Ad/2010-08-01 Concrete Syntax for a uml action Language for Foundational uml (Alf) Second Revised Submission

9.1Overview

{

'activity' = (Activity)(this.types[1]);

group.activityExecution = this;

this.activationGroup = group;

group.activation('activity'.node, 'activity'.edge);

}

Syntax

Block(b: Block)
= "{" StatementSequence(b) "}"

StatementSequence(b: Block)
= { DocumentedStatement(b.statement) }

DocumentedStatement(s: Statement)
= [ DocumentationComment(s.documentation) ] Statement(s)

Statement(s: Statement)
= AnnotatedStatement(s)
| InLineStatement(s)
| BlockStatement(s)
| EmptyStatement(s)
| LocalNameDeclarationStatement(s)
| ExpressionStatement(s)
| IfStatement(s)
| SwitchStatement(s)
| WhileStatement(s)
| DoStatement(s)
| ForStatement(s)
| BreakStatement(s)
| ReturnStatement(s)
| AcceptStatement(s)
| ClassifyStatement(s)

Figure 9 42 Base Abstract Syntax for Statements and Blocks

1. 
   SyntaxElement see Subclause 6.5
   
2. 
   DocumentedElement see Subclause 6.5
   
3. 
   DocumentationComment see Subclause 7.4.2
   
4. 
   AnnotatedStatement see Subclause 9.2
   
5. 
   InLineStatement see Subclause 9.3
   
6. 
   BlockStatement see Subclause 9.4
   
7. 
   EmptyStatement see Subclause 9.5
   
8. 
   LocalNameDeclarationStatement see Subclause 9.6
   
9. 
   ExpressionStatement see Subclause 9.7
   
10. 
    IfStatement see Subclause 9.8
    
11. 
    SwitchStatement see Subclause 9.9
    
12. 
    WhileStatement see Subclause 9.10
    
13. 
    DoStatement see Subclause 9.11
    
14. 
    ForStatement see Subclause 9.12
    
15. 
    BreakStatement see Subclause 9.13
    
16. 
    ReturnStatement see Subclause 9.14
    
17. 
    AcceptStatement see Subclause 9.15
    
18. 
    ClassifyStatement see Subclause 9.16
    

Unless otherwise annotated (see Subclause 9.3), all the statements in a statement sequence are executed sequentially in order. See also the discussion for each kind of statement in the following subclauses.

Integration with UML

An Alf statement sequence can be inserted into a UML model using an opaque behavior (UML Specification, Subclause 13.3.20) in which the unprocessed text of the Alf statement sequence is used as the body of the opaque behavior and the corresponding language string is "Alf". Opaque behaviors may be used in a UML model any place that a behavior is allowed.

An Alf statement sequence can also be inserted into a UML activity using an opaque action (UML Specification, Subclause 11.3.26) in which the unprocessed text of the Alf statement sequence is used as the body of the opaque action and the corresponding language string is "Alf". The input and output pins of such an action must all be named. The input pins are considered to be the assigned sources (see Subclause 8.1) for their names within the statement sequence. The names of the output pins may be assigned within the statement sequence, and their assigned sources at the end of the statement sequence provide the values for the corresponding output pins. The names of other visible model elements (qualified as necessary) may also be used as usual within the statement sequence (see Subclause 8.3.3 on name expressions).

The execution semantics of Alf statements are given formally by the mapping to UML activity graphs given in the following subclauses. An Alf statement sequence can therefore always be compiled to a part or all of a UML activity model (which does not necessarily need to be the same as the formal mapping, but must have an equivalent effect to it—see Subclause 2.2).

Indeed, the semantics of an opaque behavior that only includes unprocessed Alf text in its body may be considered equivalent to an activity with the same parameters as the opaque behavior, containing the activity nodes and edges mapped from the body of the opaque behavior. The semantics of an opaque action that only includes unprocessed Alf text in its body may be considered equivalent to a structured activity node with the same input and output pins as the opaque action, containing the activity nodes and edges mapped from the body of the opaque behavior.

Local Names

Local names (see Subclause 8.1) are used in Alf to denote intermediate values in computations within a statement sequence. The scope of such local names is generally from the point at which they are defined lexically to the end of the statement sequence, though there are special rules for conditional statements (see Subclauses 9.8 and 9.9) and loop statements (see Subclauses 9.10, 9.11 and 9.12). Alf does not provide hierarchical scoping of local names defined in nested blocks.

The assignments of and references to local names in an Alf input text need to be mapped to appropriate object flow edges from the mapping of the appropriate assignment to the mapping of the reference that requires that assigned value. The assigned source for a local name is the Alf element that, when executed, will provide the actual assigned value for that local name. If the assigned source for a local name is known, then a reference to the assigned value of that local name can be mapped to an object flow from the mapping of the assigned source.

Since local names can be reassigned in Alf (see Subclause 8.8 on assignment expressions), the assigned source for any given local name can be different at different points in a statement sequence. In order to carry out the above mapping, it must always be possible to determine at most one assigned source for any local name at any point in the text. The general rule is that the latest assignment “lexically previous” to a reference to a local name is used as the assigned source for that reference. However, some care must be given to carefully defining this term when assignments are allowed within control structures such as conditional and looping statements.

The static semantic rules for local names provide the necessary formalization for determining assigned sources. As with other static semantic rules, these rules are applied by traversing the abstract syntax tree of a statement sequence. At each point in this traversal, the rules determine the set of local names with assigned sources. A name that has no assigned source is known as an unassigned name.

When the analysis reaches a specific node in the abstract syntax tree representing a certain kind of Alf construct, a local name with an assigned source is said to have that source before the construct in question. If the name is unassigned, then it said to be unassigned before the construct. The assignment rules then determine what the assigned source for the name is after that construct, continuing the traversal to the next node in the parse tree. The rules may also place restrictions on what assignments are allowed, in order that the analysis may be carried out.

NOTE. The assignment rules for statements often refer to the rules for assigned values before and after the evaluation of expressions within the statement. These rules are given for each kind of expression in the subclauses of Clause 8.

The assigned source for a name before the first statement of a statement sequence is the same as the assigned source before the statement sequence. The assigned source for a name before each statement other than the first is the assigned source after the previous statement (as determined by the rules of the following subclauses for each kind of statement). The assigned source for a name after a statement sequence is the same as the assigned source after the last statement of the sequence.

Note that a block in Alf is basically just a syntactic delineation of a sequence of statements and does not introduce new semantics as such. In particular, a block does not introduce a lexically nested scope for local names. That is, local names with assigned sources lexically previous to and visible from the statement sequence of a block cannot be redefined in the block (as with a local name declaration statement—see Subclause 9.6), though they can generally be reassigned unless there is some specific rule otherwise (such as the special rules for reassignment of local names in a parallel for statement—see Subclause 9.12).