With EGL, you can use high-level constructs to create code
that will run on one of several target platforms.
The EGL development process includes the following steps:
- At development time, you write code in the EGL editor. Your code
periodically becomes an input to an internal process that validates
your work. This validation focuses on general syntax errors. If your
code fails validation, error marks are displayed in the editor.
- When you save source code that has no syntax errors, the validated
code is written to intermediate representation (IR) files, which represent
the compiled form of the EGL source. EGL build is the
process of validating and compiling EGL source and then writing the
compiled output to IR files.
- In IBM® Rational® EGL
Community Edition,
the IR files are an input to EGL generation, which is
the following internal process:
- Validation of your work for its conformance to a particular target
runtime; for example, for use in a browser.
- Generation of source code as JavaScript™,
to use in a browser, or as Java™,
to use as a Web service implementation. With the commercial EGL products,
you can also create COBOL output.
When you save code, EGL generation occurs automatically. You
control the process by specifying the following files:
- A build file (.eglbld), which includes details
about what is being generated. The most important element in the build
file is the EGL build descriptor. When you first use
EGL, you might accept the default values that are specified for the
build descriptor; as you become familiar with EGL, you might work
in the Build Descriptor editor to customize that element.
- An EGL deployment descriptor (file extension .egldd),
which is used to control aspects of service access and service deployment.
Rational EGL Community Edition includes
two forms of the generated output: one for use by the EGL debugger,
and a second, which lacks debugging detail, for deployment to a target
platform.
- With a few keystrokes, you can invoke EGL deployment,
which readies the code for deployment.
When you work with EGL, you specify some details for use at run
time and some details for use by the EGL system code:
- The runtime details are similar to the details that you might
specify in any computer language. For example, you might indicate
that a given variable is of type INT (an integer). By indicating that
a given variable is an integer, you might ensure that the runtime
value is limited to integer values and that a particular subset of
operations can be applied to the variable; for example, addition and
multiplication.
- The system code details (specifically, those about the EGL builder
and generator) are in the form of properties or annotations.
By specifying these details, you can structure some aspect of the
output source code at a more detailed level than you can when you
customize the EGL build descriptor.