Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.
Difference between revisions of "EDT:EGL Language Statements"
| Line 10: | Line 10: | ||
| bgcolor="#999999" align="center" | '''Java''' | | bgcolor="#999999" align="center" | '''Java''' | ||
|- | |- | ||
| − | | bgcolor="#cccccc" | ''Variable declaration (including nullability<sup>6</sup> and array declarations<sup>7</sup>)''<br> | + | | bgcolor="#cccccc" | ''Variable declaration (including nullability<sup>6</sup> and array declarations<sup>7</sup>)''<br> |
| <br>done | | <br>done | ||
| done<br> | | done<br> | ||
| Line 233: | Line 233: | ||
#New syntax will allow setting annotations on declarations without the use of curly braces. In RBD we usually do '''<span style="font-family: times,'times new roman',serif;">x int {myAnnotation = 3};</span>''' but another way to do the same thing is '''<span style="font-family: times,'times new roman',serif;">x int {@myAnnotation{3}};</span>'''. In EDT we will allow that to be outside of curly braces and before the declaration, for example '''<span style="font-family: times,'times new roman',serif;">@myAnnotation{3} x int;</span>'''. | #New syntax will allow setting annotations on declarations without the use of curly braces. In RBD we usually do '''<span style="font-family: times,'times new roman',serif;">x int {myAnnotation = 3};</span>''' but another way to do the same thing is '''<span style="font-family: times,'times new roman',serif;">x int {@myAnnotation{3}};</span>'''. In EDT we will allow that to be outside of curly braces and before the declaration, for example '''<span style="font-family: times,'times new roman',serif;">@myAnnotation{3} x int;</span>'''. | ||
#EDT won't support '''exit stack'''. | #EDT won't support '''exit stack'''. | ||
| − | #See the discussion of nullability below.<br> | + | #See the discussion of nullability below.<br> |
#See the discussion of array declarations below.<br> | #See the discussion of array declarations below.<br> | ||
| − | <br> | + | <br> |
| − | === Nullability<br> === | + | === Nullability<br> === |
| − | Variables may be declared with a question mark following the name of the type to indicate that they're nullable. Nullability means that a variable may really be null. It's not an "I'm null" flag like in RBD. Even reference variables may be nullable.<br> | + | Variables may be declared with a question mark following the name of the type to indicate that they're nullable. <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">Nullability means that a variable may really be null. It's not an "I'm null" flag like in RBD. Even reference variables may be nullable.</span><br> |
| − | A NullValueException will be thrown if you try to access a field or function of a null variable, even a record. A NullValueException will be thrown if a null variable is an operand to a math operator, an array access, a substring access, a comparison, or a bitwise operator. The string concatenation operators will work the same as in RBD with respect to nulls. :: treats null as the empty string, and ?: results in null if either operand is null. A question mark won't be allowed on the second operand of the AS and ISA operators (the name of the type). <br> | + | <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">A NullValueException will be thrown if you try to access a field or function of a null variable, even a record. A NullValueException will be thrown if a null variable is an operand to a math operator, an array access, a substring access, a comparison, or a bitwise operator.</span> The string concatenation operators will work the same as in RBD with respect to nulls. :: treats null as the empty string, and ?: results in null if either operand is null. <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">A question mark won't be allowed on the second operand of the AS and ISA operators (the name of the type).</span><br> |
| − | A validation check will ensure that things which can't be instantiated (interfaces, and types with private default constructors) must be declared nullable. Constructors can be defined in ExternalTypes and handlers.<br> | + | <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">A validation check will ensure that things which can't be instantiated (interfaces, and types with private default constructors) must be declared nullable. Constructors can be defined in ExternalTypes and handlers.</span><br> |
=== Array Declarations<br> === | === Array Declarations<br> === | ||
| − | ==== Arrays can't be declared with an initial size ==== | + | ==== Arrays can't be declared with an initial size ==== |
| − | The size of an array isn't part of its type. That's why in RBD you can declare an int[5] and then assign [1,2,3] to it -- you change its length from 5 to 3. In EDT, all arrays must be declared without an initial size. | + | <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">Arrays can't be declared with an initial size.</span> The size of an array isn't part of its type. That's why in RBD you can declare an int[5] and then assign [1,2,3] to it -- you change its length from 5 to 3. In EDT, all arrays must be declared without an initial size. |
| − | A size is still allowed on a new expression when you create an array. | + | A size is still allowed on a new expression when you create an array. |
| − | Here are some example array declarations for EDT: | + | Here are some example array declarations for EDT: |
| − | *a int[] = new int[3]; | + | *a int[] = new int[3]; |
| − | *a int[] = [1, 2, 3]; | + | *a int[] = [1, 2, 3]; |
| − | *a int[]; // This is an array of length zero. | + | *a int[]; // This is an array of length zero. |
| − | *a int[]?; // Initially null. | + | *a int[]?; // Initially null. |
*a int[]? {}; // This is an array of length zero. | *a int[]? {}; // This is an array of length zero. | ||
| − | ==== Initializing arrays with literals ==== | + | ==== Initializing arrays with literals ==== |
| − | Array initializers must be efficient. "a int[] = [1, 2, 3];" means make an array of three elements, values 1 then 2 then 3. Do not make a zero-length array, then make an array from the literal, and throw away the original zero-length array. | + | Array initializers must be efficient. "a int[] = [1, 2, 3];" means make an array of three elements, values 1 then 2 then 3. Do not make a zero-length array, then make an array from the literal, and throw away the original zero-length array. |
| − | ==== Initializing arrays with set-values blocks ==== | + | ==== Initializing arrays with set-values blocks ==== |
| − | + | <span style="background: none repeat scroll 0% 0% rgb(255, 165, 0);">A set-values block on an array declaration causes the values within the block to be appended to the array. For example "a int[] { 1, 2, 3 };" results in [1, 2, 3].</span> The block has a different effect in RBD: it sets elements rather than appending them, so you'd get an index out of bounds exception on the declaration "a int[] { 1, 2, 3 };". | |
Revision as of 16:51, 23 August 2011
Please see the parent of this page, EDT:EGL Language.
Contents
Statements (Table 5)
| Statements | Core | JavaScript | Java |
| Variable declaration (including nullability6 and array declarations7) |
done |
done |
done |
| Annotations before declarations4 | 6d | none | none |
| Const declaration | done |
done |
done |
| Use | |
done |
done |
| Assignment | done |
done |
done |
| Move1 | 1d bug 354164 |
2d |
2d bug 353670 |
| Return | done |
done (see Function invocation below) |
done |
| Function invocation | done |
Synchronous service invocation |
REST Service invocation
SOAP Service invocation bug 352590(3d) |
| Call2 | done |
REST Service invocation
SOAP Service invocation bug 352591(3d) |
5d bug 353672 |
| Label | done (remove label field from ConditionalStatement) bug 354163 |
done |
done |
| Transfer | done |
N/S |
1d |
| Throw | done |
JS:Throws0.2d |
done |
| Try | done |
done |
done |
| Case | done |
JS: Case0.2d |
(preprocessor doesn't pass case statement, it breaks into a series of IF statements) - no work needed |
| If | done |
JS: If 0.1d |
done |
| While | done |
JS: While0.2d |
done |
| For | done |
done for 0.7.0 |
done |
| Foreach (SQL) | done | N/S | 0.5d bug 353671 |
| Foreach (array)3 | 1d |
JS: Foreach0.1d |
0.5d |
| Exit5 | done |
done |
done |
| Continue | done |
|
done |
| Empty statement (a semicolon) | done |
done |
done |
| Add | done |
N/S |
1d bug 353671 |
| Close | done |
N/S |
0.5d bug 353671 |
| Delete | done |
N/S |
1d bug 353671 |
| Get | done |
N/S |
2d bug 353671 |
| Replace | done |
N/S |
2d bug 353671 |
| Execute | done? |
N/S |
1d bug 353671 |
| Prepare | done? |
N/S |
1d |
| Open | done? |
N/S |
2d bug 353671 |
| FreeSQL | done? |
N/S |
0.5d |
| Goto |
done |
N/S | N/S |
| Set |
done |
N/S | N/S |
| Converse |
done |
N/S | N/S |
| Display |
done |
N/S | N/S |
| Print |
done |
N/S | N/S |
| Forward |
done |
N/S | N/S |
| Show |
done |
N/S | N/S |
| OpenUI |
done |
N/S | N/S |
Notes on Table 5
- EDT won't support every variation of RBD's move statement. There will be support for move byName, move for, and move for all. A move statement without one of the additional keywords is only allowed between two references, and it results in the target being assigned a copy of the source's value. If/when we support structured records, we might not support move byName on them because of the complex (unclean) design.
- EDT doesn't have called programs, but services and native programs can be called.
- EDT's foreach statement will support iterating over an array.
- New syntax will allow setting annotations on declarations without the use of curly braces. In RBD we usually do x int {myAnnotation = 3}; but another way to do the same thing is x int {@myAnnotation{3}};. In EDT we will allow that to be outside of curly braces and before the declaration, for example @myAnnotation{3} x int;.
- EDT won't support exit stack.
- See the discussion of nullability below.
- See the discussion of array declarations below.
Nullability
Variables may be declared with a question mark following the name of the type to indicate that they're nullable. Nullability means that a variable may really be null. It's not an "I'm null" flag like in RBD. Even reference variables may be nullable.
A NullValueException will be thrown if you try to access a field or function of a null variable, even a record. A NullValueException will be thrown if a null variable is an operand to a math operator, an array access, a substring access, a comparison, or a bitwise operator. The string concatenation operators will work the same as in RBD with respect to nulls. :: treats null as the empty string, and ?: results in null if either operand is null. A question mark won't be allowed on the second operand of the AS and ISA operators (the name of the type).
A validation check will ensure that things which can't be instantiated (interfaces, and types with private default constructors) must be declared nullable. Constructors can be defined in ExternalTypes and handlers.
Array Declarations
Arrays can't be declared with an initial size
Arrays can't be declared with an initial size. The size of an array isn't part of its type. That's why in RBD you can declare an int[5] and then assign [1,2,3] to it -- you change its length from 5 to 3. In EDT, all arrays must be declared without an initial size.
A size is still allowed on a new expression when you create an array.
Here are some example array declarations for EDT:
- a int[] = new int[3];
- a int[] = [1, 2, 3];
- a int[]; // This is an array of length zero.
- a int[]?; // Initially null.
- a int[]? {}; // This is an array of length zero.
Initializing arrays with literals
Array initializers must be efficient. "a int[] = [1, 2, 3];" means make an array of three elements, values 1 then 2 then 3. Do not make a zero-length array, then make an array from the literal, and throw away the original zero-length array.
Initializing arrays with set-values blocks
A set-values block on an array declaration causes the values within the block to be appended to the array. For example "a int[] { 1, 2, 3 };" results in [1, 2, 3]. The block has a different effect in RBD: it sets elements rather than appending them, so you'd get an index out of bounds exception on the declaration "a int[] { 1, 2, 3 };".