grammar Mantra;
options {
output=AST;
}

tokens {
UNIT;
SLIST; // statement list
ELIST; // expression list; args of method call, array ref
CLOSURE; // x:{...}
    LIST; // [1,2]
ARG;
FILTER;
    MAP; // [x=y, a="hi"]
    APPLY; // apply code to expression
    SINK; // stream => sink
EXPR; // indicates root of an expression
PROGRAM; // indicates direct execution of code; usually main
METHOD;
FIELD;
CALL;
INDEX;
FIELDACCESS;// o.field
    UNARY_MINUS;// unary operators
    UNARY_PLUS;
    UNARY_NOT;
UNARY_BNOT;
}

@header {
package tool;
}
@lexer::header {
package tool;
}

compilationUnit
: typeDefinition+ -> ^(UNIT typeDefinition+)
| statement+ -> ^(PROGRAM statement+)
;

typeDefinition
: modifier!? classDefinition
| modifier!? interfaceDefinition
;

classDefinition
: 'class' ID
('extends' sup=typename)?
('implements' i+=classname (',' i+=classname)*)?
'{'
field*
methodDefinition[true]*
'}'
-> ^('class' ID ^('extends' $sup)? ^('implements' $i+)?
methodDefinition*
)
;

interfaceDefinition
: 'interface' ID ('extends' sup+=classname (',' sup+=classname)* )?
'{'
( constant
| methodDefinition[false]
)*
'}'
-> ^('interface' ID ^('extends' $sup+)? constant* methodDefinition* )
;

field
: ID '=' expression ';' -> ^(FIELD ID expression)
;

constant
: 'const' ID '=' expression ';' -> ^('const' ID expression)
;

methodDefinition[boolean needBody]
: modifier? mname=ID
'(' idList? ')'
( {needBody}? compoundStatement
| {!needBody}? ';'
)
-> ^(METHOD ID idList? compoundStatement?)
;

modifier
: 'public'
| 'static'
| 'const'
| 'abstract'
;

typename
: classname
| builtInType
;

builtInType
: 'object'
    | 'void'
    | 'char'
| 'boolean'
| 'int'
| 'float'
| 'long'
| 'double'
| 'stream'
| 'string'
| datastructure
;

datastructure
: 'set'
| 'linkedlist'
| 'list'
| 'map'
;

compoundStatement
: '{' statement+ '}' -> ^(SLIST statement+)
;

statement
: (primary '++')=> primary '++'^ ';'!
| (primary '--')=> primary '--'^ ';'!
| (assignment)=> assignment
| (stream_sink)=> stream_sink
| (completeExpression ';')=> completeExpression ';'! // can this only be a function call?
| 'if' '(' equalityExpression ')' s1=statement
( 'else' s2=statement -> ^('if' ^(EXPR equalityExpression) $s1 $s2)
| -> ^('if' ^(EXPR equalityExpression) $s1)
)
| 'return'^ completeExpression ';'!
| 'break' ';' -> 'break'
| ';'!
;

expressionList
: completeExpression (',' completeExpression)* -> ^(ELIST completeExpression+)
| -> ELIST
;

// flip to var def if first assignment?
assignment
: lvalue
( '='^
        | '+='^
        | '-='^
        | '*='^
        | '/='^
        )
completeExpression
';'!
;

/** lhs of an assignment */
lvalue
: postfixExpression -> ^(EXPR postfixExpression)
;

completeExpression
: expression -> ^(EXPR expression)
;

expression
: conditionalExpression
;

conditionalExpression
: logicalOrExpression
// ( '?'^ conditionalExpression ':'! conditionalExpression )?
// do we really need this? Ambig with apply closure ':'
;

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

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

inclusiveOrExpression
: exclusiveOrExpression ('|'^ exclusiveOrExpression)*
;

exclusiveOrExpression
: andExpression ('^'^ andExpression)*
;

// bitwise or non-short-circuiting and (&)
andExpression
: equalityExpression ('&'^ equalityExpression)*
;

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

relationalExpression
: shiftExpression
( ( ( '<'^
| '>'^
| '<='^
| '>='^
)
shiftExpression
)*
)
;

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

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

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

unaryExpression
: '-' unaryExpression -> ^(UNARY_MINUS unaryExpression)
| '+' unaryExpression -> ^(UNARY_PLUS unaryExpression)
| '!' unaryExpression -> ^(UNARY_NOT unaryExpression)
| '~' unaryExpression -> ^(UNARY_BNOT unaryExpression)
| postfixExpression
;

postfixExpression
: (primary->primary) // set return tree
( '(' args=expressionList ')' -> ^(CALL $postfixExpression $args)
| '[' ie=expression ']' -> ^(INDEX $postfixExpression $ie)
| '.' p=primary -> ^(FIELDACCESS $postfixExpression $p)
| ':' ID -> ^(APPLY ^(EXPR $postfixExpression) ID)
| ':' cl=closure -> ^(APPLY ^(EXPR $postfixExpression) $cl)
)*
;

primary
options {k=1;}
    : ID
| 'new' typename '(' expressionList ')' -> ^('new' typename expressionList)
    | ( '[' mapelement ) => mapliteral
    | listliteral
| NUM_INT
| NUM_FLOAT
| STRING
| CHAR
| 'null'
| 'true'
| 'false'
| 'super'
| 'this'
| '(' e=expression ')' -> $e
    | closure
;

/** { x; x!="ter" | println(x); } */
closure
: lc='{' ID
(';' equalityExpression)?
('|' statement+
         -> ^(CLOSURE[$lc]
          ^(ARG ID)
          ^(FILTER ^(EXPR equalityExpression))?
          ^(SLIST statement+)
          )
| -> ^(CLOSURE[$lc]
             ^(ARG ID)
             ^(FILTER ^(EXPR equalityExpression))?
             )
)
'}'
;

stream_sink
: completeExpression '=>' completeExpression ';' -> ^(SINK completeExpression+)
;

listliteral
    : '[' expressionList ']' -> ^(LIST expressionList)
    ;

mapliteral
    : '[' mapelement (',' mapelement)* ']' -> ^(MAP mapelement+)
    ;

mapelement
    : completeExpression '='^ completeExpression
    ;

classname
: ID
;

idList
: ID (',' ID)* -> ID+
;

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

NUM_INT
    : DECIMAL_LITERAL
    | HEX_LITERAL
    | OCTAL_LITERAL
    ;

fragment
DECIMAL_LITERAL: '1'..'9' ('0'..'9')* ('l'|'L')? ;

fragment
HEX_LITERAL: '0' ('x'|'X') ('0'..'9'|'a'..'f'|'A'..'F')+ ('l'|'L')? ;

fragment
OCTAL_LITERAL: '0' ('0'..'7')* ('l'|'L')? ;

NUM_FLOAT
    : DIGITS '.' (DIGITS)? (EXPONENT_PART)? (FLOAT_TYPE_SUFFIX)?
    | '.' DIGITS (EXPONENT_PART)? (FLOAT_TYPE_SUFFIX)?
    | DIGITS EXPONENT_PART FLOAT_TYPE_SUFFIX
    | DIGITS EXPONENT_PART
    | DIGITS FLOAT_TYPE_SUFFIX
    ;
    
fragment
DIGITS : ('0'..'9')+ ;

fragment
EXPONENT_PART: ('e'|'E') ('+'|'-')? DIGITS ;

fragment
FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;

STRING
    : '\"'
      ( options {greedy=false;}
      : ESCAPE_SEQUENCE
      | ~'\\'
      )*
      '\"'
    ;

CHAR
    : '\''
      ( ESCAPE_SEQUENCE
      | ~'\''
      )
      '\''
    ;

fragment
ESCAPE_SEQUENCE
    : '\\' 'b'
    | '\\' 't'
    | '\\' 'n'
    | '\\' 'f'
    | '\\' 'r'
    | '\\' '\"'
    | '\\' '\''
    | '\\' '\\'
    | '\\' '0'..'3' OCTAL_DIGIT OCTAL_DIGIT
    | '\\' OCTAL_DIGIT OCTAL_DIGIT
    | '\\' OCTAL_DIGIT
| UNICODE_CHAR
;

fragment
HEX_DIGIT
: '0'..'9'|'a'..'f'|'A'..'F'
;

fragment
OCTAL_DIGIT
: '0'..'7'
;

fragment
UNICODE_CHAR
: '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
;

SL_COMMENT
: '//' ~'\n'* '\n' {$channel=HIDDEN; }
;

ML_COMMENT
: '/*'
( options {greedy=false;} : . )*
'*/'
{$channel=HIDDEN;}
;

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