anchor.diff:  goToStmt : GOTO WS valueStmt;
   
   ifThenElseStmt : 
  -	IF WS ifConditionStmt WS THEN WS blockStmt (WS ELSE WS blockStmt)? # inlineIfThenElse
  -	| ifBlockStmt ifElseIfBlockStmt* ifElseBlockStmt? END_IF # blockIfThenElse
  +	IF WS ifConditionStmt WS THEN WS blockStmt (WS ELSE WS blockStmt)?	# inlineIfThenElse
  +	| ifBlockStmt ifElseIfBlockStmt* ifElseBlockStmt? END_IF			# blockIfThenElse
   ;
   
   ifBlockStmt : 
  
positive.code: 
  unlockStmt : UNLOCK WS valueStmt (WS? ',' WS? valueStmt (WS TO WS valueStmt)?)?;
  
  valueStmt : 
  	literal # vsLiteral
  	| midStmt # vsMid
  	| NEW WS valueStmt # vsNew
  	| implicitCallStmt_InStmt # vsValueCalls
  	| typeOfStmt # vsTypeOf
  	| LPAREN WS? valueStmt (WS? ',' WS? valueStmt)* RPAREN # vsStruct
  	| implicitCallStmt_InStmt WS? ASSIGN WS? valueStmt # vsAssign
  	| valueStmt WS? PLUS WS? valueStmt # vsAdd
  	| PLUS WS? valueStmt # vsPlus
  	| ADDRESSOF WS valueStmt # vsAddressOf
  	| valueStmt WS AMPERSAND WS valueStmt # vsAmp
  	| valueStmt WS AND WS valueStmt # vsAnd
  	| valueStmt WS? LT WS? valueStmt # vsLt
  	| valueStmt WS? LEQ WS? valueStmt # vsLeq
  	| valueStmt WS? GT WS? valueStmt # vsGt
  	| valueStmt WS? GEQ WS? valueStmt # vsGeq
  	| valueStmt WS? EQ WS? valueStmt # vsEq
  	| valueStmt WS? NEQ WS? valueStmt # vsNeq
  	| valueStmt WS? DIV WS? valueStmt # vsDiv
  	| valueStmt WS EQV WS valueStmt # vsEqv
  	| valueStmt WS IMP WS valueStmt # vsImp
  	| valueStmt WS IS WS valueStmt # vsIs
  	| valueStmt WS LIKE WS valueStmt # vsLike
  	| valueStmt WS? MINUS WS? valueStmt # vsMinus
  	| MINUS WS? valueStmt # vsNegation
  	| valueStmt WS? MOD WS? valueStmt # vsMod
  	| valueStmt WS? MULT WS? valueStmt # vsMult
  	| NOT WS valueStmt # vsNot
  	| valueStmt WS? OR WS? valueStmt # vsOr
  	| valueStmt WS? POW WS? valueStmt # vsPow
  	| valueStmt WS? XOR WS? valueStmt # vsXor
  ;
  
  variableStmt : (DIM | STATIC | visibility) WS (WITHEVENTS WS)? variableListStmt;
  
negative.code: 	| eCS_MemberProcedureCall 
  ;
  
  // parantheses are required in case of args -> empty parantheses are removed
  eCS_ProcedureCall : CALL WS ambiguousIdentifier typeHint? (WS? LPAREN WS? argsCall WS? RPAREN)?;
  
  // parantheses are required in case of args -> empty parantheses are removed
  eCS_MemberProcedureCall : CALL WS implicitCallStmt_InStmt? '.' ambiguousIdentifier typeHint? (WS? LPAREN WS? argsCall WS? RPAREN)?;
  
  
  implicitCallStmt_InBlock :
  	iCS_B_ProcedureCall
  	| iCS_B_MemberProcedureCall
  ;
  
  // parantheses are forbidden in case of args
  // variables cannot be called in blocks
  // certainIdentifier instead of ambiguousIdentifier for preventing ambiguity with statement keywords 
  iCS_B_ProcedureCall : certainIdentifier (WS argsCall)?;
  
  iCS_B_MemberProcedureCall : implicitCallStmt_InStmt? '.' ambiguousIdentifier typeHint? (WS argsCall)? dictionaryCallStmt?;
  
  
  // iCS_S_MembersCall first, so that member calls are not resolved as separate iCS_S_VariableOrProcedureCalls
  implicitCallStmt_InStmt :
  	iCS_S_MembersCall
  	| iCS_S_VariableOrProcedureCall
  	| iCS_S_ProcedureOrArrayCall
  	| iCS_S_DictionaryCall
  ;
  
  iCS_S_VariableOrProcedureCall : ambiguousIdentifier typeHint? dictionaryCallStmt?;
  
  iCS_S_ProcedureOrArrayCall : (ambiguousIdentifier | baseType) typeHint? WS? LPAREN WS? (argsCall WS?)? RPAREN dictionaryCallStmt?;
  
  iCS_S_MembersCall : (iCS_S_VariableOrProcedureCall | iCS_S_ProcedureOrArrayCall)? iCS_S_MemberCall+ dictionaryCallStmt?;
  
  iCS_S_MemberCall : '.' (iCS_S_VariableOrProcedureCall | iCS_S_ProcedureOrArrayCall);
  
  iCS_S_DictionaryCall : dictionaryCallStmt;
  
  
  // atomic call statements ----------------------------------
  
  argsCall : (argCall? WS? (',' | ';') WS?)* argCall (WS? (',' | ';') WS? argCall?)*;
  
  argCall : ((BYVAL | BYREF | PARAMARRAY) WS)? valueStmt;
  
  dictionaryCallStmt : '!' ambiguousIdentifier typeHint?;
  
  
  // atomic rules for statements
  