|
|
| (123 intermediate revisions by 2 users not shown) |
| Line 1: |
Line 1: |
| − | = Introduction = | + | <span style="font-size:smaller;">< [[EDT| EDT wiki home]]</span> |
| | + | |
| | + | This overview introduces the EGL language as defined in EGL Core and as extended by Eclipse IDE for the EGL Web Developer. Reference details are in the EDT help system, which is made available when you install a download from the following site: [http://www.eclipse.org/edt/download/ www.eclipse.org/edt/download/]. |
| | | | |
| | In many ways, EGL is like other programming languages. It includes familiar constructs such as loops and transfers of control. It is built on a set of '''types''', each of which defines the operations that are available for each value of the type. Last, it involves a process for validating source code and for converting the source code into a less abstract form, closer to the runtime need. | | In many ways, EGL is like other programming languages. It includes familiar constructs such as loops and transfers of control. It is built on a set of '''types''', each of which defines the operations that are available for each value of the type. Last, it involves a process for validating source code and for converting the source code into a less abstract form, closer to the runtime need. |
| Line 5: |
Line 7: |
| | EGL is special in its reliance on '''stereotypes''', which are declarations used by the software that transforms the source code to another form such as Java or JavaScript. | | EGL is special in its reliance on '''stereotypes''', which are declarations used by the software that transforms the source code to another form such as Java or JavaScript. |
| | | | |
| − | Stereotypes offer simplicity. First, they ensure that the output created for a source-code element such as "Handler" includes details for a particular use; for example, to be runnable on a full-page web browser. The developer who writes a customized Handler element and declares the appropriate stereotype does not need to know a lot about a browser to write the code. He can rely on the pre-tested logic that an EGL JavaScript generator creates automatically. | + | Stereotypes offer simplicity. First, they ensure that the output created for a source-code element such as "Handler" includes details for a particular use; for example, to be runnable on a full-page web browser. The developer who writes a custom Handler element and declares the appropriate stereotype does not need to know a lot about a browser to write the code. He can rely on the pre-tested logic that is created by an EGL JavaScript generator. The pre-tested logic supplements the custom logic. |
| | | | |
| − | Second, stereotypes provide a way to extend the language. The creation of a new kind of stereotype enables an existing source-code element to have an alternative use. For example, a future stereotype might allow a developer to write a customized Handler element and then to create output for a mobile device that runs under the Android operating system. This alternative option requires that the extender create Java classes that supplement existing logic. | + | Second, stereotypes provide a way to extend the language. The creation of a new kind of stereotype enables an existing source-code element to have an alternative use. For example, a future stereotype might allow a developer to write a custom Handler element and then to create output for a mobile device that runs under the Android operating system. This alternative option requires that the extender create Java classes that add to the existing generator logic. |
| | | | |
| − | Stereotypes are best understood in the context of EGL types and values.<br>
| + | The mechanism for using stereotypes is provided by EGL Core, which includes the basic rules of EGL syntax. Most stereotypes are provided by an EGL extension, and the first extension is Eclipse IDE for the EGL Developer.<br> |
| | | | |
| − | == General comments on type and values ==
| + | We describe stereotypes in the first of the following pages and proceed to other aspects of the language: <br> |
| | | | |
| − | In general usage, a '''type''' such as integer or string defines a set of values and a set of operations that can be applied to those values. For example, integers are whole numbers that can be added, subtracted, and so forth; and the number 5 is a value of that type.
| + | *[[EDT:Language Overview02|EGL types and values]] |
| | + | *[[EDT:Language Overview03|Packages and type-name resolution]] |
| | + | *[[EDT:Language Overview04|Syntax and scope]] |
| | | | |
| − | The meaning is much the same in EGL, where every value is “of a type.” The type defines the structure of the value and the set of operations that can be applied to the value.
| + | <br> <br> |
| | | | |
| − | Types can be categorized in different ways, and we initially distinguish between reference and value types:
| + | |
| − | | + | |
| − | *A '''reference type''' defines an '''object''', which is a value in a memory area that was separately allocated to hold the value. The object is referenced from some logic and is an instance of the type. In this case, the words "value," "object," and "instance" are interchangeable.
| + | |
| − | *A '''value type '''defines a value that is embedded in an object.
| + | |
| − | | + | |
| − | A '''field declaration''' is a coded statement that declares a value in a memory area. If the value is based on a reference type, the memory area either represents a null or holds an address that points to the value. If the value is based on a value type, the memory area contains the value itself.
| + | |
| − | | + | |
| − | A field declaration typically includes an identifier that names the memory area. If the code that embeds the field declaration is allowed to update the area, the identifier is a '''variable'''. If the update is disallowed, the identifier is a '''constant'''. Later in this overview is a field declaration that does not name a memory area at all. Such a field declaration is said to be '''anonymous'''.
| + | |
| − | | + | |
| − | Consider the following field declarations:
| + | |
| − | <pre> // variable declaration
| + | |
| − | NumberOfCars INT;
| + | |
| − |
| + | |
| − | // constant declaration
| + | |
| − | const MINIMUMNUMBER INT = 2; </pre>
| + | |
| − | The type is each case is INT, which is a value type for four-byte integers. The first statement declares a '''value variable''', the second declares a '''value constant'''.
| + | |
| − | | + | |
| − | For a second example, you might declare a list of five integers by coding a statement like one of these:<br>
| + | |
| − | <pre> // variable declaration
| + | |
| − | NumberOfVehicles INT[5];
| + | |
| − | | + | |
| − | // constant declaration
| + | |
| − | const MINIMUMNUMBERS INT[5] = [1,2,3,4,5];</pre>
| + | |
| − | The type in this case is INT List or INT[], which is a reference type. The first statement declares a '''reference variable''', which means that you can assign a different list to <code>NumberOfVehicles</code> later. Incidentally, you can also change the values inside the list and can change the number of elements.
| + | |
| − | | + | |
| − | The second statement declares a '''reference constant''', which means that you cannot assign a different list to <code>MINIMUMNUMBERS</code>. However, even in this case, you can alter the values inside the list and can change the number of elements.
| + | |
| − | | + | |
| − | The behavior is consistent because each declaration in the second example identifies a memory area that contains an address of a second memory area. The constant is only constant in the sense that the area identified as <code>MINIMUMNUMBERS</code> must always contain the same address, which refers to the same list. The following, subsequent assignment is not valid even though the values are the same:<br>
| + | |
| − | <pre> // An invalid assignment
| + | |
| − | MINIMUMNUMBERS = [1,2,3,4,5]; </pre>
| + | |
| − | == EGL native types ==
| + | |
| − | | + | |
| − | EGL Core defines a set of '''native types''', which are implemented only by extensions such as Eclipse IDE for EGL Developers. The most elemental are the '''simple types'''. They have no sub-fields and can be categorized as follows:
| + | |
| − | | + | |
| − | *Character types
| + | |
| − | *Timestamp types
| + | |
| − | *Large object types
| + | |
| − | *Numeric types
| + | |
| − | *Miscellaneous types:<br>
| + | |
| − | **BOOLEAN, which is the basis of a field that contains the logical true or false.
| + | |
| − | **ANY, which is the basis of an instance that itself can reference a value of any type.
| + | |
| − | | + | |
| − | The following native types are also built into EGL Core for implementation by an extension:
| + | |
| − | | + | |
| − | *List types, each of which is the basis of a list. A list is a dynamic array: an ordered sequence of elements that can be increased or decreased in number and otherwise updated at run time.
| + | |
| − | *Dictionary type, which is the basis of a dictionary. A dictionary is composed of key-value<br>pairs that can be increased or decreased in number and otherwise updated at run time.
| + | |
| − | | + | |
| − | == EGL classifiers ==
| + | |
| − | | + | |
| − | EGL provides a variety of '''classifiers''', each of which is a kind of type. The capabilities of a classifier are made available to your code in various situations; most often, when you define a custom type that is based on the classifier.
| + | |
| − | | + | |
| − | Before we list the classifiers, we consider the characteristics of the custom types and offer examples.
| + | |
| − | | + | |
| − | === Characteristics of custom types<br> ===
| + | |
| − | | + | |
| − | Depending on the classifier, a custom type can have some or all of the following characteristics:
| + | |
| − | | + | |
| − | *A header, which is always required. The header includes the classifier name; the name of the custom type; and, in some cases, a stereotype.
| + | |
| − | *The '''end''' keyword, which is the last detail in the type definition.
| + | |
| − | *A set of members:
| + | |
| − | **'''Fields''', each of which is based on a native or custom type.
| + | |
| − | **'''Functions''', each of which is a logical unit that is equivalent to a function or method in another language. EGL functions do not embed other functions.
| + | |
| − | **'''Constructors''', each of which is a logical unit that creates an instance of a reference type.<br>
| + | |
| − | | + | |
| − | === Examples of custom types ===
| + | |
| − | | + | |
| − | One classifier is Record, which enables you to define a type with multiple fields. For example, you might use this classifier to define a type named <code>CarPolicy</code>:
| + | |
| − | <pre>Record CarPolicy
| + | |
| − | thePolicyID STRING;
| + | |
| − | theCarCount INT;
| + | |
| − | theDriverCount INT;
| + | |
| − | end</pre>
| + | |
| − | You can use a type such as <code>CarPolicy</code> to declare a variable named <code>myCarPolicy</code>:
| + | |
| − | <pre>myCarPolicy CarPolicy;</pre>
| + | |
| − | The variable is called a '''record''', and you can now assign values to its fields:
| + | |
| − | <pre>myCarPolicy.thePolicyID = "ABC123";
| + | |
| − | myCarPolicy.theCarCount = 2;
| + | |
| − | myCarPolicy.theDriverCount = 2;</pre>
| + | |
| − | Another classifier is Program. You use this classifier to define a '''program''', which is a '''static type: '''a coded unit that runs and is not the basis of a variable. For example, here is the program <code>AssignPolicyValues</code>:
| + | |
| − | <pre>Program AssignPolicyValues
| + | |
| − | | + | |
| − | myCarPolicy CarPolicy;
| + | |
| − | const CONSTANT_TWO INT = 2
| + | |
| − | | + | |
| − | function main()
| + | |
| − | myCarPolicy.thePolicyID = "ABC123";
| + | |
| − | myCarPolicy.theCarCount = CONSTANT_TWO;
| + | |
| − | myCarPolicy.theDriverCount = CONSTANT_TWO;
| + | |
| − | end
| + | |
| − | end </pre>
| + | |
| − | <code>AssignPolicyValues</code> embeds fields and functions that are '''program global''', which means that they are accessible throughout the type.
| + | |
| − | | + | |
| − | The members in a custom type are typically accessible in the same type. However, if you declare a member to be '''private''', the member is protected from external access; it can be accessed only within the same type. If you do not declare a member to be private, it is said to be '''public'''.
| + | |
| − | | + | |
| − | Incidentally, EGL documentation often drops the word “type” when referring to a type that is based on a classifier other than Record. For example, <code>AssignPolicyValues</code> is said to be a “program” rather than a “Program type.”
| + | |
| − | | + | |
| − | <br>
| + | |
| − | | + | |
| − | <br>
| + | |
| − | | + | |
| − | <br>Kinds of classifiers
| + | |
| − | | + | |
| − | <br>The classifiers in EGL Core are as follows:
| + | |
| − | | + | |
| − | <br>
| + | |
| − | | + | |
| − | <br>
| + | |
| | | | |
| | | | |
| | | | |
| − | <br>
| + | [[Category:EDT]] |
| − | | + | |
| − | <br>
| + | |
| − | | + | |
| − | <br>
| + | |
This overview introduces the EGL language as defined in EGL Core and as extended by Eclipse IDE for the EGL Web Developer. Reference details are in the EDT help system, which is made available when you install a download from the following site: www.eclipse.org/edt/download/.
In many ways, EGL is like other programming languages. It includes familiar constructs such as loops and transfers of control. It is built on a set of types, each of which defines the operations that are available for each value of the type. Last, it involves a process for validating source code and for converting the source code into a less abstract form, closer to the runtime need.
Stereotypes offer simplicity. First, they ensure that the output created for a source-code element such as "Handler" includes details for a particular use; for example, to be runnable on a full-page web browser. The developer who writes a custom Handler element and declares the appropriate stereotype does not need to know a lot about a browser to write the code. He can rely on the pre-tested logic that is created by an EGL JavaScript generator. The pre-tested logic supplements the custom logic.
Second, stereotypes provide a way to extend the language. The creation of a new kind of stereotype enables an existing source-code element to have an alternative use. For example, a future stereotype might allow a developer to write a custom Handler element and then to create output for a mobile device that runs under the Android operating system. This alternative option requires that the extender create Java classes that add to the existing generator logic.
The mechanism for using stereotypes is provided by EGL Core, which includes the basic rules of EGL syntax. Most stereotypes are provided by an EGL extension, and the first extension is Eclipse IDE for the EGL Developer.
We describe stereotypes in the first of the following pages and proceed to other aspects of the language:
