Ad/2010-08-01 Concrete Syntax for a uml action Language for Foundational uml (Alf) Second Revised Submission
Download 1.74 Mb.
|
- Navigate this page:
- 8.6.2Arithmetic Expressions
- 8.6.3Shift Expressions
- 8.6.4Relational Expressions
- 8.6.5Classification Expressions
- 8.6.6Equality Expressions
- 8.6.7Logical Expressions
- 8.6.8Conditional Logical Expressions
8.6Binary Expressions8.6.1OverviewA binary expression is an expression with two operand expressions and an operator that performs some action on the values produced by the operands. Binary operators include arithmetic, relational, equality, logical and conditional logical operators. Classification expressions, which test if a value has a certain type, are also syntactically similar to binary expressions, except that one of the “operands” of a classification expression is actually a type name. Syntax See the concrete syntax for each kind of binary expression in subsequent subclauses. 
Figure 8 32 Base Abstract Syntax for Binary Expressions Semantics Except in the case of conditional logical expressions (see Subclause 8.6.8), the operand expressions of a binary expression are evaluated concurrently and then the operator is applied to their results. Because of the concurrent evaluation of the operands, it is not legal to assign the same local name in both operand expressions. The semantics of each kind of binary expression are discussed further in subsequent subclauses.
amount * interestRate duration / timeStep length % unit initialPosition + positionChange basePrice - discount Syntax UnaryOrMultiplicativeExpression(e: Expression) = UnaryExpression(e) | MultiplicativeExpression(e) MultiplicativeExpression(e: ArithmeticExpression) = UnaryOrMultiplicativeExpression(e.operand1) MultiplicativeOperator(e.operator) UnaryExpression(e.operand2) MultiplicativeOperator(op: String) = "*"(op) | "/"(op) | "%"(op) UnaryOrArithmeticExpression(e: Expression) = UnaryOrMultiplicativeExpression(e) | AdditiveExpression(e) AdditiveExpression(e: ArithmeticExpression) = UnaryOrArithmeticExpression(e.operand1) AdditiveOperator(e.operator) UnaryOrMultiplicativeExpression(e.operand2) AdditiveOperator(op: String) = "+"(op) | "-"(op) 
Figure 8 33 Abstract Syntax of Arithmetic Expressions Cross References
Semantics The operand expressions for an arithmetic operator other than + must be of type Integer. The operand expressions for the + operator must either both be of type Integer or both be of type String. In all cases, the operand expressions must have a multiplicity upper bound of 1. The functionality of the arithmetic operators is equivalent to the application of the similarly named primitive functions from the library IntegerFunctions package (see Subclause 11.3.2) or StringFunctions package (see Subclause 11.3.3), depending on the type of the operand expressions, with the two operand expressions as arguments. The * operator denotes multiplication, the / operator denotes division and the % operator denotes remainder. The + operator denotes either addition or string concatenation. The – operator denotes subtraction. An arithmetic expression has the same type as its operands and a multiplicity upper bound of 1. Its multiplicity lower bound is 0 if the lower bound if either operand expression is 0 and 1 otherwise.
bitmask << wordLength wordContent >> offset (value&0xF0) >>> 8 Syntax ArithmaticOrShiftExpression(e: Expression) = UnaryOrArithmeticExpression(e) | ShiftExpression(e) ShiftExpression(e: ShiftExpression) = ArithmeticOrShiftExpression(e.operand1) ShiftOperator(e.operator) UnaryOrArithmeticExpression(e.operand2) ShiftOperator(op: String) = "<<"(op) | ">>"(op) | ">>>"(op) 
Figure 8 34 Abstract Syntax of Shift Expressions Cross References
Semantics The first operand expression of a shift expression must have the type BitString or Integer. The second operand expression must have the type Integer. The operand expressions must each have a multiplicity upper bound of 1. The shift operators are used to perform bit shifts on bit strings. If the first operand is an integer, then it is first converted to a bit string by applying the library BitStringFunctions:: ToBitString function (see Subclause 11.3.5). High-order bits in a bit string are considered to be on the left, while low-order bits are on the right. The functionality of the shift operators is equivalent to the application of the similarly named primitive functions from the library BitStringFunctions package (see Subclause 11.3.5) with the two operand expressions as arguments. The value of b< The value of b>>n is b right-shifted n positions. Since the bit string length is fixed, the right n bits of b are lost. The left n bits of the resulting value are set the same as the rightmost (highest bit position) bit of b. If b is the twos-complement representation of an integer (e.g., if it was converted from an integer value), then this corresponds to sign-extension of the original value. The value of b>>>n is the same as for b>>n, except that the left n bits of the resulting value are zero (zero-extension instead of sign-extension).
A shift expression has type BitString and a multiplicity upper bound of 1. Its multiplicity lower bound is 0 if the lower bound of either operand expression is 0 and 1 otherwise. sensorReading > threshold size < maxSize
size >= minSize count <= limit
Figure 8 35 Abstract Syntax of Relational Expressions The operand expressions for a comparison operator must have the type Integer, UnlimitedNatural or Natural. However, it is not allowed to have one operand expression be Integer and the other be UnlimitedNatural. The operand expressions must each have a multiplicity upper bound of 1. The relational operators are used to compare the values of two numbers. The number being compared may be either integers or unlimited naturals, but it is not legal to directly compare an integer to an unlimited natural number.
Thus, the expression 3 < *
is legal (and evaluates to true), since the natural literal 3 is automatically cast to UnlimitedNatural in this context. However, the expression is not legal, because the literal +3 has type Integer. A cast expression (see Subclause 8.5.5) must be used in order to directly compare an integer value to an unlimited natural value; for example, (UnlimitedNatural)(+3) < * evaluates to true. The functionality of the relational operators is equivalent to the application of the similarly named primitive functions from the library IntegerFunctions package (see Subclause 11.3.2) or UnlimitedFunctions package (see Subclause 11.3.4), depending on the type of the operand expressions, with the two operand expressions as arguments.
A comparison expression has type Boolean and a multiplicity upper bound of 1. Its multiplicity lower bound is 0 if the lower bound if either operand expression is 0 and 1 otherwise. 8.6.5Classification ExpressionsA classification expression is an expression with a single operand expression followed by one of the classification operators instanceof or hastype. A classification expression is used to determine whether the result of its operand expression has a certain type, which is given as a qualified name after the classification operator. Examples action instanceof ActionActivation 'signal' hastype SignalArrival
Figure 8 36 Abstract Syntax of Classification Expressions NOTE. The concrete syntax for classification expressions, in terms of form and precedence, is similar to that of a normal binary expression, except that one of the “operands” is a type rather than a second expression. However, since only one operand is actually an expression, in the abstract syntax a classification expression is treated as a kind of unary expression. Cross References
Semantics The qualified name in a classification expression must resolve to a classifier. The classifier must not be a template, though it may be the binding of a template classifier (see Subclause 8.2). The operand expression must have a multiplicity upper bound of 1. A classification expression has type Boolean, the same multiplicity lower bound as its operand expression and a multiplicity upper bound of 1. The instanceof operator checks if the dynamic type of its operand conforms to the given type—that is, whether the argument type is the same as or a direct or indirect subclass of the given type. The hastype operator, on the other hand, checks if the dynamic type of its argument is the same as the given type. 8.6.6Equality ExpressionsAn equality expression is a binary expression with one of the equality operators == (equal to) or != (not equal to). The equality operators are analogous to the relational operators, except for their lower precedence. They are syntactically left-associative (they group left to right), so a==b==c parses as (a==b)==c. However, the result type of a==b is Boolean, so if c is not Boolean, the expression will always be false. Thus, a==b==c does not test whether a, b and c are all equal. Examples errorCount==0 nextRecord!=endRecord list.next==null Syntax ClassificationOrEqualityExpression(e: Expression) = RelationalOrClassificationExpression(e) | EqualityExpression(e) EqualityExpression(e: BinaryExpression) = ClassificationOrEqualityExpression(e.operand1) EqualityOperator(e.operator) RelationalOrClassificationExpression(e.operand2) EqualityOperator(op: String) = "=="(op) | "!="(op) EqualityOrAndExpression(e: Expression) = ClassificationOrEqualityExpression(e) | AndExpression(e) 
Figure 8 37 Abstract Syntax of Equality Expressions Cross References
Semantics For primitive types, the equality operators test whether two values of the same type are the same value. A value of a primitive type is never equal to a value of any other type. NOTE. Since String is a primitive type in UML, not a class, strings may be tested for equality of value using the regular equality operators. For structured data types, the equality operators test whether two values of the same type have equal values for each corresponding attribute. A value of one structured data type is never equal to a value of any other type. Note also that the participation of a value in association links does not affect its equality to other values. For classes, the equality operators test whether the argument values are references to the same object, that is, they test object identity. Further, if one of the arguments to an equality operator is empty (that is, it is the empty sequence), then it is considered to be equal to another empty value, but unequal to any non-empty value. Thus, a==null is true if and only if isEmpty(a). An operand expression for an equality operator must have a multiplicity upper bound of 1. An equality expression has type Boolean and multiplicity [1..1].
sensorOff | sensorError i > min & i < max | unlimited bitString ^ mask registerContent & 0x00FF
Figure 8 38 Abstract Syntax of Logical Expressions Cross References
Semantics The operand expressions for a logical operator must type Boolean, BitString or Integer. However, if one of the operands is Boolean, then the other must also be Boolean. The operand expressions must each have a multiplicity upper bound of 1. Any operand that is an integer is converted to a bit string by applying the library BitStringFunctions::ToBitString function (see Subclause 11.3.5). The functionality of the logical operators is equivalent to the application of the similarly named primitive functions from the library BooleanFunctions package (see Subclause 11.3.1), if the operands have type Boolean, or BitStringFunctions package (see Subclause 11.3.5), with the two operand expressions as arguments. For Boolean operands, the logical operators perform the indicated logical operation and produce a Boolean result:
For BitString or Integer operands, the logical operators perform the indicated logical operation, as above, bit-wise on corresponding bits of the operands and produce a BitString result. For the purpose of carrying out bit-wise logical operations, a bit that is set (value of 1) is considered to be “true” while a bit that is unset (value of 0) is considered to be “false”. A logical expression has the same type as its operand expressions and a multiplicity upper bound of 1. Its multiplicity lower bound is 0 if the lower bound if either operand expression is 0 and 1 otherwise. 8.6.8Conditional Logical ExpressionsA conditional logical expression is a binary expression using one of the conditional logical operators && (conditional-and) and || (conditional-or). The operators are similar to the logical operators & and |, except that the evaluation of their second operand expression is conditioned on the result of evaluating the first expression. In the case of the && operator, the second operand is evaluated only if the value of the first operand is true. In the case of the || operator, the second operatnd is evaluated only if the value of the first operand is false. Examples index > 0 && value[index] < limit index == 0 || value[index] >= limit
Figure 8 39 Abstract Syntax of Conditional Logical Expressions Cross References
Semantics An expression with a conditional-and operator is evaluated by first evaluating its first operand expression. If the the first operand expression evaluates to true, then the second operand expression is evaluated, and its value is the value for the conditional-and expression. If the first operand expression evaluates to false, however, the conditional-and expression evaluates to false without ever evaluating its second operand expression. An expression with a conditional-or operator is evaluated by first evaluating its first operand expression. If the first operand expression evaluates to false, then the second operand expression is evaluated, and its value is the value for the conditional-or expression. If the first operand expression evaluates to true, however, the conditional-or expression evaluates to true without ever evaluating its second operand expression. Since, if the second operand expression is evaluated at all, it is always evaluated after the first, a conditional logical operator expression is fully associative, even in the presence of side effects. That is, not only does an expression of the form (expr1 && expr2) && expr3 produce the same result as expr1 && (expr2 && expr3), the subexpression expr1, including any side effects, will always be evaluated before expr2, and expr2 before expr3. Similarly, an expression of the form (expr1 || expr2) || expr3 produces the same result as expr1 || (expr2 || expr3), with the subexpression expr1 always evaluated before expr2, and expr2 before expr3. Note that this is not guaranteed for the logical operators & and |, for which the operand expressions are evaluated concurrently. The operand expressions to a conditional logical expression must be of type Boolean and have a multiplicity upper bound of 1. A conditional logical expression has type Boolean and a multiplicity upper bound of 1. Its multiplicity lower bound is 0 if the lower bound of either operand expression is 0 and 1 otherwise. A conditional logical operator has special rules for assignment, since it evaluates its arguments sequentially. Assignments made in the first operand expression are available in the second operand expression, if it is evaluated. Further, local names defined outside the second operand expression may be (conditionally) reassigned within that expression. However, local names defined in the second operand expression are not visible outside that expression, since they would have no assigned value if the second operand expression is not actually evaluated. Directory: spec spec -> Illinois state board of education spec -> Volume Ⅴ (2015) On The 2015 China Victory Day Parade spec -> General information spec -> Topeka capital-journal spec -> P-8153 Frederick Tilp II (upper right) with plumbers who worked for him spec -> Catalog of My Wine Library Thomas Pinney Claremont, California 2004 note spec -> Unique 00225 Mobile Barrier (2015 Specifications: 12-04-14) spec -> Annual Conference " Initium Novum" spec -> Petroleum Development Oman L. L. C. Document Title: Specification for hse cases Download 1.74 Mb. Share with your friends:
|
