Pseudo-Compact .g

grammar pseudoC;

options {
  output=AST;
  backtrack=true;
}

tokens {
    Program;
    Declaration;
    Codeblock;
    Variables;
    Statements;
    Return;
    Var;
    FUNC_CALL;
    UnaryMin;
    Negation;
    Lookup;
    Indices;
    Assignment;
    VarDeclare;
    If;
    Exp;
    Switch;
    Case;
    Default;
    ExpList;
    IdList;
    List;
}

@parser::header {
  package us.cio.lily;

  import us.cio.lily.tree.*;

  import java.util.Map;
  import java.util.HashMap;
}

@lexer::header {
  package us.cio.lily;
}

@parser::members {

    public Map<String, Function> functions = new HashMap<String, Function>();

    private void defineFunction(String id, Object idList, Object block) {

    // `idList` is possibly null!  Create an empty tree in that case.
    CommonTree idListTree = idList == null ? new CommonTree() : (CommonTree)idList;

    // `block` is never null
    CommonTree blockTree = (CommonTree)block;

    // The function name with the number of parameters after it, is the unique key
    String key = id + idListTree.getChildCount();
    functions.put(key, new Function(id, idListTree, blockTree));
  }

}

parse
  : codeblock EOF -> codeblock
  ;

// Parser Rules

codeblock
    :   BEGIN (statement | functDecl)* (RETURN expression SCOLON)? END
    ->  ^(Codeblock ^(Statements statement*) ^(Return expression?))
    ;

statement
    :   assignment SCOLON -> assignment
    |   varDeclare SCOLON -> varDeclare
    |   functionCall SCOLON -> functionCall
    |   ifStatement
    |   whileLoop
    |   doWhileLoop
    |   forLoop
    |   switchStatement
    ;

functionCall
    :   ID O_PAREN exprList? C_PAREN    -> ^(FUNC_CALL ID exprList?)
    |   SCANSTRING O_PAREN expression C_PAREN -> ^(FUNC_CALL SCANSTRING expression)
    |   SCANNUMBER O_PAREN expression C_PAREN -> ^(FUNC_CALL SCANNUMBER expression)
    |   PRINTING O_PAREN expression C_PAREN -> ^(FUNC_CALL PRINTING expression)
    |   WRITE O_PAREN expression C_PAREN -> ^(FUNC_CALL WRITE expression)
    ;

assignment
    :   ID indices? EQUAL TO expression
    ->  ^(Assignment ID indices? expression)
    ;

varDeclare
    :   DATATYPE ID indices? EQUAL TO expression
    ->  ^(VarDeclare DATATYPE ID indices? expression)
    ;

ifStatement
    :   basicIfState elseIfState* elseState? SCOLON
    ->  ^(If    basicIfState elseIfState* elseState?)
    ;

basicIfState
    :   WHEN O_PAREN expression C_PAREN DO codeblock
    ->  ^(Exp   expression codeblock)
    ;

elseIfState
    :   OR ELSE IF O_PAREN expression C_PAREN DO codeblock
    ->  ^(Exp   expression codeblock)
    ;

elseState
    :   ELSE DO codeblock
    ->  ^(Exp   codeblock)
    ;

whileLoop
    :   AS LONG AS O_PAREN expression C_PAREN DO codeblock SCOLON
    ->  ^(AS LONG AS    expression codeblock)
    ;

doWhileLoop
    :   PERFORM codeblock AS LONG AS O_PAREN expression C_PAREN SCOLON
    ->  ^(PERFORM   codeblock expression)
    ;

forLoop
    :   WHERE ID '=' expression UNTIL expression DO codeblock SCOLON
    ->  ^(WHERE ID expression expression codeblock)
    ;

switchStatement
    :   USING O_PAREN expression C_PAREN AND WITH O_CURLY caseEnum+ defaultState? C_CURLY SCOLON
    ->  ^(Switch    expression caseEnum+ defaultState?)
    ;

caseEnum
    :   CASE expression DO codeblock ('break' SCOLON | 'continue' SCOLON)?
    ->  ^(Case expression codeblock)
    ;

defaultState
    :   WHEN DEFAULTKEY DO codeblock 'break' SCOLON
    ->  ^(Default codeblock)
    ;

functDecl
    :   DEFINE ID O_PAREN idList? C_PAREN codeblock
        {defineFunction($ID.text,$idList.tree,$codeblock.tree);}
    ;

idList
    :   ID (COMMA ID)*
    ->  ^(IdList    ID+)
    ;

exprList
    :   expression (COMMA expression)*
    ->  ^(ExpList   expression+)
    ;

expression
    :   orExpr
    ;

orExpr
    :   andExpr (OR^ andExpr)*
    ;

andExpr
    :   equalExpr (AND^ equalExpr)*
    ;

equalExpr
    :   relationExpr (('==' | '!=')^ relationExpr)*
    ;

relationExpr
    :   addExpr (('>' | '<' | '>=' | '<=')^ addExpr)*
    ;

addExpr
    :   mulExpr ((ADD | SUB)^ mulExpr)*
    ;

mulExpr
    :   unaryExpr ((MULT | DIV | MOD)^ unaryExpr)*
    ;

unaryExpr
    :   SUB atom    -> UnaryMin atom
    |   NOT ARROW atom  -> Negation atom
    |   atom
    ;

atom
    :   INT
    |   FLOAT
    |   BOOL
    |   lookup
    ;

lookup
    :   functionCall indices?   -> ^(Lookup functionCall indices?)
    |   list indices? -> ^(Lookup list indices?)
    |   O_PAREN expression C_PAREN indices? -> ^(Lookup expression indices?)
    |   ID indices? -> ^(Lookup ID indices?)
    |   STRING indices? -> ^(Lookup STRING indices?)
    ;

list    :   '[' exprList? ']' -> ^(List exprList?) ;

indices :   ('[' expression ']')+  -> ^(Indices expression+)
    ;


// Lexer Rules

BEGIN   :   'begin';
END :   'end';
USING   :   'using';
DEFINE  :   'define';
WHEN    :   'when' ;
WHERE   :   'where';
UNTIL   :   'until';
CASE    :   'case';
DO  :   'do' ;
AS  :   'as' ;
LONG    :   'long';
OR  :   'or' ;
RETURN  :   'return' ;
AND     :   'and' ;
WITH    :   'with' ;
EQUAL   :   'equal' ;
IS  :   'is';
IF  :   'if';
NOT :   'not';
TO  :   'to';
LESS    :   'less';
GREATER :   'greater';
THAN    :   'than';
WRITE   :   'write';
PRINTING
    :   'printing' ;
PERFORM :   'perform' ;
ELSE    :   'else' ;
DEFAULTKEY  :   'default' ;
BREAK   :   'break' ;
CONTINUE:   'continue' ;
SCANSTRING
    :   'scanString' ;
SCANNUMBER
    :   'scanNumber' ;
DATATYPE
    :   'num'
    |   'char'
    |   'String'
    ;
O_PAREN :   '(';
C_PAREN :   ')';
O_CURLY :   '{';
C_CURLY :   '}';
O_ANGLE :   '<';
C_ANGLE :   '>';
COMMA   :   ',';
SCOLON  :   ';';
FULLSTOP:   '.';
ASSIGN  :   ':=';
ARROW   :   '->';
SUB :   '-';
ADD :   '+';
MULT    :   '*';
DIV :   '/';
MOD :   'mod';
BOOL    :   'true' | 'false' ;

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

INT :   '0'..'9'+
    ;

FLOAT
    :   ('0'..'9')+ '.' ('0'..'9')* EXPONENT?
    |   '.' ('0'..'9')+ EXPONENT?
    |   ('0'..'9')+ EXPONENT
    ;

WS  :   ( ' '
        | '\t'
        | '\r'
        | '\n'
        ) {skip();}
    ;

STRING
@after {
  setText(getText().substring(1, getText().length()-1).replaceAll("\\\\(.)", "$1"));
}
    :  '"' ( ESC_SEQ | ~('\\'|'"') )* '"'
    |  '\'' (~('\'' | '\\') | '\\' ('\\' | '\''))* '\''
    ;

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

fragment
EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;

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

fragment
ESC_SEQ
    :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
    |   UNICODE_ESC
    |   OCTAL_ESC
    ;

fragment
OCTAL_ESC
    :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
    |   '\\' ('0'..'7') ('0'..'7')
    |   '\\' ('0'..'7')
    ;

fragment
UNICODE_ESC
    :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
    ;