Jump to: navigation, search

EDT:EGL Language Statements

Please see the parent of this page, EDT:EGL Language.


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
done bug 354164
2d
2d bug 353670
Return
done
done
(see Function invocation below)
done
Function invocation
done

done

Synchronous service invocation


REST Service invocation


SOAP Service invocation bug 352590(3d)


Call2
done

REST Service invocation


SOAP Service invocation bug 352591(3d)
Dedicated service invocation bug 352592(3d)
Proxy bug 346145(1d)


5d bug 353672
Label done
done
done
Transfer
done
N/S
1d
Throw
done
done
done
Try done
done
done
Case
done
done
(preprocessor doesn't pass case statement, it breaks into a series of IF statements) - no work needed
If
done
done
done
While done
done done
For done
done
done
Foreach (SQL) done N/S 0.5d bug 353671
Foreach (array)3 done bug 366884
JS: Foreach0.1d
0.5d bug 366883
Exit5
done
done
done
Continue
done

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
done
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


  1. 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 reference variables of the same type, and it results in the target being assigned a deep copy of the source's value. The deep copy is invalid for JavaObject and JavaScriptObject ExternalTypes. If/when we support structured records, we might not support move byName on them because of the complex (unclean) design.
  2. EDT doesn't have called programs, but services and native programs can be called.
  3. EDT's foreach statement will support iterating over an array.
  4. 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;.
  5. EDT won't support exit stack.
  6. See the discussion of nullability below.
  7. See the discussion of array declarations below.



Nullability

Variable declarations, function parameters, and function return types may end with a question mark 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 can 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.


You can't assign null to something that's not nullable.  We'll give a validation error on notNullableVariable = null; and a runtime error on notNullableVariable = nullableVariable; when the nullableVariable is null.


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 };".