added predefined function support

	{ActionText} FREE_TEXT | Expression;

BehaviourStatements:

	TestcaseInstance | FunctionInstance | ReturnStatement | AltConstruct | InterleavedConstruct | LabelStatement |

	GotoStatement | {BehaviourStatements} REPEATSTATEMENT | DeactivateStatement | AltstepInstance | ActivateOp |

	{BehaviourStatements} BREAKSTATEMENT | {BehaviourStatements} CONTINUESTATEMENT;

	testcase=TestcaseInstance | function=FunctionInstance | return=ReturnStatement |

	alt=AltConstruct | interleaved=InterleavedConstruct | label=LabelStatement | goto=GotoStatement |

	{BehaviourStatements} REPEATSTATEMENT | deactivate=DeactivateStatement | altstep=AltstepInstance |

	activate=ActivateOp | {BehaviourStatements} BREAKSTATEMENT | {BehaviourStatements} CONTINUESTATEMENT;

ActivateOp:

	ACTIVATEKEYWORD LPAREN AltstepInstance RPAREN;

	FunctionDef | ExtFunctionDef;

	//(IDENTIFIER DOT)? IDENTIFIER;

//PreDefFunctionIdentifier returns ecore::EString:

//	IDENTIFIER;

FunctionActualParList:

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

	asssign+=FunctionActualParAssignment)*);

FunctionActualParAssignment:

	TemplateInstanceAssignment | ComponentRefAssignment | ArrayIdentifierRefAssignment;

	template=TemplateInstanceAssignment | component=ComponentRefAssignment | array=ArrayIdentifierRefAssignment;

	// FormalValuePar according to antlr implementation

ComponentRefAssignment:

	{ComponentRef} (ref=ComponentOrDefaultReference | SYSTEMKEYWORD | SELFOP | MTCKEYWORD);

ComponentOrDefaultReference:

	variable=VariableRef | function=FunctionInstance;

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

TestcaseInstance:

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

	name=IDENTIFIER arryRefs+=ArrayOrBitRef*;

BasicStatements:

	LogStatement | StatementBlock | LoopConstruct | ConditionalConstruct | SelectCaseConstruct | Assignment;

	log=LogStatement | block=StatementBlock | loop=LoopConstruct | conditional=ConditionalConstruct |

	select=SelectCaseConstruct | assign=Assignment;

StatementBlock:

	{StatementBlock} LBRACKET (def+=FunctionDefList | stat+=FunctionStatementList)* RBRACKET;

	(statements+=FunctionStatement sc+=SEMICOLON?)+;

FunctionStatement:

	TimerStatements | BasicStatements | BehaviourStatements | SetLocalVerdict | CommunicationStatements |

	ConfigurationStatements | SUTStatements | TestcaseOperation;

	timer=TimerStatements | basic=BasicStatements | behavior=BehaviourStatements | verdict=SetLocalVerdict |

	communication=CommunicationStatements | configuration=ConfigurationStatements | sut=SUTStatements |

	test=TestcaseOperation;

TestcaseOperation:

	{TestcaseOperation} TESTCASEKEYWORD DOT STOPKEYWORD (LPAREN ((txt+=FREE_TEXT | template+=InLineTemplate) COMMA?)*

	SETVERDICTKEYWORD LPAREN expression=SingleExpression (COMMA log+=LogItem)* RPAREN;

ConfigurationStatements:

	ConnectStatement | MapStatement | DisconnectStatement | UnmapStatement | DoneStatement | KilledStatement |

	StartTCStatement | StopTCStatement | KillTCStatement;

	connect=ConnectStatement | map=MapStatement | disconnect=DisconnectStatement | unmap=UnmapStatement |

	done=DoneStatement | killed=KilledStatement | startTc=StartTCStatement | stopTc=StopTCStatement |

	killTc=KillTCStatement;

KillTCStatement:

	{KillTCStatement} KILLKEYWORD | ((ComponentReferenceOrLiteral | {KillTCStatement} ALLKEYWORD COMPONENTKEYWORD) DOT

	STOPKEYWORD;

ComponentReferenceOrLiteral:

	ComponentOrDefaultReference | {ComponentReferenceOrLiteral} MTCKEYWORD | {ComponentReferenceOrLiteral} SELFOP;

	ref=ComponentOrDefaultReference | {ComponentReferenceOrLiteral} MTCKEYWORD | {ComponentReferenceOrLiteral} SELFOP;

StartTCStatement:

	ref=ComponentOrDefaultReference DOT STARTKEYWORD LPAREN function=FunctionInstance RPAREN;

	component=ComponentRef COLON array=ArrayIdentifierRef;

CommunicationStatements:

	SendStatement | CallStatement | ReplyStatement | RaiseStatement | ReceiveStatement | TriggerStatement |

	GetCallStatement | GetReplyStatement | CatchStatement | CheckStatement | ClearStatement | StartStatement |

	StopStatement | HaltStatement | CheckStateStatement;

	send=SendStatement | call=CallStatement | reply=ReplyStatement | raise=RaiseStatement | receive=ReceiveStatement |

	trigger=TriggerStatement | getCall=GetCallStatement | getReply=GetReplyStatement | catch=CatchStatement |

	check=CheckStatement | clear=ClearStatement | start=StartStatement | stop=StopStatement | halt=HaltStatement |

	checkState=CheckStateStatement;

CheckStateStatement:

	PortOrAllAny DOT CHECKSTATEKEYWORD LPAREN expr=SingleExpression RPAREN;

	port=PortOrAllAny DOT CHECKSTATEKEYWORD LPAREN expr=SingleExpression RPAREN;

PortOrAllAny:

	PortOrAll | {PortOrAllAny} ANYKEYWORD PORTKEYWORD;

	port=PortOrAll | {PortOrAllAny} ANYKEYWORD PORTKEYWORD;

HaltStatement:

	PortOrAll DOT HALTKEYWORD;

	port=PortOrAll DOT HALTKEYWORD;

StartStatement:

	PortOrAll DOT STARTKEYWORD;

	port=PortOrAll DOT STARTKEYWORD;

StopStatement:

	PortOrAll DOT STOPKEYWORD;

	port=PortOrAll DOT STOPKEYWORD;

ClearStatement:

	PortOrAll DOT CLEAROPKEYWORD;

	port=PortOrAll DOT CLEAROPKEYWORD;

PortOrAll:

	ArrayIdentifierRef | {PortOrAll} ALLKEYWORD PORTKEYWORD;

	ref=ArrayIdentifierRef | {PortOrAll} ALLKEYWORD PORTKEYWORD;

RaiseStatement:

	array=ArrayIdentifierRef DOT op=PortRaiseOp;

	array=ArrayIdentifierRef DOT op=PortReplyOp;

PortReplyOp:

	REPLYKEYWORD LPAREN InLineTemplate value=ReplyValue? RPAREN to=ToClause?;

	REPLYKEYWORD LPAREN template=InLineTemplate value=ReplyValue? RPAREN to=ToClause?;

ReplyValue:

	VALUEKEYWORD Expression;

	VALUEKEYWORD expr=Expression;

CallStatement:

	array=ArrayIdentifierRef DOT op=PortCallOp body=PortCallBody?;

PortCallOp:

	CALLOPKEYWORD LPAREN CallParameters RPAREN to=ToClause?;

	CALLOPKEYWORD LPAREN params=CallParameters RPAREN to=ToClause?;

CallParameters:

	InLineTemplate (COMMA value=CallTimerValue)?;

	template=InLineTemplate (COMMA value=CallTimerValue)?;

CallTimerValue:

	Expression | {CallTimerValue} NOWAITKEYWORD;

	expr=Expression | {CallTimerValue} NOWAITKEYWORD;

PortCallBody:

	LBRACKET CallBodyStatementList RBRACKET;

	LBRACKET callBody=CallBodyStatementList RBRACKET;

CallBodyStatementList:

	(body+=CallBodyStatement SEMICOLON?)+;

CallBodyStatement:

	CallBodyGuard block=StatementBlock;

	call=CallBodyGuard block=StatementBlock;

CallBodyGuard:

	AltGuardChar ops=CallBodyOps;

	guard=AltGuardChar ops=CallBodyOps;

CallBodyOps:

	GetReplyStatement | CatchStatement;

	reply=GetReplyStatement | catch=CatchStatement;

SendStatement:

	array=ArrayIdentifierRef DOT port=PortSendOp;

PortSendOp:

	SENDOPKEYWORD LPAREN InLineTemplate RPAREN to=ToClause?;

	SENDOPKEYWORD LPAREN template=InLineTemplate RPAREN to=ToClause?;

ToClause:

	{ToClause} TOKEYWORD (template=InLineTemplate | ref=AddressRefList | ALLKEYWORD COMPONENTKEYWORD);

OpCall:

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

	testcase=TestcaseInstance | activate=ActivateOp | templateOps=TemplateOps fieldTemplate+=ExtendedFieldReference* |

	field+=ExtendedFieldReference+;

	preFunction=PreDefFunction | testcase=TestcaseInstance | activate=ActivateOp | templateOps=TemplateOps

	fieldTemplate+=ExtendedFieldReference* | field+=ExtendedFieldReference+;

AliveOp:

	ComponentId DOT ALIVEKEYWORD;

enum BooleanValue:

	true | false;

	/*

 * Predefined Functions.

 * Changed TemplateInstance to TemplateOrRange

 */

PreDefFunction:

	Fint2char | Fint2unichar | Fint2bit | Fint2enum | Fint2hex | Fint2oct | Fint2str | Fint2float | Ffloat2int |

	Fchar2int | Fchar2oct | Funichar2int | Funichar2oct | Fbit2int | Fbit2hex | Fbit2oct | Fbit2str | Fhex2int | Fhex2bit

	| Fhex2oct | Fhex2str | Foct2int | Foct2bit | Foct2hex | Foct2str | Foct2char | Foct2unichar | Fstr2int | Fstr2hex |

	Fstr2oct | Fstr2float | Fenum2int | Flengthof | Fsizeof | Fispresent | Fischosen | Fisvalue | Fisbound | Fregexp |

	Fsubstr | Freplace | Fencvalue | Fdecvalue | FencvalueUnichar | FdecvalueUnichar | Frnd | Ftestcasename;

Fint2char:

	'int2char' LPAREN e1=SingleExpression RPAREN;

Fint2unichar:

	'int2unichar' LPAREN e1=SingleExpression RPAREN;

Fint2bit:

	'int2bit' LPAREN e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Fint2enum:

	'int2enum' LPAREN e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Fint2hex:

	'int2hex' LPAREN e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Fint2oct:

	'int2oct' LPAREN e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Fint2str:

	'int2str' LPAREN e1=SingleExpression RPAREN;

Fint2float:

	'int2float' LPAREN e1=SingleExpression RPAREN;

Ffloat2int:

	'float2int' LPAREN e1=SingleExpression RPAREN;

Fchar2int:

	'char2int' LPAREN e1=SingleExpression RPAREN;

Fchar2oct:

	'char2oct' LPAREN e1=SingleExpression RPAREN;

Funichar2int:

	'unichar2int' LPAREN e1=SingleExpression RPAREN;

Funichar2oct:

	'unichar2oct' LPAREN expr+=SingleExpression (COMMA expr+=SingleExpression)? RPAREN;

Fbit2int:

	'bit2int' LPAREN e1=SingleExpression RPAREN;

Fbit2hex:

	'bit2hex' LPAREN e1=SingleExpression RPAREN;

Fbit2oct:

	'bit2oct' LPAREN e1=SingleExpression RPAREN;

Fbit2str:

	'bit2str' LPAREN e1=SingleExpression RPAREN;

Fhex2int:

	'hex2int' LPAREN e1=SingleExpression RPAREN;

Fhex2bit:

	'hex2bit' LPAREN e1=SingleExpression RPAREN;

Fhex2oct:

	'hex2oct' LPAREN e1=SingleExpression RPAREN;

Fhex2str:

	'hex2str' LPAREN e1=SingleExpression RPAREN;

Foct2int:

	'oct2int' LPAREN e1=SingleExpression RPAREN;

Foct2bit:

	'oct2bit' LPAREN e1=SingleExpression RPAREN;

Foct2hex:

	'oct2hex' LPAREN e1=SingleExpression RPAREN;

Foct2str:

	'oct2str' LPAREN e1=SingleExpression RPAREN;

Foct2char:

	'oct2char' LPAREN e1=SingleExpression RPAREN;

Foct2unichar:

	'oct2unichar' LPAREN expr+=SingleExpression (COMMA expr+=SingleExpression)? RPAREN;

Fstr2int:

	'str2int' LPAREN e1=SingleExpression RPAREN;

Fstr2hex:

	'str2hex' LPAREN e1=SingleExpression RPAREN;

Fstr2oct:

	'str2oct' LPAREN e1=SingleExpression RPAREN;

Fstr2float:

	'str2float' LPAREN e1=SingleExpression RPAREN;

Fenum2int:

	'enum2int' LPAREN e1=SingleExpression RPAREN;

Flengthof:

	'lengthof' LPAREN t1=TemplateOrRange RPAREN;

Fsizeof:

	'sizeof' LPAREN t1=TemplateOrRange RPAREN;

Fispresent:

	'ispresent' LPAREN t1=TemplateOrRange RPAREN;

Fischosen:

	'ischosen' LPAREN t1=TemplateOrRange RPAREN;

Fisvalue:

	'isvalue' LPAREN t1=TemplateOrRange RPAREN;

Fisbound:

	'isbound' LPAREN t1=TemplateOrRange RPAREN;

Fregexp:

	'regexp' LPAREN t1=TemplateOrRange COMMA e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Fsubstr:

	'substr' LPAREN t1=TemplateOrRange COMMA e1=SingleExpression COMMA e2=SingleExpression RPAREN;

Freplace:

	'replace' LPAREN e1=SingleExpression COMMA e2=SingleExpression COMMA e3=SingleExpression COMMA e4=SingleExpression

	RPAREN;

Fencvalue:

	'encvalue' LPAREN t1=TemplateOrRange RPAREN;

Fdecvalue:

	'decvalue' LPAREN e1=SingleExpression COMMA e2=SingleExpression RPAREN;

FencvalueUnichar:

	'encvalue_unichar' LPAREN t1=TemplateOrRange (COMMA e1=SingleExpression? RPAREN);

FdecvalueUnichar:

	'decvalue_unichar' LPAREN e1=SingleExpression COMMA e2=SingleExpression (COMMA e3=SingleExpression)? RPAREN;

Frnd:

	{Frnd} 'rnd' LPAREN e1=SingleExpression? RPAREN;

Ftestcasename:

	{Ftestcasename} 'testcasename' LPAREN RPAREN;

 No newline at end of file