+ changes for v4.9.1

	{AltGuardChar} SQUAREOPEN expr=BooleanExpression? SQUARECLOSE;

AltstepInstance:

	ref=[AltstepDef|QualifiedIdentifier] LPAREN list=FunctionActualParList? RPAREN;

	ref=[AltstepDef|QualifiedIdentifier] LPAREN list=ActualParList? RPAREN;

FunctionInstance:

	//TODO: this needs to be refined for control and not implemented as well

	//TODO: other places where predefined functions are used?

	(ref=[FunctionRef|QualifiedIdentifier] LPAREN params=FunctionActualParList? RPAREN)

	(ref=[FunctionRef|QualifiedIdentifier] LPAREN params=ActualParList? RPAREN)

	| pre=PreDefFunction

	;

	BaseTemplate | Enumeration | FormalTemplatePar | FormalValuePar | SingleTempVarInstance;

FunctionActualParList:

	(params+=FunctionActualPar (COMMA params+=FunctionActualPar)*) | (asssign+=FunctionActualParAssignment (COMMA

	asssign+=FunctionActualParAssignment)*);

//FunctionActualParList:

//	(params+=FunctionActualPar (COMMA params+=FunctionActualPar)*) | (asssign+=FunctionActualParAssignment (COMMA

//	asssign+=FunctionActualParAssignment)*);

FunctionActualParAssignment:

	template=TemplateInstanceAssignment | component=ComponentRefAssignment | port=PortRefAssignment |

	timer=TimerRefAssignment;

//FunctionActualParAssignment:

//	template=ActualParAssignment | component=ComponentRefAssignment | port=PortRefAssignment |

//	timer=TimerRefAssignment;

	// used FormalValuePar according to antlr implementation

ComponentRefAssignment:

	ref=[FormalValuePar|IDENTIFIER] ASSIGNMENTCHAR value=ComponentRef;

//ComponentRefAssignment:

//	ref=[FormalValuePar|IDENTIFIER] ASSIGNMENTCHAR value=ComponentRef;

	// hack to deal with ambiguity between FormalValuePar and FormalPortPar

// TODO; find better solution for this

FormalPortAndValuePar:

	FormalPortPar | FormalValuePar | PortElement;

FormalPar:

	FormalPortAndValuePar | FormalTemplatePar | FormalTimerPar	

;

PortRefAssignment:

	port=[FormalPortAndValuePar|IDENTIFIER] ASSIGNMENTCHAR value=PortRef;

TimerRefAssignment:

	timer=[FormalTimerPar|IDENTIFIER] ASSIGNMENTCHAR value=[TimerVarInstance|IDENTIFIER];

FunctionActualPar:

	template=TemplateInstance | component=ComponentRef | timer=[TimerVarInstance|IDENTIFIER] | port=PortRef |

	{FunctionActualPar} MINUS;

//FunctionActualPar:

//	template=TemplateInstance | component=ComponentRef | timer=[TimerVarInstance|IDENTIFIER] | port=PortRef |

//	{FunctionActualPar} MINUS;

ComponentRef:

	ref=ComponentOrDefaultReference | system=SYSTEMKEYWORD | self=SELFOP | mtc=MTCKEYWORD;

	variable=VariableRef /*| function=FunctionInstance /*| preFunction=PreDefFunction*/;

TestcaseInstance:

	EXECUTEKEYWORD LPAREN ref=[TestcaseDef|QualifiedIdentifier] LPAREN tcParams=TestcaseActualParList? RPAREN (COMMA

	EXECUTEKEYWORD LPAREN ref=[TestcaseDef|QualifiedIdentifier] LPAREN tcParams=ActualParList? RPAREN (COMMA

	(expr=Expression | MINUS) (COMMA sexpr=SingleExpression)?)? RPAREN;

TestcaseActualParList:

	(templParam+=TemplateInstanceActualPar (COMMA templParam+=TemplateInstanceActualPar)*) |

	(templAssign+=TemplateInstanceAssignment (COMMA templAssign+=TemplateInstanceAssignment)*);

//TestcaseActualParList:

//	(templParam+=ActualPar (COMMA templParam+=ActualPar)*) |

//	(templAssign+=ActualParAssignment (COMMA templAssign+=ActualParAssignment)*);

TimerStatements:

	start=StartTimerStatement | stop=StopTimerStatement | timeout=TimeoutStatement;

	MAPKEYWORD spec=SingleConnectionSpec clause=ParamClause?;

ParamClause:

	PARAMKEYWORD list=FunctionActualParList;

	PARAMKEYWORD list=ActualParList;

ConnectStatement:

	CONNECTKEYWORD spec=SingleConnectionSpec;

;

UnionFieldDef:

	(type=Type | nestedType=NestedTypeDef) name=IDENTIFIER array=ArrayDef? subType=SubTypeSpec?;

	(default=DEFAULT_MODIFIER)? (type=Type | nestedType=NestedTypeDef) name=IDENTIFIER array=ArrayDef? subType=SubTypeSpec?;

SetDef:

	SETKEYWORD ADDRESSKEYWORD body=StructDefBody | SetDefNamed;

	//		-> keep for now otherwise it gets matched as TemplateRef with ParList

	//		-> test performance and correctness -> overshoots, treats everything as enum

	symbol=MatchingSymbol 

	| (list=TemplateRefWithParList extended=ExtendedFieldReference?)

	//DONE: is this 0..* (*) or 1..* (+)? -> set to (+) -> report -> reverted in v4.11.1

	//DONE: it would make sense to group perhaps -> see SingleTemplateRef -> reverted

	//DONE: validate	

	| (list=TemplateRefWithParList (extended=ExtendedFieldReference)?)

	| =>(enumeration=[Enumeration|QualifiedIdentifier] extension=EnumTemplateExtension)

//	DONE: is it supposed to be a reference? -> yes

;

	// TODO: test this!

TemplateRefWithParList:

	template=[TemplateRef|QualifiedIdentifier] list=TemplateActualParList?;

	//DONE: pulled LPAREN and RPAREN here to avoid double parentheses

	template=[TemplateRef|QualifiedIdentifier] (LPAREN list=ActualParList RPAREN)?;

TemplateActualParList:

	{TemplateActualParList} LPAREN (actual+=TemplateInstanceActualPar (COMMA actual+=TemplateInstanceActualPar)* |

	assign+=TemplateInstanceAssignment (COMMA assign+=TemplateInstanceAssignment)*)? RPAREN;

ActualParList:

	//TODO: this has to be revised

	{ActualParList} ((actual+=ActualPar (COMMA actual+=ActualPar)*) (COMMA assign+=ActualParAssignment)* |

	assign+=ActualParAssignment (COMMA assign+=ActualParAssignment)*);

MatchingSymbol:

	//TODO: switched to RangeDef instead of Range -> added both -> removed again 

	templates=ListOfTemplates;

DecodedContentMatch:

	DECODED_MATCH  ( LPAREN Expression RPAREN )? template=TemplateInstance  

	DECODED_MATCH  ( LPAREN expr=Expression? RPAREN )? template=TemplateInstance  

;

SubsetMatch:

OpCall:

	configuration=ConfigurationOps | verdict=GETLOCALVERDICT | timer=TimerOps | function=FunctionInstance

	extendedFunction+=ExtendedFieldReference* | preFunction=PreDefFunction | testcase=TestcaseInstance |

	activate=ActivateOp | templateOps=TemplateOps extendedTemplate+=ExtendedFieldReference* |

	field+=ExtendedFieldReference+;

	activate=ActivateOp | (templateOps=TemplateOps extendedTemplate+=ExtendedFieldReference*) |

	field+=ExtendedFieldReference+

	//TODO: this is left recursive.. 

	| getAttribute=GetAttributeOp

	;

AliveOp:

	component=ComponentOrAny DOT ALIVEKEYWORD index=IndexAssignment?;

Signature:

	ref=[SignatureDef|QualifiedIdentifier];

TemplateInstanceAssignment:

	name=[BaseTemplate|IDENTIFIER] ASSIGNMENTCHAR template=TemplateInstance;

ActualParAssignment:

	//TODO: this should be changed to par / parameter!!

	parameter=[FormalPar|IDENTIFIER] ASSIGNMENTCHAR template=TemplateInstance;

TemplateInstanceActualPar:

	TemplateInstance | {TemplateInstanceActualPar} MINUS;

ActualPar:

	//TODO: added template property for consistency

	template=TemplateInstance | minus=MINUS;

TemplateRestriction:

	LPAREN (omit=OMITKEYWORD | value=VALUEKEYWORD | present=PRESENTKEYWORD) RPAREN;

	{MultiWithAttrib} (single+=SingleWithAttrib SEMICOLON?)*;

SingleWithAttrib:

	{SingleWithAttrib} keyword=AttribKeyword override=OVERRIDEKEYWORD? attrib=AttribQualifier? text=FREE_TEXT;

	{SingleWithAttrib}

	//TODO: this should have been factored out? 

	standard=StandardAttribute | variant=VariantAttribute

;

StandardAttribute:

	{StandardAttribute}

	keyword=AttribKeyword (override=OVERRIDEKEYWORD | local=LOCAL_MODIFIER)? attrib=AttribQualifier? text=FREE_TEXT

;

VariantAttribute:

	{VariantAttribute}

	//TODO: related encoding seems to be ignored..

	keyword=VARIANTKEYWORD ( override=OVERRIDEKEYWORD | local=LOCAL_MODIFIER)? attrib=AttribQualifier? (encoding=RelatedEncoding DOT )? text=FREE_TEXT 

;

RelatedEncoding:

	{RelatedEncoding}

	text+=FREE_TEXT | ( LBRACKET text+=FREE_TEXT ( COMMA text+=FREE_TEXT )* RBRACKET)

;

AttribKeyword returns ecore::EString:

	ENCODEKEYWORD | VARIANTKEYWORD | DISPLAYKEYWORD | EXTENSIONKEYWORD | OPTIONALKEYWORD;

	ENCODEKEYWORD | DISPLAYKEYWORD | EXTENSIONKEYWORD | OPTIONALKEYWORD;

AttribQualifier:

	LPAREN list=DefOrFieldRefList RPAREN;

QualifiedIdentifierList:

	qids+=QualifiedIdentifier (COMMA qids+=QualifiedIdentifier)*;

GetAttributeOp:

//	{GetAttributeOp}

	//TODO: is it a type definition or reference??

	//TODO: this is left recursive.. over OpCall

//	( type=Type | template=TemplateInstance ) DOT attribute=GetAttributeSpec

//    ( type=Type | value=ReferencedValue | LPAREN template=TemplateInstance RPAREN) DOT attribute=GetAttributeSpec

	( type=Type ) DOT attribute=GetAttributeSpec

; 

GetAttributeSpec:

	encode=ENCODEKEYWORD 

	| (variant=VARIANTKEYWORD ( LPAREN text=FREE_TEXT RPAREN )? ) 

	| display=DISPLAYKEYWORD 

	| extension=EXTENSIONKEYWORD

	| optional=OPTIONALKEYWORD 	

; 

SingleConstDef:

	name=IDENTIFIER array=ArrayDef? assign=ASSIGNMENTCHAR expr=ConstantExpression;

terminal DECODED_MODIFIER returns ecore::EString:

	'@decoded';

terminal DEFAULT_MODIFIER returns ecore::EString:

	'@default';

terminal NOCASE_MODIFIER returns ecore::EString:

	'@nocase';	

terminal OVERRIDEKEYWORD returns ecore::EString:

	'override';

terminal LOCAL_MODIFIER returns ecore::EString:

	'@local';

terminal OPTIONALKEYWORD returns ecore::EString:

	'optional';

import de.ugoe.cs.swe.tTCN3.TemplateInstance

import de.ugoe.cs.swe.tTCN3.TemplateRefWithParList

import de.ugoe.cs.swe.tTCN3.SingleTemplateExpression

import de.ugoe.cs.swe.tTCN3.ActualParAssignment

//TODO: switch to TTCN3LocalScopeProvider as base class?

class TTCN3ScopeProvider extends AbstractDeclarativeScopeProvider {

		return s

	}	

	def IScope scope_ActualParAssignment_name(ActualParAssignment it, EReference par) {

		var list = <EObject>newArrayList

		var container = findDesiredParent(ModuleDefinition)

		list.addAll(container.eAllOfType(TTCN3Package.eINSTANCE.formalTemplatePar.instanceClass as Class<? extends EObject>))

		list.addAll(container.eAllOfType(TTCN3Package.eINSTANCE.formalValuePar.instanceClass as Class<? extends EObject>))

		list.addAll(container.eAllOfType(TTCN3Package.eINSTANCE.formalPortPar.instanceClass as Class<? extends EObject>))

		list.addAll(container.eAllOfType(TTCN3Package.eINSTANCE.formalTimerPar.instanceClass as Class<? extends EObject>))

		var s = scopeFor(list) //TODO: why does this return Null scope?

		return s

	}

	//TODO: reuse and cache

	//TODO: check in IDE.. may need to be deactivated

	//TODO: switch to this everywhere

import de.ugoe.cs.swe.tTCN3.FdecvalueUnichar

import de.ugoe.cs.swe.tTCN3.Fint2enum

import de.ugoe.cs.swe.tTCN3.FormalTemplatePar

import de.ugoe.cs.swe.tTCN3.FunctionActualPar

import de.ugoe.cs.swe.tTCN3.FunctionDef

import de.ugoe.cs.swe.tTCN3.FunctionDefList

import de.ugoe.cs.swe.tTCN3.FunctionFormalPar

import static extension org.eclipse.xtext.EcoreUtil2.*

import de.ugoe.cs.swe.tTCN3.Enumeration

import de.ugoe.cs.swe.tTCN3.FormalValuePar

import de.ugoe.cs.swe.tTCN3.ActualPar

class DataFlowValidator extends AbstractDeclarativeValidator {

    var debug = false;

    protected def void processAltstepInstance(AltstepInstance altstep, DataFlowHelper dfh) {

        if (altstep.list !== null && altstep.ref.params !== null) {

            altstep.list.params.processParameters(altstep.ref.params.params, dfh)

            altstep.list.actual.processParameters(altstep.ref.params.params, dfh)

        }

    }

            //TODO: also external functions?

            if (r instanceof FunctionDef) {

                if (r.parameterList !== null) {

                    function.params.params.processParameters(r.parameterList.params, dfh)

                    function.params.actual.processParameters(r.parameterList.params, dfh)

                }

            } else if (r instanceof ExtFunctionDef) {

                if (r.list !== null) {

                    function.params.params.processParameters(r.list.params, dfh)

                    function.params.actual.processParameters(r.list.params, dfh)

                }

            } else if (r instanceof AltstepDef) {

                //TODO: remove?

                if (r.params !== null) {

                    function.params.params.processParameters(r.params.params, dfh)

                    function.params.actual.processParameters(r.params.params, dfh)

                }

            } else {

                //handle other cases

        }

    }

    protected def void processParameters(EList<FunctionActualPar> actualParameters, EList<FunctionFormalPar> formalParameters, DataFlowHelper dfh) {

    protected def void processParameters(EList<ActualPar> actualParameters, EList<FunctionFormalPar> formalParameters, DataFlowHelper dfh) {

        var i = 0;

        //actual parameters

        for (p : actualParameters) {