The output of EGL generation largely depends on whether you are generating
COBOL, Java, or a Java wrapper. The next table shows the file names of
generated output that do not come from a specific EGL part.
Output type | File name |
Build plan | aliasBuildPlan.xml |
Enterprise JavaBean (EJB) session bean | aliasEJBHome.java for the home interface, aliasEJB.java for the remote bean interface, and aliasEJBBean.java for the bean implementation |
J2EE environment file | alias-env.txt |
Program properties file | alias.properties |
Results file | alias_Results_timeStamp.xml |
Other characteristics of alias are determined by the kind of output:
For details on file names, see the appropriate reference topic:
Related concepts
Build plan
Enterprise JavaBean (EJB) session bean
Generated output
Generation
J2EE environment file
Program properties file
Results file
Related reference
Output of COBOL generation
Output of Java program generation
Output of Java wrapper generation
The COBOL generation outputs for iSeries include a COBOL program, a results file (which includes status information on EGL generation and preparation), and a build plan (if the build descriptor option buildPlan is set to yes). For additional details, see the EGL Server Guide for iSeries, which is available in the help system.
Related concepts
COBOL program
Development process
Program part
Results file
Source of additional information on EGL
Related tasks
Generating for COBOL
Related reference
buildPlan
callLink element
Generated output (reference)
Output of Java program generation
Output of Java wrapper generation
The output of Java server program generation is as follows:
You can use the EGL generator to generate entire Java programs. Programs and records are generated as separate Java classes. Functions are generated as methods in the program. Data items and structure items are generated as fields of the record or program class to which they belong.
The following table shows the names of the various types of generated Java
parts:
Names of generated Java parts | |
Part type and name | What is generated |
---|---|
Program named P | A class named P in P.java |
Function named F in program P | A method of the P class called $funcF in P.java |
Record named R | A class named EzeR in EzeR.java |
Basic record named R, parameter to Function F | A class named Eze$paramR in Eze$paramR.java |
Linkage options part named L | Linkage properties file named L.properties |
Library named Lib | A class named Lib in Lib.java |
DataTable named DT | A class named EzeDT in EzeDT.java |
Form named F | A class named EzeF in EzeF.java |
FormGroup named FG | A class named FG in FG.java |
If the naming format would cause two names to be identical, EGL adds a suffix to each file generated after the first. The suffix as follows:
$vn
where
Related concepts
Build plan
J2EE environment file
Java program, page handler, and library
Linkage properties file
Program properties file
Results file
Related reference
callLink element
The output of Java wrapper generation is as follows:
You can use the generated beans to wrap calls to server programs from non-EGL Java classes such as servlets, EJBs, or Java applications. The following types of classes are generated:
The following table shows the names of the various types of generated Java
wrapper parts:
Names of generated Java wrapper parts | |
Part type and name | What is generated |
---|---|
Program named P | A class named PWrapper in PWrapper.java |
Record named R used as a parameter | A class named R in R.java |
Substructured area S in record R used as a parameter | A class named R.S in R.java |
Linkage options part named L | Linkage properties file named L.properties |
When you request that a program part be generated as a Java wrapper, EGL produces Java class for each of the following executables:
In addition, the class generated for each record includes an inner class (or a class within an inner class) for each structure item that has these characteristics:
Each generated class is stored in a file. The EGL generator creates names used in Java wrappers as follows:
If one of the parameters to the program is a record, EGL generates a wrapper class for that variable as well. If program Prog has a record parameter with a typeDef named Rec, the wrapper class for the parameter will be called Rec. If the typeDef of a parameter has the same name as the program, the wrapper class for the parameter will have a "Record" suffix.
The generator also produces a wrapper if a record parameter has an array item and the item has other items under it. This substructured array wrapper becomes an inner class of the record wrapper. In most cases, a substructured array item called AItem in Rec will be wrapped by a class called Rec.AItem. The record may contain two substructured array items with the same name, in which case the item wrappers are named by using the qualified names of the items. If the qualified name of the first AItem is Top1.AItem and the qualified name of the second is Top2.Middle2.AItem, the classes will be named Rec.Top1$_aItem and Rec.Top2$_middle2$_aItem. If the name of a substructured array is the same as the name of the program, the wrapper class for substructured array will have a Structure suffix.
Methods to set and get the value of low-level items are generated into each record wrapper and substructured array wrapper. If two low-level items in the record or substructured array have the same name, the generator uses the qualified-name scheme described in the previous paragraph.
Additional methods are generated into wrappers for SQL record variables. For each item in the record variable, the generator creates methods to get and set its null indicator value and methods to get and set its SQL length indicator.
You can use the Javadoc tool to build a classname.html file once the the class has been compiled. The HTML file describes the public interfaces for the class. If you use HTML files created by Javadoc, be sure that it is an EGL Java wrapper. HTML files generated from a VisualAge Generator Java wrapper are different from those generated from an EGL Java wrapper.
An example of a record part with a substructured array is as follows:
Record myRecord type basicRecord 10 MyTopStructure[3]; 15 MyStructureItem01 CHAR(3); 15 MyStructureItem02 CHAR(3); end
In relation to the program part, the output file is named as follows:
aliasWrapper.java
where
In relation to each record declared as a program parameter, the output file is named as follows:
recordName.java
where
In relation to a substructured array, the name and position of the inner class depends on whether the array name is unique in the record:
recordName.siName
where
Topname$_Secondname$_Siname
where
If another, same-named array is immediately subordinate to the highest level of the record, the inner class is also within the record class and is named as follows:
Topname$_Siname
where
Finally, consider the following case: a substructured array has a name that is not unique in the record, and the array is subordinate to another substructured array whose name is not unique in the record. The class for the subordinate array is generated as an inner class of an inner class.
When you generate a Java wrapper, you also generate a Java properties file and a linkage properties file if you request that linkage options be set at run time.
Related concepts
Build plan
Enterprise JavaBean (EJB) session bean
Java wrapper
Linkage options part
Linkage properties file
Results file
Related tasks
Generating Java wrappers
Related reference
callLink element
Java wrapper classes
(C) Copyright IBM Corporation 1992, 2005. All Rights Reserved.