* partial alignment of grammar, #208

//# Foundation

//Needs to be the first rule

//Package

Package returns tdl::Package:

    AnnotationCommentFragment

    'Package' name=PackageName

    (BEGIN

        (^import+=ElementImport//)*

        | packagedElement+=PackageableElement //)*

        (^import+=ElementImport

        | packagedElement+=PackageableElement

        | nestedPackage+=Package)*

    END)?

;

//PackageableElement

PackageableElement returns tdl::PackageableElement:

    (AnnotationType | TestObjective

     | ConstraintType

;

//Element : Abstract

fragment AnnotationFragment returns tdl::Element:

	'@' 

	//Workaround for upstream issue

	)

;

fragment AnnotationCommentFragment returns tdl::Element:

    CommentFragment?

    AnnotationFragment?

    //(annotation+=Annotation)*

;

fragment PIXITAnnotationFragment returns tdl::Element:

	annotation+=PIXITAnnotation

;

fragment NameFragment returns tdl::Element:

    'Name' ':' name=Identifier

;

;

//NamedElement : Abstract

//Void.

//ElementImport

ElementImport returns tdl::ElementImport:

    AnnotationCommentFragment

    'Import'

    'from' importedPackage=[tdl::Package|QIdentifier]

;

//Comment

SingleComment returns tdl::Comment:

    (name=NIdentifier)? 

    ':' body=EString

    body=EString

;

//Annotation

Annotation returns tdl::Annotation:

    key=[tdl::AnnotationType|AIdentifier]

    (':' value=EString)?

    (':' value=EString)?

;

//AnnotationType

AnnotationType returns tdl::AnnotationType:

    AnnotationCommentFragment

    'Annotation' name=AIdentifier

    ('extends' extension=Extension)?

;

//TestObjective

TestObjective returns tdl::TestObjective:

    AnnotationCommentFragment

    'Objective' name=DeclName

    END)?

;

//Extension

Extension returns tdl::Extension:

    //NOTE: No annotations or comments

    extending=[tdl::PackageableElement|DeclName]

;

//ConstraintType

ConstraintType returns tdl::ConstraintType: 

    AnnotationCommentFragment

    'Constraint' name=DeclName

;

//Constraint

Constraint returns tdl::Constraint: 

    //NOTE: No annotations or comments

    type=[tdl::ConstraintType|DeclName]

//## Data Definition

//DataResourceMapping

DataResourceMapping returns tdl::DataResourceMapping:

    AnnotationCommentFragment

    'Use' resourceURI=EString

    'as' name=Identifier

;

//DataElementMapping

DataElementMapping returns tdl::DataElementMapping:

    AnnotationCommentFragment

    'Map' mappableDataElement=[tdl::MappableDataElement|DeclName]

    END)?

;

//ParameterMapping

ParameterMapping returns tdl::ParameterMapping:

    AnnotationCommentFragment

    parameter=[tdl::Parameter|ParameterIdentifier]

;

//DataType: Abstract

fragment ConstraintFragment returns tdl::DataType:

    (LBrace constraint+=Constraint RBrace)* 

;

//SimpleDataType

SimpleDataType returns tdl::SimpleDataType:

    AnnotationCommentFragment

    'Type' name=Identifier

    ('extends' extension=Extension)?

;

//DONE: boolean data instance

//SimpleDataInstance

SimpleDataInstance returns tdl::SimpleDataInstance:

    AnnotationCommentFragment

    PIXITAnnotationFragment?

    name=Identifier 

;

//StructuredDataType

StructuredDataType returns tdl::StructuredDataType:

    AnnotationCommentFragment

    'Structure' name=Identifier

    LParen (member+=Member (',' member+=Member)*)? RParen

;

//Member

Member returns tdl::Member:

    AnnotationCommentFragment

    (isOptional?='optional')?

    ('=' value=DataUse)?

;

//StructuredDataInstance

StructuredDataInstance returns tdl::StructuredDataInstance:

    AnnotationCommentFragment

    PIXITAnnotationFragment?

    LParen (memberAssignment+=MemberAssignment (',' memberAssignment+=MemberAssignment)*)? RParen

;

//MemberAssignment

MemberAssignment returns tdl::MemberAssignment:

    AnnotationCommentFragment

    member=[tdl::Member|ParameterIdentifier]

    '=' memberSpec=DataUse

;

//CollectionDataType

CollectionDataType returns tdl::CollectionDataType:

    AnnotationCommentFragment

    PIXITAnnotationFragment?

    'of' itemType=[tdl::DataType|Identifier]

;

//CollectionDataInstance

CollectionDataInstance returns tdl::CollectionDataInstance:

    AnnotationCommentFragment

    dataType=[tdl::DataType|Identifier] 

    '[' item+=DataUse (',' item+=DataUse)* ']'    

;

//ProcedureSignature

ProcedureSignature returns tdl::ProcedureSignature:

    AnnotationCommentFragment

    'Signature' name=DeclName

    LParen parameter+=ProcedureParameter ( ',' parameter+=ProcedureParameter)* RParen

;

//ProcedureParameter

ProcedureParameter returns tdl::ProcedureParameter:

    AnnotationFragment?

    kind=ParameterKind

    WithCommentFragment?

;

//ParameterKind

enum ParameterKind returns tdl::ParameterKind:

    In = 'in' | Out = 'out' | Exception = 'exception';

    In = 'in' | Out = 'out' | Exception = 'exception'

;

//Parameter

//Void.

//FormalParameter

FormalParameter returns tdl::FormalParameter:

    AnnotationFragment?

    dataType=[tdl::DataType|Identifier]

    WithCommentFragment?

;

//Variable

Variable returns tdl::Variable:

    AnnotationCommentFragment

    'variable' dataType=[tdl::DataType|Identifier]

    WithCommentFragment?

;

//Action

Action returns tdl::Action:

    AnnotationCommentFragment

    'Action' name=DeclName

    (':' body=EString)?

;

//Function

Function returns tdl::Function:

    AnnotationCommentFragment

    'Function' name=DeclName

    (':' body=EString)?

;

//UnassignedMemberTreatment

enum UnassignedMemberTreatment returns tdl::UnassignedMemberTreatment:

    AnyValue = '?' | AnyValueOrOmit = '*';

    AnyValue = '?' | AnyValueOrOmit = '*'

;

//PredefinedFunction

PredefinedFunction returns tdl::PredefinedFunction:

    AnnotationCommentFragment

    'Predefined' 

;

PredefinedIdentifierBinary returns ecore::EString:

    '+' | '-' | '*' | '/' | 'mod' 

  | '>' | '<' | '>=' | '<=' //DONE: fix extra '>=' also in TDLan2

  | '==' | '!=' | 'and' | 'or' | 'xor'

    PredefinedIdentifierOr

    | PredefinedIdentifierXor

    | PredefinedIdentifierAnd

    | PredefinedIdentifierEquality

    | PredefinedIdentifierRelational

    | PredefinedIdentifierMultiplicative

;

PredefinedIdentifierMinus returns ecore::EString:

    '-'

;

PredefinedIdentifierNot returns ecore::EString:

    'not'

;

PredefinedIdentifierSize returns ecore::EString:

    'size'

;

PredefinedIdentifierNot 			returns ecore::EString: 'not';

PredefinedIdentifierMinus			returns ecore::EString: '-';

PredefinedIdentifierSize 			returns ecore::EString: 'size';

// Precedence (lowest to highest):

// OrExpression → XorExpression → AndExpression → NotExpression → EqualityExpression

PredefinedIdentifierAdditive       	returns ecore::EString: '+' | '-';

PredefinedIdentifierMultiplicative 	returns ecore::EString: '*' | '/' | 'mod';

//EnumDataType

EnumDataType returns tdl::EnumDataType: 

    AnnotationCommentFragment

    'Enumerated' name=Identifier

//## Data Use

//DataUse

DataUse returns tdl::DataUse:

    XorExpression

    ({tdl::PredefinedFunctionCall.actualParameters+=current}

    LBrace (annotation+=CheckAnnotation) RBrace

;

//ParameterBinding

ParameterBinding returns tdl::ParameterBinding:

    parameter=[tdl::Parameter|ParameterIdentifier]

	//TODO: is there a better way? -> will need to be rethought, semantics for collections still problematic..

    (reduction+=MemberReference)+

;

//MemberReference

MemberReference returns tdl::MemberReference:

    ('.' member=[tdl::Member|ParameterIdentifier])

    |

    ('.' 'get' LParen collectionIndex=DataUse RParen)

;

//StaticDataUse

StaticDataUse returns tdl::StaticDataUse:    

    DataInstanceUse

    | SpecialValueUse

    | LiteralValueUse

;

//DataInstanceUse

DataInstanceUse returns tdl::DataInstanceUse:

    (

    	'instance' dataInstance=[tdl::DataInstance|Identifier]

    '[' (item+=DataUse (',' item+=DataUse)*)? ']'

;

//SpecialValueUse

SpecialValueUse returns tdl::SpecialValueUse:

    OmitValue | AnyValue | AnyValueOrOmit 

;

//AnyValue

AnyValue returns tdl::AnyValue:

    name='?'

    (LBrace dataType=[tdl::DataType|Identifier] RBrace)?

    CheckFragment?

;

//AnyValueOrOmit

AnyValueOrOmit returns tdl::AnyValueOrOmit:

    name='*'

    CheckFragment?

;

//OmitValue

OmitValue returns tdl::OmitValue:

    name='omit'

;

//LiteralValueUse

LiteralValueUse returns tdl::LiteralValueUse:

	(value=STRING | intValue=BIGINTEGER | boolValue=BOOLEAN)

    //Note overloaded syntax with constraints, in a sense this is a constraint too..

	// ReductionFragment now handled by PostfixExpression

;

//DynamicDataUse

DynamicDataUse returns tdl::DynamicDataUse:

    FunctionCall

    | FormalParameterUse

;

//TODO: deprecated?

//FunctionCall

FunctionCall returns tdl::FunctionCall:

    'instance' 'returned' 'from' function=[tdl::Function|DeclName]

    ParameterBindingFragment

;

//TODO: deprecated?

//FormalParameterUse

FormalParameterUse returns tdl::FormalParameterUse:

    'parameter' parameter=[tdl::FormalParameter|ParameterIdentifier]

    ParameterBindingFragment?

    // ReductionFragment now handled by PostfixExpression

;

//VariableUse

VariableUse returns tdl::VariableUse:

    componentInstance=[tdl::ComponentInstance|Identifier] '::' 

    variable=[tdl::Variable|Identifier]

    ParameterBindingFragment?

;

//PredefinedFunctionCall

PredefinedFunctionCall returns tdl::PredefinedFunctionCall:

    PredefinedFunctionCallSize

    | PredefinedFunctionCallNot

//# Time

//Time

Time returns tdl::Time:

    AnnotationCommentFragment

    'Time' name=DeclName

;

//TimeLabel

TimeLabel returns tdl::TimeLabel:

    //NOTE: No annotations or comments

    name=Identifier '=' 'now'    

;

//TimeLabelUse

TimeLabelUse returns tdl::TimeLabelUse:

    //NOTE: No reduction and parameter binding (constraint)

    '@' timeLabel=[tdl::TimeLabel|Identifier]

    ('.' kind=TimeLabelUseKind)?

;

//TimeLabelUseKind

enum TimeLabelUseKind returns tdl::TimeLabelUseKind:

    Last = 'last' | Previous = 'previous' | First = 'first'

;

//TimeConstraint

TimeConstraint returns tdl::TimeConstraint:

    //NOTE: No annotations or comments

    timeConstraintExpression=DataUse

;

//Timer

Timer returns tdl::Timer:

    AnnotationCommentFragment

    'timer' name=DeclName

;

//TimeOperation

TimeOperation returns tdl::TimeOperation: 

    Wait | Quiescence

;

//Wait

Wait returns tdl::Wait: 

    AtomicPrefixFragment

    'wait' 'for' period=DataUse

    ( 'on' componentInstance=[tdl::ComponentInstance|Identifier])?

;

//Quiescence

Quiescence returns tdl::Quiescence: 

    AtomicPrefixFragment

    'quiet' 'for' period=DataUse 

    )?

;

//TimerOperation

TimerOperation returns tdl::TimerOperation: 

    TimerStart | TimerStop | TimeOut

;

//TimerStart

TimerStart returns tdl::TimerStart:

    AtomicPrefixFragment

    //TODO: towards scoped components

    'start' 

    (componentInstance=[tdl::ComponentInstance|Identifier] '::')? 

    timer=[tdl::Timer|DeclName]

    'for' period=DataUse

;

//TimerStop

TimerStop returns tdl::TimerStop:

    AtomicPrefixFragment

    //TODO: towards scoped components

    'stop' 

    (componentInstance=[tdl::ComponentInstance|Identifier] '::')? 

    timer=[tdl::Timer|DeclName]

;

//TimeOut

TimeOut returns tdl::TimeOut:

    AtomicPrefixFragment

    //TODO: towards scoped components

    'timeout' 'on' 

    (componentInstance=[tdl::ComponentInstance|Identifier] '::')? 

    timer=[tdl::Timer|DeclName]

//# Test Configuration

//GateType

GateType returns tdl::GateType:

    AnnotationCommentFragment

    kind=GateTypeKind

    'accepts' dataType+=[tdl::DataType|Identifier] ( ',' dataType+=[tdl::DataType|Identifier])*

;

//GateTypeKind

enum GateTypeKind returns tdl::GateTypeKind:

    Message = 'Message' | Procedure = 'Procedure'

;

//GateInstance

GateInstance returns tdl::GateInstance:

    AnnotationCommentFragment

    'gate' type=[tdl::GateType|DeclName]

    WithCommentFragment?  

;

//ComponentType

ComponentType returns tdl::ComponentType:

    AnnotationCommentFragment

    'Component' name=DeclName

    END

;

//ComponentInstance

ComponentInstance returns tdl::ComponentInstance:

    AnnotationCommentFragment

    type=[tdl::ComponentType|DeclName]

    SUT = 'SUT' | Tester = 'Tester'

;

//GateReference

GateReference returns tdl::GateReference:

    //NOTE: No annotations or comments

    //		-> note that if the name is present, it shall be used exclusively

    gate=[tdl::GateInstance|Identifier]

;

//Connection

Connection returns tdl::Connection:

    AnnotationCommentFragment

    'connect' endPoint+=GateReference 

    WithNameFragment?

;

//TestConfiguration

TestConfiguration returns tdl::TestConfiguration:

    AnnotationCommentFragment

    'Configuration' name=DeclName

//## Test Description

//TestDescription

TestDescription returns tdl::TestDescription:

    TDPrefixFragment

    ('Test' 'Description' | isLocallyOrdered?='Test')

    ( ',' testObjective+=[tdl::TestObjective|DeclName])*

;

//BehaviourDescription

BehaviourDescription returns tdl::BehaviourDescription:

    //NOTE: No annotations or comments

    behaviour=Behaviour

//## Combined Behaviour

//Behaviour

Behaviour returns tdl::Behaviour:

    CombinedBehaviour | AtomicBehaviour

    //NOTE: Excluded via constraint:

;

fragment ObjectiveFragment returns tdl::Behaviour:

    'Objective' ':' testObjective+=[tdl::TestObjective|DeclName] ( ',' testObjective+=[tdl::TestObjective|DeclName])*

    'Objective' ':' testObjective+=[tdl::TestObjective|DeclName] 

    ( ',' testObjective+=[tdl::TestObjective|DeclName])*

;

//Block

Block returns tdl::Block:

    //NOTE: No annotations or comments

    ('['

    END

;

//LocalExpression

LocalExpression returns tdl::LocalExpression:

    //NOTE: No annotations or comments

    expression=DataUse

    ('on' componentInstance=[tdl::ComponentInstance|Identifier])?

;

//CombinedBehaviour

CombinedBehaviour returns tdl::CombinedBehaviour:

    (SingleCombinedBehaviour | MultipleCombinedBehaviour)

    =>WithCombinedFragment?

        NameFragment?

        ObjectiveFragment?

        CommentFragment?

        (periodic+=PeriodicBehaviour //)*

        (periodic+=PeriodicBehaviour

        | exceptional+=ExceptionalBehaviour)*

    END

;

//SingleCombinedBehaviour

SingleCombinedBehaviour returns tdl::SingleCombinedBehaviour:

    CompoundBehaviour

    | BoundedLoopBehaviour

    | OptionalBehaviour

;

//CompoundBehaviour

CompoundBehaviour returns tdl::CompoundBehaviour:

    AnnotationFragment?

    block=NoGuardBlock

;

//BoundedLoopBehaviour

BoundedLoopBehaviour returns tdl::BoundedLoopBehaviour:

    AnnotationFragment?

    'repeat' numIteration+=LocalLoopExpression (',' numIteration+=LocalLoopExpression)*

    block=Block

;

//UnboundedLoopBehaviour

UnboundedLoopBehaviour returns tdl::UnboundedLoopBehaviour:

    AnnotationFragment?

    'while' block=Block

;

//OptionalBehaviour

OptionalBehaviour returns tdl::OptionalBehaviour:

    AnnotationFragment?

    'optionally' block=Block

;

//MultipleCombinedBehaviour

MultipleCombinedBehaviour returns tdl::MultipleCombinedBehaviour:

    ConditionalBehaviour 

    | AlternativeBehaviour

    | ParallelBehaviour

;

//ConditionalBehaviour

ConditionalBehaviour returns tdl::ConditionalBehaviour:

    AnnotationFragment?

    'if' block+=Block

       ('else' block+=Block)))?

;

//AlternativeBehaviour

AlternativeBehaviour returns tdl::AlternativeBehaviour:

    AnnotationFragment?

    'alternatively' block+=Block

    ('or' block+=Block)+ 

;

//ParallelBehaviour

ParallelBehaviour returns tdl::ParallelBehaviour:

    AnnotationFragment?

    'run' block+=Block 

    ('and' block+=Block)*

;

//ExceptionalBehaviour

ExceptionalBehaviour returns tdl::ExceptionalBehaviour:

    DefaultBehaviour | InterruptBehaviour

;

//DefaultBehaviour

DefaultBehaviour returns tdl::DefaultBehaviour:

    AnnotationFragment?

    'default' 

    WithBehaviourFragment?

;

//InterruptBehaviour

InterruptBehaviour returns tdl::InterruptBehaviour:

    AnnotationFragment?

    'interrupt'

    WithBehaviourFragment?

;

//PeriodicBehaviour

PeriodicBehaviour returns tdl::PeriodicBehaviour:

    AnnotationFragment?

    'every'

;

//## Atomic Behaviour

//AtomicBehaviour

AtomicBehaviour returns tdl::AtomicBehaviour:

    (TimerOperation

    | TimeOperation

    LBrace timeConstraint+=TimeConstraint ( ',' timeConstraint+=TimeConstraint)* RBrace

;

//Break

Break returns tdl::Break:

    {tdl::Break}

    AtomicPrefixFragment

    'break'

;

//Stop

Stop returns tdl::Stop:

    {tdl::Stop}

    AtomicPrefixFragment

    'terminate'

;

//VerdictAssignment

VerdictAssignment returns tdl::VerdictAssignment:

    AtomicPrefixFragment

    'set' 'verdict' 'to' verdict=DataUse

;

//Assertion

Assertion returns tdl::Assertion:

    {tdl::Assertion}

    AtomicPrefixFragment

    ('otherwise' otherwise=DataUse)?

;

//Interaction

Interaction returns tdl::Interaction: 

    Message | ReceiveMessage | ProcedureCall | ProcedureCallResponse

;

//Message

Message returns tdl::Message:

    AtomicPrefixFragment

    sourceGate=[tdl::GateReference|GRIdentifier]

    'to' target+=TargetMessage ( ',' target+=TargetMessage)* 

;

TargetMessage returns tdl::Target:

    //NOTE: No name, annotations or comments

    targetGate=[tdl::GateReference|GRIdentifier]

    (valueAssignment+=ValueAssignmentMessage)?

;

ValueAssignmentMessage returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    'where' 'it' 'is' 

    'assigned' 'to' variable=[tdl::Variable|Identifier]

;

ReceiveMessage returns tdl::Message:

    AtomicPrefixFragment

    //NOTE: Only single target possible

    target+=ReceiveTargetMessage //( ',' target+=ReceiveTargetMessage)*

    target+=ReceiveTargetMessage

    'receives' (isTrigger?='trigger')? 

    argument=DataUse

    'from' sourceGate=[tdl::GateReference|GRIdentifier]

;

//Target

TargetMessage returns tdl::Target:

    //NOTE: No name, annotations or comments

    targetGate=[tdl::GateReference|GRIdentifier]

    (valueAssignment+=ValueAssignmentMessage)?

;

ReceiveTargetMessage returns tdl::Target:

    //NOTE: No name, annotations or comments

    (valueAssignment+=ReceiveValueAssignmentMessage)?

    targetGate=[tdl::GateReference|GRIdentifier]

;

TargetProcedure returns tdl::Target:

    //NOTE: No name, annotations or comments

    targetGate=[tdl::GateReference|GRIdentifier]

    (valueAssignment+=ValueAssignmentProcedure (',' valueAssignment+=ValueAssignmentProcedure)*)?

;

//ValueAssignment

ValueAssignmentMessage returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    'where' 'it' 'is' 

    'assigned' 'to' variable=[tdl::Variable|Identifier]

;

ReceiveValueAssignmentMessage returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    variable=[tdl::Variable|Identifier] '='

;

ValueAssignmentProcedure returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    'where' parameter=[tdl::Parameter|ParameterIdentifier] 'is'

    'assigned' 'to' variable=[tdl::Variable|Identifier]

;

//ProcedureCall

ProcedureCall returns tdl::ProcedureCall:

    AtomicPrefixFragment

    (name=Identifier ':')?

    'to' target+=TargetProcedure

;

TargetProcedure returns tdl::Target:

    //NOTE: No name, annotations or comments

    targetGate=[tdl::GateReference|GRIdentifier]

    (valueAssignment+=ValueAssignmentProcedure (',' valueAssignment+=ValueAssignmentProcedure)*)?

;

ValueAssignmentProcedure returns tdl::ValueAssignment:

    //NOTE: No name, annotations or comments

    'where' parameter=[tdl::Parameter|ParameterIdentifier] 'is'

    'assigned' 'to' variable=[tdl::Variable|Identifier]

;

//TestDescriptionReference

TestDescriptionReference returns tdl::TestDescriptionReference:

    AtomicPrefixFragment

    'execute' testDescription=[tdl::TestDescription|DeclName]

    END)?

;

//ComponentInstanceBinding

ComponentInstanceBinding returns tdl::ComponentInstanceBinding:

    AnnotationCommentFragment

    formalComponent=[tdl::ComponentInstance|Identifier]

    '->' actualComponent=[tdl::ComponentInstance|Identifier]

;

//ActionBehaviour

ActionBehaviour returns tdl::ActionBehaviour: 

    ActionReference | InlineAction

;

//ActionReference

ActionReference returns tdl::ActionReference:

    AtomicPrefixFragment

    'perform' action=[tdl::Action|DeclName]

    ('on' componentInstance=[tdl::ComponentInstance|Identifier])?

;

//InlineAction

InlineAction returns tdl::InlineAction:

    AtomicPrefixFragment

    'perform' 'action' ':' body=EString

    ('on' componentInstance=[tdl::ComponentInstance|Identifier])?

;

//Assignment

Assignment returns tdl::Assignment:

    AtomicPrefixFragment

    //TODO: towards scoped components -> collides with receive