ATL: Atlas Transformation Language Specification of the ... - Eclipse

Specification of the ATL Virtual Machine
int_set->iterate(e; ret : Integer = 0 | ret + e);
As a reminder, e identifies the current element of the reference collection. ret : Integer = 0
corresponds to the declaration and the initialization of the variable to be returned (ret). Finally, ret + e
specifies the operation to be iteratively performed. This ATL instruction can be compiled into the following
ATL virtual machine instructions set:
0
1
2
3
4
5
6
7
8
9
10
Similarly to the previously described ATL iterative instructions, the first step consists in allocating and
initializing the variable used to store the value to be returned. However, compared to the other iterative
instructions, this variable can be here of any ATL types. In this example, this step consists in initializing the
integral value ret to 0. This is achieved by instruction 0. Initilialized value is then stored in local variable 2
(instruction 1). Assuming that the reference set is stored within local variable 1, it is then loaded on top of the
operand stack (instruction 2). The iterate instruction (instruction 3) uses this set as its reference collection.
A new element of the reference collection is implicitly pushed onto the operand stack at the beginning of
each iteration. It is saved into local variable 3 by instruction 4. Instructions 5 and 6 respectively load the
value to be returned and the current element on top of the operand stack. The operation + is then called with
the value to be returned as context and the current element of the reference collection as parameter
(instruction 7). As a result, the operation pushes the computed value onto the operand stack. This value is
stored in local variable 2 as the value to be returned (instruction 8). Once the iteration has completed, the
content of local variable 2 is loaded onto the operand stack (instruction 10).
6.2.8 Receiving Arguments
As opposed to Java, the ATL language does not define context-less operation calls facilities. Whereas
static Java methods do not have any instance, all invoked operations in ATL are to be associated with a
specific context. As a consequence, there exist a one and only way to receive arguments for ATL operations.
The n arguments that are passed to an invoked operation are stored in the localvariabletable structure
of the stack frame created for the new operation. The table entry 0 is reserved to hold a reference to the
context in which the operation is called and the arguments are stored in local variables numbered from 1 to
n. The arguments are received in the order they were passed. As an example, consider the code of the
following ATL helper:
helper
def: firstOfTwo(i: Integer, j: Integer) : Integer = i;
This helper is defined in the context of the ATL context module and simply returns the value of its first
argument. It compiles to:
Operation int firstOfTwo(int,int)
0
The value of the operation first argument is loaded on top of the operand stack. This top value is the one to
be returned when the operation completes.
Page 50 / 62