grammar MyLang;

options {
  language=C;
  output=AST;
  backtrack=true;
}

tokens {
  SourceToken;
  CondToken;
  FuncDefToken;
  FuncSignatureToken;
  ArgListToken;
  TypeRefToken;
  ArrayToken;
  ExpressionToken;
  CallToken;
  LoopToken;
  RepeatToken;
  ArgToken;
  Body;
}

source
  : sourceItem* -> ^(SourceToken sourceItem*)
  ;

sourceItem
  :  'def' funcSignature body? 'end'-> ^(FuncDefToken funcSignature body?)
  ;

funcSignature
  :  identifier '(' argList ')' ('of' typeRef)? -> ^(FuncSignatureToken ^(Identifier identifier) argList? typeRef)
  ;

argList
  :  arg (',' arg)* -> ^(ArgListToken arg+)
  ;

arg
  :  identifier ('of' typeRef) -> ^(ArgToken ^(Identifier identifier) typeRef?)
  ;

statement
  :  expression ';'!
  |  loopStatement -> ^(LoopToken loopStatement)
  |  breakStatement
  |  expressionStatement
  |  condStatement -> ^(CondToken condStatement)
  |  repeatStatement  -> ^(RepeatToken repeatStatement)
  ;

 body
	:	statement* -> ^(Body statement*)
	;

condStatement
  :  'if'! expression 'then'! body? ('else'! body)?
  ;

loopStatement
  :  ('while'|'until') expression body 'end'
  ;

repeatStatement
  :  'repeat' body ('while'|'until') expression ';'
  ;

breakStatement
  :  'break' ';'
  ;

expressionStatement
  :  expression ';'
  ;

blockStatement
  :  ('begin'|'{') (statement|source)* ('end'|'}')
  ;

expression
  :  assignmentExpression
  ;

slice
  :  expression '[' dec dec ']'
  ;

ranges
  :  expression ('..' expression)?
  ;

assignmentExpression
  :  logicalOrExpression (AssignmentOp^ assignmentExpression)?
  ;

logicalOrExpression
  :  logicalAndExpression ('||'^ logicalAndExpression)*
  ;

logicalAndExpression
  :  bitwiseOrExpression ('&&'^ bitwiseOrExpression)*
  ;

bitwiseOrExpression
  :  bitwiseXorExpression ('|'^ bitwiseXorExpression)*
  ;

bitwiseXorExpression
  :  bitwiseAndExpression ('^'^ bitwiseAndExpression)*
  ;

bitwiseAndExpression
  :  equalityExpression ('&'^ equalityExpression)*
  ;

equalityExpression
  :  relationalExpression (('=='|'!=')^ relationalExpression)*
  ;

relationalExpression
  :  shiftExpression (RelationalOp^ shiftExpression)*
  ;

shiftExpression
  :  additiveExpression (('<<'|'>>')^ additiveExpression)*
  ;

additiveExpression
  :  multiplicativeExpression (('+'|'-')^ multiplicativeExpression)*
  ;

multiplicativeExpression
  :  unaryExpression (('*'|'/'|'%')^ unaryExpression)*
  ;

unaryExpression
  :  ('!'|'~')^ unaryExpression
  |  (UnaryOp^)? primaryExpression
  ;

primaryExpression
  :  '('! assignmentExpression ')'!
  |  Literal
  |  Identifier (('(') => call)*
  ;

expressionList
  :  expression (','! expression)*
  ;

call
  :   expression '(' expressionList ')' -> ^(CallToken expressionList?)
  ;


typeRef  :  builtin
    |identifier
    |array
   ;

array
  :  'array'  '[' dec ']' -> ArrayToken
  ;

builtin
  :   BuiltIn
  ;


identifier
  :  Identifier
  ;

Literal
  :  Bool
  |  Bits
  |  Hex
  |  Dec
  |  Char
  |  Str
  ;

fragment
Bool:  ('true'|'false');

fragment
Bits:  '0' ('b'|'B') ('0'..'1')+;

fragment
Hex :  '0' ('x'|'X') ('0'..'9'|'a'..'f'|'A'..'F')+;

fragment
Dec  :  ('0'..'9')+;

fragment
Char:  '\'' ~('\'') '\'';

fragment
Str :  '"' ( ~('"'|'\\') | ('\\'.) )* '"';

BuiltIn
  :  'bool'
  |  'byte'
  |  'int'
  |  'uint'
  |  'long'
  |  'ulong'
  |  'char'
  |  'string'
  ;

Identifier
  :  ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
  ;

AssignmentOp
  :  ('+'|'-'|'*'|'/'|'%'|'<<'|'>>'|'&'|'^'|'|')? '='
  ;

RelationalOp
  :  ('<'|'<='|'>'|'>=')
  ;

UnaryOp
  :  ('++'|'--'|'+'|'-')
  ;

WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') { $channel=HIDDEN; };