• languages/MDL/Grammar/Expressions
• languages/MDL/Grammar/FileHeader
• languages/MDL/Grammar/MeasureDefinition
• languages/MDL/Grammar/Terminals
• languages/MDL/Grammar/Typing

Expressions

Expressions in MDL are used to define queries to refine a scope specified by a class of the application meta-model? (AMM). They address the features #5 and #6.

The expression grammar can be divided in several parts. First, it provides boolean operations, compare operations, unary operations and operations for simple calculations, which form the basic structure of an expression. Second, it provides logical quantors and conditional expressions. Third, it provides rules to describe property and method selectors. And fourth, it provides auxiliary rules for built-in functions and nested expressions.

Rules for the Basic Structure of Expressions

Expression: AndExpression ( ({Expression.left=current} operator='||') right=Expression)? ; 

AndExpression returns Expression: RelationalExpression ( ({Expression.left=current} operator='&&') right=AndExpression)? ; 

RelationalExpression returns Expression: AdditiveExpression ( ({Expression.left=current} operator=OpCompare) right=AdditiveExpression)?; OpCompare: '>=' | '<=' | '>' | '<' | '==' | '!=' ; 

AdditiveExpression returns Expression: MultiplicativeExpression (({Expression.left=current} operator=OpAdd) right=AdditiveExpression)?; OpAdd: '+' | '-'; 

MultiplicativeExpression returns Expression: UnaryOperation (({Expression.left=current} operator=OpMulti) right=MultiplicativeExpression)?; OpMulti: '*' | '**' | '/' | '%'; 

UnaryOperation returns Expression: {UnaryOperation} operator=OpUnary operand=PrimaryExpression | PrimaryExpression; OpUnary: "!" | "-" | "+"; 

PrimaryExpression returns Expression: Literal | IfExpression | ForAllExpression | ExistsExpression | FunctionCall | ValueExpression | ParenthesizedExpression; 

Quantors and Conditional Expressions

The MDL scope expression language provides a conditional expression to control the evaluation of parts of an expression, and the forall and exists quantors used to conclude over sets and properties of their elements.

The semantic of the IfExpression is, that the condition is evaluated first. If it is true, the then-expression is evaluated. If it is false, the else-expression is evaluated.

Constraint: The expression for the condition must therefore be a boolean expression.

Constraint: The expressions for then and else must conform to the type context established by the outer scope of the expression.

IfExpression returns Expression: {IfExpression} 'if' '(' condition=Expression ')' then=Expression ('else' else=Expression); 

The behavior of the ForAllExpression is to return true if all elements of a collection are true, or, if specified, the given expression for each collection value is true. The collection is specified by a Collection rule.

Constraint: The expression to evaluate is optional. If such an expression is given, it must return a boolean value for each given collection member.

Constraint: If no expression is given, the collection must contain boolean values.

ForAllExpression returns Expression: {ForAllExpression} 'forall' '(' collection=Collection ('|' evaluate=Expression)? ')' ; 

The behavior for the ExistsExpression is to return true if at least one element of an collection is true, or, if specified, the given expression for one collection value is true. The collection is specified by a Collection rule.

Constraint: The expression to evaluate is optional. If such an expression is given, it must return a boolean value for each given collection member.

Constraint: If no expression is given, the collection must contain boolean values.

ExistsExpression returns Expression: {ExistsExpression} 'exists' '(' collection=Collection ('|' evaluate=Expression)? ')' ; 

The Collection rule is used for both quantors in the same way. It declares a name for the local scope of the expression. This name is then used in the evaluation-expression of the quantors to identify a single collection member.

Constraint: The collection must reference a value expression which resembles a collection of some kind.

Constraint: A collection must always contain objects of the same type. However, objects of subtyped classes are also allowed complying to OOP semantics.

Collection: name=ID 'in' collection=ValueExpression ; 

Property and Method Selectors

Scope expressions must be able to select properties and methods of the class specified to be the base for the scope. Furthermore, they must be able to navigate references to other classes of the application meta-model?. The ValueExpression realizes the chain of references in form of a tree. The left-side of each branch contains a reference, while the right side contains the next ValueExpression-node.

The scope for the base-reference are properties (ecore::EStructuredFeature) of the class referenced by the parent's ValueExpression base-reference. For the left most (or top most) reference the scope is defined by the ecore::EClassifier of the ModelType-node.

ValueExpression: base=ValueElement ('.' child=ValueExpression)? ; 

The above image shows the lookup chains for the left most reference, which context is the ecore::EClassifier of the ModelType-node. While the others use the type (and classifier) of previously resolved references.

Constraint: As the grammar does not distinguish between ecore::EReference and ecore::EAttribute, this must be done by a check, as attributes do not have an valid ecore::EClassifier.

Beside references, an value expression can use built-in methods to reflect on the type of a value. Furthermore, operations of the meta-model can be accessed. Therefore, the ValueExpression does not allow only References, but, through the following rule, also OperationCalls and ReflectionCalls.

ValueElement: Reference | OperationCall | ReflectionCall ; 

A Reference references an ecore::EStructuralFeature and uses the ID of that feature as lookup value. While references might point to collections, or collections of collections, the elements of an collection can be addressed by a selection expression.

Constraint: The Expression for the selection of one member of a collection must be a positive numerical value for simple collections or a key of the right type, if the collection is a map of some sort.

Reference: reference=[ecore::EStructuralFeature|ID] ('[' selections+=Expression ']')* ; 

An OperationCall is used to access operations provided by the meta-model for the type of the local typing context. The operation can have 0 or more parameters, which required suitable values.

Constraint: The validity of the operation parameters must be checked on the basis of the parameters provided by the ecore::EOperation instance. Therefore, the type of each parameter expression has to be determined.

OperationCall: operation=[ecore::EOperation|ID] '(' (parameterAssignments+=Expression (',' parameterAssignments+=Expression)*)? ')' ; 

MDL supports also methods to handle reflection on selector expressions. At present two methods are defined: isTypeOf and isKindOf. They provide the functionality of the reflection methods of OCL. Therefore, isKindOf returns true, if the instance has the given type, or the type of the instance is a subtype of the given type.

Constraint: The classifier should be part of the same meta-model as the reference written left of it. Otherwise it will always be false.

ReflectionCall: reflectionType=ReflectionType '(' type=[ecore::EClassifier|ID] ')' ; enum ReflectionType: IS_TYPE_OF = 'isTypeOf' | IS_KIND_OF = 'isKindOf' ; 

Auxiliary Rules for Expressions

ParenthesizedExpression returns Expression: '(' Expression ')' ; 

FunctionCall: function=FunctionName '(' (parameterAssignments+=Expression (',' parameterAssignments+=Expression)*)? ')' ; FunctionName: ABS = 'abs' | FLOOR = 'floor' | CEIL = 'ceil' | SIZE = 'size' ;

grammar de.cau.cs.se.measure.definition.language.MeasureDefinitionLanguage with org.eclipse.xtext.common.Terminals generate definition "http://se.cs.cau.de/languages/MeasureDefinitionLanguage" import "http://www.eclipse.org/xtext/common/JavaVMTypes" as types import "http://www.eclipse.org/emf/2002/Ecore" as ecore 

Model: 'library' name=QualifiedName (imports+=Import)* (metamodels+=MetaModel)+ (types+=MeasureType)+ (measures+=Measure)+ ; 

Import: 'import' (importedType=[types::JvmType|QualifiedName] | importedNamespace=QualifiedNameWithWildcard) ; 

MetaModel: 'model' name=ID package=[ecore::EPackage|STRING] ; 

library de.cau.cs.se.MengesMeasures

model ecore "http://www.eclipse.org/emf/2002/Ecore"
model types "http://se.informatik.uni-kiel.de/menges/types"

Declaration of Measures

The MDL provide four basic measures. The NamedMeasure is used to declare references to external measure sources. The CountingMeasure is an counting function, which could be replaced in future by functions in expressions. The MeasureExpression allows to define complex formulas over direct measures and is mapped to a wide range of BinaryMeasures of the SMM. And the CollectiveMeasure, which calculates accumulation expressions.

Measure: NamedMeasure | CountingMeasure | MeasureExpression | CollectiveMeasure ; 

A NamedMeasure is defined by an unique name, which references an external source of measurements. The resultType of a NamedMeasure defines the data type of that external source. The elementType describes, which meta-model elements the NamedMeasure can be used for. For example, the measure ExecutionTime is can be applied to a Java-method, but not to an enumeration. Therefore, it would be limited to Java-method by the elementType property.

NamedMeasure: 'measure' resultType=[MeasureType|ID] name=ID ':' elementType=ModelTypeReference ('(' parameter+=ParameterDeclaration (',' parameter+=ParameterDeclaration)* ')')? (scope=Scope)? ; 

The CountingMeasure is modeled after the SMM CountingMeasure. It returns 1, if selection is not empty and 0, if the selection is empty. Note: Either the naming should be changed to something more suitable to the specified semantics, or count should be able to return the number of found elements.

The CountingMeasure does not have a specifiable result type, as the type is unit-less 0 or 1.

CountingMeasure: 'count' name=ID ':' elementType=ModelType ('(' parameter+=ParameterDeclaration (',' parameter+=ParameterDeclaration)* ')')? 'select' selection=Expression (scope=Scope)? ; 

The MeasureExpression is the most complex measure construct. It is a facade to a wide range of measures, which are automatically generated through the specified expression. A MeasureExpression comprises of a unique name, a resultType to define, the allowed result type of the derived measure. An elementType to define which meta-model elements can be addressed by the MeasureExpression. And an expression to define the formula to derive values.

MeasureExpression: 'def' resultType=[MeasureType|ID] name=ID ':' elementType=ModelTypeReference ('(' parameter+=ParameterDeclaration (',' parameter+=ParameterDeclaration)* ')')? expression=AdditiveExpression (scope=Scope)? ; 

A CollectiveMeasure summarizes results from a nested measure. The Accumulator defines the method of this collection. And the referencedMeasure specifies the measure which provides the data to be accumulated. Depending on the type of the referenced measure and the accumulation method the result type must be specified.

Note: The CollectiveMeasure is not yet complete, as it does not support periodic measures.

CollectiveMeasure: 'collect' resultType=[MeasureType|ID] name=ID ':' elementType=ModelTypeReference ('(' parameter+=ParameterDeclaration (',' parameter+=ParameterDeclaration)* ')')? accumulator=Accumulator ref=[Measure|ID] (scope=Scope)? ; enum Accumulator: SUM = 'sum' | AVERAGE = 'average' | STANDARD_DEVIATION = 'standard-deviation' | STANDARD_DEVIATION = 'sd' ; 

The previously described measures have some common features, which require the following two common rules. First, the ParameterDeclaration allows to declare parameter for measures. As the reference rule for the parameter type TypeReference is used to limit probable types to types with units or base types.

ParameterDeclaration: type=TypeReference name=ID ; 

Second, the Scope rule is used to refine the scope of a measure. While elementType limits the measure to one meta-model class, the scope can go further and add limits based on complex Boolean expressions. For example, elementType limits the use of a measure to Java-methods and the scope can limit that to methods with the name run if the class is a Runnable.

Scope:{Scope} 'scope' '{' (scopes+=Expression)+ '}' ;

Terminals

terminal BOOLEAN returns ecore::EBooleanObject : "true" | "false"; QualifiedName: ID (=>'.' ID)*; QualifiedNameWithWildcard: QualifiedName '.' '*' ; SpecialName: ID | STRING ; 

MeasureType: 'typedef' baseType=TypeReference unit=Unit name=ID ; Unit: UnitFormula | FreeUnit ; FreeUnit: unit=STRING ; 

UnitFormula: UnitCombination (({UnitFormula.numerator=current} '/') denominator=UnitCombination )? ; UnitCombination: SIUnit | '(' units+=UnitCombination+ ')' ; 

SIUnit:
	(prefix=Prefix)? kind=Kind (dimension=INT)?
;

enum Prefix: PICO = 'pico' | NANO = 'nano' | MICRO = 'micro' | MILLI = 'milli' | CENTI = 'centi' | DECI = 'deci' | KILO = 'kilo' | MEGA = 'mega' | GIGA = 'giga' | TERA = 'tera' | PETA = 'peta' ; 

enum Kind: METER = 'meter' | SECOND = 'second' | GRAM = 'gram' | LITER = 'liter' ; 

TypeReference: metamodel=[MetaModel|ID] '::' dataType=[ecore::EDataType|ID] | measureType=[MeasureType|ID] ; ModelTypeReference: metamodel=[MetaModel|ID] '::' classifier=[ecore::EClassifier] ;