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

Specification of the ATL Virtual Machine
operand stack. Prior to each iteration, a new element of the reference collection is pushed onto the operand
stack. The enditerate instruction only aims to mark the end of an iterative block (it is not associated with any
particular treatment).
The ATL language defines three main iterative instructions: select, collect and iterate. The select
instruction enables to select a subset of the reference collection. Elements of this reference collection are
filtered according to a boolean expression. A select instruction produces an output collection which size is
equal or less than the one of the reference collection. These elements moreover have the same type that
those of the reference collection. As opposed to the select one, the collect instruction produces a
homogeneous Sequence of elements whose cardinal is equal to the reference collection one. Although the
returned sequence is to be homogeneous, the type of its elements may be different from the one of
reference collection elements. A collect may, for instance, be used on a model elements collection to
compile the values of a given property of these elements. It can also be used on any collection of cardinal n
to easily produce a new Sequence composed of n identical constant values.
We propose here to illustrate the compilation of both select and collect ATL instructions. We first
consider an example making use of the select function. We introduce, in this scope, a set of integral
values:
let int_set: Set(Integer) = Set{8, 15, 6, 3, 19}
It is now possible to operate a selection on int_set in order to build the subset of values that are greater
than 10. This selection corresponds to the following ATL statement:
int_set->select(e | e > 10);
This simple ATL selection can be compiled into the following ATL virtual machine instructions set:
0
1
2
3
4
5
6
7
8
9
10
11
12
13
Performing a select operation on an ATL set results in a new set that contains the only elements that fulfil
the condition specified with the boolean expression. The first step therefore consists in instantiating a new
empty set. This is achieved with instructions 0 to 2. Assuming that the reference set is stored within local
variable 1, it can be then loaded on top of the operand stack (instruction 3). The iterate instruction uses this
set as its reference collection.
Prior to each iteration, a new element of the collection is implicitly pushed onto the operand stack by the ATL
virtual machine. This element is saved into local variable 2 and made available again on top of the operand
stack by instructions 5 and 6. Next step corresponds to the evaluation of the ATL boolean expression (e >
10). For this purpose, the 10 integral constant is pushed onto the operand stack (instruction 7) and the >
operation is called with the current element as context and the integral constant as parameter (instruction 8).
This invocation returns a boolean value on top of the operand stack. Next instruction calls the not operation
with the previously returned boolean value as context (instruction 9). This new invocation pushes a new
boolean value onto the operand stack. This value is then tested by a conditional branch (instruction 10). If
the value is true (i.e. the ATL condition is not fulfilled), the execution flow is redirected to instruction 13
which corresponds to the end of the current iteration. Otherwise, if the ATL condition is fulfilled, execution
proceeds from the next instruction (instruction 11). This instruction loads the current collection element onto
Page 48 / 62