GScript.g4

grammar GScript;


classDeclaration
    : CLASS IDENTIFIER
      (EXTENDS typeType)?
      (IMPLEMENTS typeList)?
      classBody
    ;

classBody
    : '{' classBodyDeclaration* '}'
    ;

// interfaceBody
//     : '{' interfaceBodyDeclaration* '}'
//     ;

classBodyDeclaration
    : ';'
    //| STATIC? block
    | memberDeclaration
    ;

memberDeclaration
    : functionDeclaration
//    | genericFunctionDeclaration
    | fieldDeclaration
    // | constructorDeclaration
    // | genericConstructorDeclaration
//     | interfaceDeclaration
    // | annotationTypeDeclaration
     //| classDeclaration
    // | enumDeclaration
    ;
functionDeclaration
    : typeTypeOrVoid? IDENTIFIER operatorOverloading? formalParameters ('[' ']')*
      (THROWS qualifiedNameList)?
      functionBody
    ;

operatorOverloading
    : PLUS
    | SUB
    | MULT
    | DIV
    | EQUAL
    | NOTEQUAL
    | LE
    | GE
    | GT
    | LT
    ;

functionBody
    : block
    | ';'
    ;

typeTypeOrVoid
    : typeType
    | VOID
    ;

qualifiedNameList
    : qualifiedName (',' qualifiedName)*
    ;

formalParameters
    : '(' formalParameterList? ')'
    ;

formalParameterList
    : formalParameter (',' formalParameter)* (',' lastFormalParameter)?
    | lastFormalParameter
    ;

formalParameter
    : variableModifier* typeType variableDeclaratorId
    ;

lastFormalParameter
    : variableModifier* typeType '...' variableDeclaratorId
    ;

variableModifier
// todo final require?
    : FINAL
    //| annotation
    ;

qualifiedName
    : IDENTIFIER ('.' IDENTIFIER)*
    ;


fieldDeclaration
    //: typeType variableDeclarators ';'
    : variableDeclarators ';'
    ;

variableDeclarators
    : typeType variableDeclarator (',' variableDeclarator)*
    ;

variableDeclarator
    : variableDeclaratorId ('=' variableInitializer)?
    ;

variableDeclaratorId
    : IDENTIFIER ('[' ']')*
    ;

variableInitializer
    : arrayInitializer
    | expr
    ;

arrayInitializer
    : ('[' expr (',' expr)? ']')? '{' (variableInitializer (',' variableInitializer)* (',')? )? '}'
    ;


classOrInterfaceType
    : IDENTIFIER ('.' IDENTIFIER)*
    //: IDENTIFIER
    ;


literal
//    : integerLiteral #Int
    : DECIMAL_LITERAL
//    | floatLiteral #Float
    | FLOAT_LITERAL
//    | CHAR_LITERAL
    | string_
    | BOOL_LITERAL
    | NULL_LITERAL
    | Nil
    ;

string_
    :RAW_STRING_LIT
    |STRING_LITERAL
    ;

prog
    : blockStatements
    ;

block
    : '{' blockStatements '}'
    ;

blockStatements
    : blockStatement* #BlockStms
    ;

blockStatement
    : variableDeclarators ';' #BlockVarDeclar
    | statement # BlockStm
   // | localTypeDeclaration
    | functionDeclaration #BlockFunc
    | classDeclaration #BlockClassDeclar
    ;

statement
    : blockLabel=block #StmBlockLabel
    | IF parExpression statement (ELSE statement)? #StmIfElse
    | FOR '(' forControl ')' statement #StmFor
    | FOR parExpression statement #StmWhile
    | RETURN expr?  ';'#StmReturn
    | BREAK IDENTIFIER? ';' #StmBreak
    | CONTINUE IDENTIFIER? ';' # StmContinue
    | statementExpression=expr ';'#StmExpr
    ;

forControl
    : forInit? ';' expr? ';' forUpdate=expressionList?
    ;

forInit
    : variableDeclarators
    | expressionList
    ;

parExpression
    : '(' expr ')'
    ;


expressionList
    : expr (',' expr)*
    ;


functionCall
    : IDENTIFIER '(' expressionList? ')'
    | THIS '(' expressionList? ')'
    | SUPER '(' expressionList? ')'
    ;


expr
    : primary
    | expr bop='.'
      ( IDENTIFIER
      | functionCall
      )
    | array=expr '[' index=expr ']'
    | functionCall
    | lhs=expr postfix=('++' | '--')
    | prefix=('-'|'+') rhs=expr
    | prefix=('~'|'!') rhs=expr
    | lhs=expr bop=( MULT | DIV ) rhs=expr
    | lhs=expr bop=MOD rhs=expr
    | lhs=expr bop=( PLUS | SUB ) rhs=expr
    | lhs=expr bop=(LE | GE | GT | LT ) rhs=expr
    | lhs=expr bop=(EQUAL | NOTEQUAL) rhs=expr
    | lhs=expr bop='&&' rhs=expr
    | lhs=expr bop='||' rhs=expr
    | IDENTIFIER'[' (expr) ':' (expr) ']'
    // 表明结合性是右结合的，内部原理使用循环代替递归。
    | <assoc=right> lhs=expr
      bop=('=' | '+=' | '-=' | '*=')
      rhs=expr
    ;

primary
    : '(' expr ')'
    //| THIS
    //| SUPER
    | literal
    | IDENTIFIER
    // | typeTypeOrVoid '.' CLASS
    ;


typeList
    : typeType (',' typeType)*
    ;


typeType
    : (classOrInterfaceType| functionType | primitiveType) ('[' ']')*
    ;


functionType
    : FUNCTION typeTypeOrVoid? '(' typeList? ')'
    ;

primitiveType
    : INT
    | STRING
    | FLOAT
    | BOOLEAN
    | BYTE
    | ANY
    ;


integerLiteral
    : DECIMAL_LITERAL
//    | HEX_LITERAL
//    | OCT_LITERAL
//    | BINARY_LITERAL
    ;
floatLiteral
    : FLOAT_LITERAL
//    | HEX_FLOAT_LITERAL
    ;


parse
 : expr_list+=expr+ EOF
 ;

// Keywords
CLASS:              'class';
EXTENDS:            'extends';
IMPLEMENTS:         'implements';
FINAL:              'final';
THROWS:             'throws';
INT:                'int';
STRING:             'string';
FLOAT:              'float';
BOOLEAN:            'bool';
BYTE:               'byte';
SUPER:              'super';
SWITCH:             'switch';
THIS:               'this';
Nil:                'nil';
ANY:                'any';


// Separators

LPAREN:             '(';
RPAREN:             ')';
LBRACE:             '{';
RBRACE:             '}';
LBRACK:             '[';
RBRACK:             ']';
DOT:                '.';
COLON:              ':';

ASSIGN:             '=';
GT:                 '>';
LT:                 '<';
BANG:               '!';
TILDE:              '~';
AND:                '&&';
OR:                 '||';
INC:                '++';
DEC:                '--';
MULT : '*';
DIV  : '/';
PLUS : '+';
SUB  : '-';
MOD  : '%';

ADD_ASSIGN:         '+=';
SUB_ASSIGN:         '-=';
MUL_ASSIGN:         '*=';
DIV_ASSIGN:         '/=';
EQUAL:              '==';
LE:                 '<=';
GE:                 '>=';
NOTEQUAL:           '!=';

FUNCTION:           'func';
VOID:               'void';
FOR:                'for';
IF:                 'if';
ELSE:               'else';
RETURN:             'return';
BREAK:              'break';
CONTINUE:           'continue';

BOOL_LITERAL:       'true'
            |       'false'
            ;


//CHAR_LITERAL:       '\'' (~['\\\r\n] | EscapeSequence) '\'';

STRING_LITERAL:     '"' (~["\\\r\n] | EscapeSequence)* '"';
RAW_STRING_LIT         : '^' ~'^'*                      '^';


NULL_LITERAL:       'null';

DECIMAL_LITERAL:    ('0' | [1-9] (Digits? | '_'+ Digits)) [lL]?;
FLOAT_LITERAL:      (Digits '.' Digits? | '.' Digits) ExponentPart? [fFdD]?
             |       Digits (ExponentPart [fFdD]? | [fFdD])
             ;

ELLIPSIS:           '...';

// Whitespace and comments

WS:                 [ \t\r\n\u000C]+ -> channel(HIDDEN);
COMMENT:            '/*' .*? '*/'    -> channel(HIDDEN);
LINE_COMMENT:       '//' ~[\r\n]*    -> channel(HIDDEN);
IDENTIFIER:         Letter LetterOrDigit*;
fragment Digits
    : [0-9] ([0-9_]* [0-9])?
    ;


SPACES
 : [ \t\r\n] -> skip
 ;

fragment D : [0-9];

fragment Letter
    : [a-zA-Z$_] // these are the "java letters" below 0x7F
    | ~[\u0000-\u007F\uD800-\uDBFF] // covers all characters above 0x7F which are not a surrogate
    | [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF
    ;

fragment LetterOrDigit
    : Letter
    | [0-9]
    ;

fragment ExponentPart
    : [eE] [+-]? Digits
    ;

fragment EscapeSequence
    : '\\' [btnfr"'\\]
    | '\\' ([0-3]? [0-7])? [0-7]
    | '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit
    ;

fragment HexDigit
    : [0-9a-fA-F]
    ;