grammar milestone_2;

tokens { INDENT, DEDENT }

start : (stmt NEWLINE?)* EOF;

stmt : complexOrSimpleStmt | INDENT? NEWLINE DEDENT?;

complexOrSimpleStmt : complexStmt | simpleStmt;

complexStmt : forStmt | whileStmt | functionCall | ifStmt | whenStmt | caseStmt | typeStmt | blockStmt;

simpleStmt : varStmt | constStmt | letStmt | identifierAssignment | echoStmt | assertStmt | importStmt | fromStmt | controlStmt;

identifierAssignment : IDENTIFIER EQUALS equationStmt;

identifierOperand : UNARY_OPERATOR? (array|ARRAY_INDEX | NUMBER_LIT | CHAR_LIT | STR_LIT | BOOLEAN | functionCall | (IDENTIFIER (DOT (IDENTIFIER | functionCall ))*)
| ARRAY OPEN_BRACK NUMBER_LIT+ (RANGE NUMBER_LIT+)? COMMA INT CLOSE_BRACK
| (NUMBER_LIT | CHAR_LIT) RANGE (NUMBER_LIT | CHAR_LIT));


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

letBlock : identifierAssignment(NEWLINE identifierAssignment)* NEWLINE?;

equationStmt : identifierOperand (OPERATORS identifierOperand)?;

controlStmt : CONTROL_KEYWORD (IDENTIFIER)? | CONTINUE;

CONTROL_KEYWORD : CONTINUE | BREAK | RETURN;

OPERATORS : ADD_OPERATOR | DIV_OPERATOR | 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 | indexArray)? CLOSE_BRACK;

declareElements : LIT (COMMA LIT)*;

indexArray : equationStmt | LIT | identifierOperand;

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;

colonOrAssignment : ((identifierAssignment|varColonStmt));

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

constBlock : identifierAssignment (NEWLINE identifierAssignment)* NEWLINE?;

condStmt : equationStmt (COMP_OPERATOR identifierOperand)?;

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 NEWLINE INDENT stmt+ NEWLINE? DEDENT);

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

assertStmt : ASSERT  NUMBER_LIT EQUALS_OPERATOR NUMBER_LIT  ;

ARRAY_INDEX : IDENTIFIER OPEN_BRACK (IDENTIFIER|NUMBER_LIT) CLOSE_BRACK;

functionParameter : (IDENTIFIER | NUMBER_LIT | STR_LIT | equationStmt | identifierAssignment);

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

functionCall : (IDENTIFIER (DOT IDENTIFIER)* | ARRAY_INDEX) functionInput;

forIdentifier : IDENTIFIER (COMMA IDENTIFIER)* | ;

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

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

typeStmt :TYPE (NEWLINE INDENT IDENTIFIER EQUALS REF? identifierOperand )+ ;

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

importStmt : IMPORT IDENTIFIER (COMMA IDENTIFIER)* ;

fromStmt: FROM IDENTIFIER(COMMA IDENTIFIER)* importStmt;

ofStmt : OF (STR_LIT(COMMA STR_LIT)* | BOOLEAN(COMMA BOOLEAN)* | NUMBER_LIT(COMMA NUMBER_LIT)*) COLON  ofBody ;

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

SKIP_ : WS -> skip;

dataType : STRING | INT | BOOLEAN;

STRING : 'string';
INT : 'int';
TRUE : 'true';
FALSE : 'false';


COMMENT_STMT : MULTI_LINE_COMMENT | DOCUMENTATION_COMMENTS | COMMENT;
DOCUMENTATION_COMMENTS : '##'.*?;
MULTI_LINE_COMMENT : '#[' .*? ']#' ;
COMMENT : '#' ~('\n')*;
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';
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 : '..';
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;
LIT : STR_LIT | NUMBER_LIT;