grammar milestone_2;

tokens { INDENT, DEDENT }

start : (stmt NEWLINE?)* EOF;

stmt : complexOrSimpleStmt | NEWLINE | INDENT? NEWLINE DEDENT?;

complexOrSimpleStmt : complexStmt | simpleStmt;

complexStmt : ifStmt | forStmt | whileStmt | procStmt | functionCall  | whenStmt | caseStmt | typeStmt | blockStmt | macroStmt | templateStmt | condStmt;

simpleStmt : varStmt | constStmt | letStmt | identifierAssignment | echoStmt | assertStmt | importStmt | fromStmt | continueStmt | returnStmt | breakStmt | discardStmt;

identifierAssignment : IDENTIFIER array? (EQUALS|COLON) expression SEMI_COLON?;

identifierOperand : UNARY_OPERATOR? ( IDENTIFIER? array | singleValue | functionCall | (IDENTIFIER (DOT (IDENTIFIER | functionCall ))*)
| ARRAY OPEN_BRACK NUMBER_LIT+ (RANGE NUMBER_LIT+)? COMMA INT CLOSE_BRACK
| (NUMBER_LIT | CHAR_LIT) RANGE (identifierOperand)) | ternaryExpr | dataType;

letStmt : LET (identifierAssignment | NEWLINE INDENT letBlock DEDENT);

letBlock : identifierAssignment(NEWLINE identifierAssignment)* NEWLINE?;

equationStmt : identifierOperand ( operator identifierOperand)? (DOT functionCall)? | OPEN_PAREN equationStmt CLOSE_PAREN;

ternaryExpr : IF condStmt COLON expression ELSE COLON expression;

expression : (OPEN_PAREN expression CLOSE_PAREN (DOT functionCall)? | equationStmt (operator equationStmt)? );

discardStmt : DISCARD;

continueStmt : CONTINUE;

breakStmt : BREAK IDENTIFIER?;

returnStmt : RETURN expression?;

operator : ADD_OPERATOR | DIV_OPERATOR | DIV | MOD | MUL_OPERATOR | MINUS_OPERATOR | MODULUS | XOR_OPERATOR | AND_OPERATOR | OR_OPERATOR;

UNARY_OPERATOR : AT_OPERATOR | DOLLAR_OPERATOR | NOT;

BOOLEAN : TRUE | FALSE | 'bool';

array : OPEN_BRACK (declareElements | expression | dataType)? CLOSE_BRACK;

declareElements : singleValue (COMMA singleValue)*;

singleValue : CHAR_LIT | STR_LIT | (ADD_OPERATOR | MINUS_OPERATOR)? NUMBER_LIT | RSTR_LIT | TRIPLESTR_LIT | BOOLEAN;

blockStmt : BLOCK IDENTIFIER COLON NEWLINE INDENT stmt+ NEWLINE? DEDENT;

varStmt : VARIABLE (colonOrAssignment | (NEWLINE? INDENT? varBlock DEDENT?));

varBlock : (varColonStmt NEWLINE+)+;

varColonStmt : IDENTIFIER (COMMA IDENTIFIER)* COLON (dataType|identifierAssignment);

colonOrAssignment : ((identifierAssignment|varColonStmt));

constStmt : CONST (identifierAssignment | (NEWLINE INDENT constBlock DEDENT) );

constBlock : identifierAssignment (NEWLINE identifierAssignment)* NEWLINE?;

condExpr : expression (COMP_OPERATOR expression)*;

condStmt : condExpr (boolOperator condExpr)*;

boolOperator : AND | OR;

whenStmt : WHEN condStmt COLON ( (stmt NEWLINE?) | ifBody) elifStmt* elseStmt?;

ifStmt : IF condStmt COLON ( (stmt NEWLINE?) | ifBody) elifStmt* elseStmt?;

ifBody : NEWLINE INDENT stmt+ NEWLINE? DEDENT;

elifStmt : ELIF condStmt COLON NEWLINE INDENT stmt+ NEWLINE? DEDENT;
elseStmt : ELSE COLON (stmt | NEWLINE INDENT stmt+ NEWLINE? DEDENT);

echoStmt :
ECHO OPEN_PAREN (expression) (COMMA  (expression) )* CLOSE_PAREN
| ECHO (expression) (COMMA (expression))*;

assertStmt : ASSERT  NUMBER_LIT COMP_OPERATOR NUMBER_LIT  ;

functionParam : expression | IDENTIFIER EQUALS singleValue | varColonStmt ;

functionInput : (OPEN_PAREN (functionParam (COMMA functionParam)*)? CLOSE_PAREN) | (functionParam (COMMA functionParam)*);

functionCall : (IDENTIFIER (DOT IDENTIFIER)* | IDENTIFIER? array) functionInput?;

forIdentifier : IDENTIFIER (COMMA IDENTIFIER)* ;

forStmt : FOR forIdentifier IN identifierOperand COLON NEWLINE? INDENT? stmt+ NEWLINE? DEDENT? ;

whileStmt : WHILE condStmt COLON NEWLINE INDENT stmt+ NEWLINE? DEDENT;

typeStmt : TYPE NEWLINE INDENT typeDecl (NEWLINE typeDecl)* (NEWLINE INDENT stmt NEWLINE? DEDENT)? NEWLINE? DEDENT;

typeDecl : IDENTIFIER array? EQUALS REF? identifierOperand ;

caseStmt : CASE IDENTIFIER (COLON dataType)? NEWLINE (ofStmt)+ elseStmt?;

importStmt : IMPORT IDENTIFIER (COMMA IDENTIFIER)* ;

fromStmt: FROM IDENTIFIER(COMMA IDENTIFIER)* importStmt;

ofStmt : OF (singleValue(COMMA singleValue)*) COLON  ofBody ;

ofBody : NEWLINE? INDENT? (stmt)+ NEWLINE? DEDENT?;

procStmt : procDef (COLON dataType)? EQUALS procBody;

procBody : stmt | NEWLINE INDENT stmt+ NEWLINE? DEDENT;

procInputDef : IDENTIFIER (COLON dataType | EQUALS singleValue)?;

procIdentDef : (IDENTIFIER| GRAVE_ACCENT UNARY_OPERATOR GRAVE_ACCENT) ( array )? ;

procDef : PROC procIdentDef? OPEN_PAREN procInputDef (COMMA procInputDef)* CLOSE_PAREN ;

macroDef : MACRO procIdentDef? OPEN_PAREN procInputDef (SEMI_COLON procInputDef)* CLOSE_PAREN ;

macroStmt : macroDef (COLON dataType)? EQUALS procBody;

pragma : OPEN_BRACE DOT IDENTIFIER CLOSE_BRACE ;

templateDef : TEMPLATE procIdentDef? OPEN_PAREN procInputDef (COMMA procInputDef)* CLOSE_PAREN ;

templateStmt :  templateDef pragma? EQUALS procBody ;

SKIP_ : WS -> skip;

dataType : IDENTIFIER | STRING | INT | BOOLEAN | OBJECT | procDef | VARIABLE? IDENTIFIER array;

STRING : 'string';
INT : 'int';
TRUE : 'true';
FALSE : 'false';
MULTI_LINE_COMMENT : '#['(MULTI_LINE_COMMENT|.)*?']#';
DOCUMENTATION_COMMENTS : '##'.*? (NEWLINE | EOF);
COMMENT : '#'(.)*? (NEWLINE | EOF);
NEWLINE : '\r'? '\n' WS?;
fragment WS : ' '+;

ARRAY :'array';
INCLUDE : 'include';
INTERFACE : 'interface';
IS : 'is';
ISNOT : 'isnot';
ITERATOR : 'iterator';
LET : 'let';
MACRO : 'macro';
METHOD : 'method';
MIXIN : 'mixin';
MOD : 'mod';
NIL : 'nil';
NOT : 'not';
NOTIN : 'notin';
OBJECT : 'object';
OF : 'of';
OR : 'or';
OUT : 'out';
PROC : 'proc';
PTR : 'ptr';
RAISE : 'raise';
REF : 'ref';
RETURN : 'return';
SHL : 'shl';
SHR : 'shr';
STATIC : 'static';
TEMPLATE : 'template';
TRY : 'try';
TUPLE : 'tuple';
TYPE : 'type';
USING : 'using';
WHEN : 'when';
WHILE : 'while';
XOR : 'xor';
AND : 'and';
VARIABLE : 'var';
ADDR : 'addr';
AS : 'as';
ASM : 'asm';
BIND : 'bind';
BLOCK : 'block';
BREAK : 'break';
CASE : 'case';
CONCEPT : 'concept';
CONST : 'const';
CONTINUE : 'continue';
CONVERTER : 'converter';
DEFER : 'defer';
DISCARD : 'discard';
DISTINCT : 'distinct';
DIV : 'div';
DO : 'do';
ELIF : 'elif';
ELSE : 'else';
END : 'end';
ENUM : 'enum';
EXCEPT : 'except';
EXPORT : 'export';
FINALLY : 'finally';
FOR : 'for';
FROM : 'from';
FUNC : 'func';
IF : 'if';
IMPORT : 'import';
IN : 'in';
YIELD : 'yield';
ASSERT : 'assert';
ECHO : 'echo';
GRAVE_ACCENT : '`';
IDENTIFIER : [a-zA-Z]+ [0-9]* ( '_' ([a-zA-Z] | [0-9]) )*;
NUMBER_LIT : INT_LIT | INT8_LIT | INT16_LIT | INT32_LIT | INT64_LIT | UINT_LIT | UINT8_LIT | UINT16_LIT | UINT32_LIT | UINT64_LIT | FLOAT_LIT | FLOAT32_LIT | FLOAT64_LIT;
INT_LIT : HEX_LIT | DEC_LIT | OCT_LIT | BIN_LIT;
DEC_LIT : DIGIT+ ( '_' DIGIT+ )*;
BIN_LIT : '0' ('b' | 'B' ) BINDIGIT+ ( [_] BINDIGIT+ )*;
HEX_LIT : '0' ('x' | 'X' ) HEXDIGIT+ ( '_' HEXDIGIT+ )*;
OCT_LIT : '0o' OCTDIGIT+ ( '_' OCTDIGIT )*;
INT8_LIT : INT_LIT ('\'') ('i' | 'I') '8';
INT16_LIT : INT_LIT ('\'') ('i' | 'I') '16';
INT32_LIT : INT_LIT ('\'') ('i' | 'I') '32';
INT64_LIT : INT_LIT ('\'') ('i' | 'I') '64';
UINT_LIT : INT_LIT ('\'') ('u' | 'U');
UINT8_LIT : INT_LIT ('\'') ('u' | 'U') '8';
UINT16_LIT : INT_LIT ('\'') ('u' | 'U') '16';
UINT32_LIT : INT_LIT ('\'') ('u' | 'U') '32';
UINT64_LIT : INT_LIT ('\'') ('u' | 'U') '64';
EXPONENT : ('e' | 'E' ) ('+' | '-') DIGIT+ ( '_' DIGIT+ )*;
FLOAT_LIT : DIGIT ('_' DIGIT+)* (('.' DIGIT+ ('_' DIGIT+)* (EXPONENT)*) |EXPONENT);
FLOAT32_SUFFIX : ('f' | 'F') '32';
FLOAT32_LIT : HEX_LIT '\'' FLOAT32_SUFFIX | (FLOAT_LIT | DEC_LIT | OCT_LIT | BIN_LIT) ('\'') FLOAT32_SUFFIX;
FLOAT64_SUFFIX : ( ('f' | 'F') '64' ) | 'd' | 'D';
FLOAT64_LIT : HEX_LIT '\'' FLOAT64_SUFFIX | (FLOAT_LIT | DEC_LIT | OCT_LIT | BIN_LIT) ('\'') FLOAT64_SUFFIX;
RANGE : '..' (LESS_THAN?);
EQUALS : '=';
COMP_OPERATOR : GREATER_THAN | LESS_THAN | ((GREATER_THAN | LESS_THAN)? EQUALS) | EQUALS_OPERATOR;
EQUALS_OPERATOR : EQUALS EQUALS;
ADD_OPERATOR : '+';
MUL_OPERATOR : '*';
DIGIT : [0-9];
LETTER : [a-zA-Z];
HEXDIGIT : DIGIT | [a-fA-F];
OCTDIGIT : [0-7];
BINDIGIT : [0-1];

DOLLAR_OPERATOR : '$';
MINUS_OPERATOR : '-';
DIV_OPERATOR : '/';
BITWISE_NOT_OPERATOR : '~';
AND_OPERATOR : '&';
OR_OPERATOR : '|';
LESS_THAN : '<';
GREATER_THAN : '>';
AT_OPERATOR : '@';
MODULUS : '%';
NOT_OPERATOR : '!';
XOR_OPERATOR : '^';
DOT : '.';
COLON : ':';
OPEN_PAREN : '(';
CLOSE_PAREN : ')';
OPEN_BRACE : '{';
CLOSE_BRACE : '}';
OPEN_BRACK : '[';
CLOSE_BRACK : ']';
COMMA : ',';
SEMI_COLON : ';';
STR_LIT : '"'.*?'"';
CHAR_LIT : '\''([a-zA-Z] | '[' | ']'
               |'\\'('r'
                    |'c'
                    |'n'
                    |'l'
                    |'f'
                    |'t'
                    |'v'
                    |'\\'
                    |'"'
                    |'\''
                    |DIGIT+
                    |'a'
                    |'b'
                    |'e'
                    |'x 'HEXDIGIT HEXDIGIT))'\'';
TRIPLESTR_LIT : '"""'.*?'"""';
RSTR_LIT : 'r''"'.*?'"';
GENERALIZED_STR_LIT : [a-zA-Z]+ STR_LIT;
GENERALIZED_TRIPLESTR_LIT : [a-zA-Z]+ TRIPLESTR_LIT;