Lexer

grammar hhl;

options {
  language = Java;
  output = AST;
  ASTLabelType = CommonTree;
}

tokens {
  PRINT; PRINT_STRING; SLEEP; DO_CLICK; SELECT_CONTEXT_MENU; MAP_MOVE; MAP_MOVE_STEP; IS_CURSOR; SEND_ACTION; SEND_ACTION2; MAP_CLICK; MAP_INTERACT_CLICK;
  MAP_INTERACT_CLICK2; DROP; INPUT_GET_OBJECT; HAVE_INVENTORY; SET_INVENTORY; RESET_INVENTORY; NEXT_ITEM; GET_ITEMS_COUNT; MAP_ABS_INTERACT_CLICK;
  SET_ITEM_INDEX; IS_ITEM_NAME; ITEM_QUALITY; ITEM_CLICK; ITEM_CLICK2; ITEM_COORD_X; ITEM_COORD_Y; ITEM_NUM; ITEM_METER; ITEM_DROP; WAIT_CRAFT; CHECK_CRAFT;
  FIND_OBJECT_BY_NAME; CRAFT; ITEM_DROP_TO_INVENTORY; FIND_OBJECT_BY_TYPE; EQUIP; INVENTORY; INVENTORY2; MAP_ABS_CLICK; MY_COORD_X; MY_COORD_Y;
  IS_ITEM_TOOLTIP; EXIT; LOGOUT; SAY; FIND_MAP_OBJECT; OPEN_INVENTORY; SET_SHOW_VAR; SET_ITEM_DRAG; SET_ITEM_EQUIP;
  RENDER_MODE; GET_OBJECT_BLOB; RESET_BUFF; NEXT_BUFF; BUFF_METER; BUFF_TIME_METER; IS_BUFF_NAME; MAP_PLACE; BUILD_CLICK;

  NOT; NEGATE;
  PROGRAM; INCLUDE; INCLUDELIST; VARIABLES; FUNCTIONS; CALL;
  IF; IFELSE; WHILE; FOR; RETURN; BREAK; CONTINUE; STMTS; EXPR; EXPRLIST; VAR; INDEX; NUM; BLOCK; EMPTY; NOP;
  VARDECL; ARRAYDECL; ASSIGN; POSTFIX; PREFIX;
  FUNCTION; VARPARAM; ARRAYPARAM; PARAMATERS;
}

@header {
package haven.hhl;
}

@lexer::header {
package haven.hhl;
}

//----------------------------------------------------------------------
// SYNTAX

start
    :   includeList program                 -> {stream_includeList.size() > 0 }? ^(INCLUDELIST includeList) program
                                            -> ^(INCLUDELIST EMPTY) program
    ;

program
    :   varList functionList                ->  {stream_varList.size()>0 }? ^(PROGRAM ^(VARIABLES varList) ^(FUNCTIONS functionList) ^(CALL {adaptor.create(IDENT,"main")} ^(EXPRLIST)))
                                            -> ^(PROGRAM ^(VARIABLES EMPTY) ^(FUNCTIONS functionList) ^(CALL {adaptor.create(IDENT,"main")} ^(EXPRLIST)))
    ;

includeList
    :   include*
    ;

include
    :   ('#include' '<' IDENT '>')          -> ^(INCLUDE IDENT)
    ;

functionList
    :   functionDeclaration+
    ;

functionDeclaration
    :   TYPE IDENT paramList act=block      -> ^(FUNCTION TYPE IDENT ^(PARAMATERS paramList) $act)
    ;

paramList
    :   '(' ')'                             -> EMPTY
    |   '(' paramDecl (',' paramDecl)* ')'  -> paramDecl+
    ;

paramDecl
    :   TYPE IDENT                          -> ^(VARPARAM TYPE IDENT)
    |   TYPE '[' ']' IDENT                  -> ^(ARRAYPARAM TYPE IDENT)
    ;

block
    :   '{' '}'                             -> ^(BLOCK EMPTY)
    |   '{' statement+ '}'                  -> ^(BLOCK statement+)
    ;

statement
options { backtrack = true; }
    :   ';'                                 -> NOP
    |   varDeclaration
    |   expression ';'                      -> expression
    |   IDENT '=' expression ';'            -> ^(ASSIGN IDENT expression)
    |   if_statement
    |   while_statement
    |   for_statement
    |   'return' expression ';'             -> ^(RETURN expression)
    |   'break' ';'                         -> BREAK
    |   'continue' ';'                      -> CONTINUE
    |   'sleep' '(' expression ')' ';'      -> ^(SLEEP expression)
    |   'print' '(' expression ')' ';'      -> ^(PRINT expression)
    |   'print' '(' s=STRING ')' ';'        -> ^(PRINT_STRING $s)
    |   'exit' ';'                          -> ^(EXIT)
    |   'logout' ';'                        -> ^(LOGOUT)
    |   'say' '(' s=STRING ')' ';'          -> ^(SAY $s)
    |   'do_click' '(' obj=expression ',' btn=expression ',' mod=expression ')' ';'
                                            -> ^(DO_CLICK $obj $btn $mod)
    |   'select_context_menu' '(' sname=STRING ')' ';'
                                            -> ^(SELECT_CONTEXT_MENU $sname)
    |   'map_move' '(' id=expression ',' x=expression ',' y=expression ')' ';'
                                            -> ^(MAP_MOVE $id $x $y)
    |   'map_move_step' '(' x=expression ',' y=expression ')' ';'
                                            -> ^(MAP_MOVE_STEP $x $y)
    |   'send_action' '(' sname=STRING ')' ';'
                                            -> ^(SEND_ACTION $sname)
    |   'send_action' '(' sname=STRING ',' sname2=STRING ')' ';'
                                            -> ^(SEND_ACTION2 $sname $sname2)
    |   'map_click' '(' x=expression ',' y=expression ',' btn=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_CLICK $x $y $btn $mod)
    |   'map_interact_click' '(' x=expression ',' y=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_INTERACT_CLICK $x $y $mod)
    |   'map_abs_interact_click' '(' x=expression ',' y=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_ABS_INTERACT_CLICK $x $y $mod)
    |   'map_interact_click' '(' id=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_INTERACT_CLICK2 $id $mod)
    |   'drop' '(' mod=expression ')' ';'
                                            -> ^(DROP $mod)
    |   'reset_inventory' '(' ')' ';'
                                            -> ^(RESET_INVENTORY)
    |   'set_item_index' '(' index=expression ')' ';'
                                            -> ^(SET_ITEM_INDEX $index)
    |   'set_item_drag' '(' ')' ';'
                                            -> ^(SET_ITEM_DRAG)
    |   'item_click' '(' action=STRING ')' ';'
                                            -> ^(ITEM_CLICK $action)
    |   'item_click' '(' action=STRING ',' mod=expression ')' ';'
                                            -> ^(ITEM_CLICK2 $action $mod)
    |   'item_drop' '(' x=expression ',' y=expression ')' ';'
                                            -> ^(ITEM_DROP $x $y)
    |   'item_drop_to_inventory' '(' n=STRING ',' x=expression ',' y=expression ')' ';'
                                            -> ^(ITEM_DROP_TO_INVENTORY $n $x $y)
    |   'craft' '(' a=expression ')' ';'
                                            -> ^(CRAFT $a)
    |   'equip' '(' slot=expression ',' act=STRING ')' ';'
                                            -> ^(EQUIP $slot $act)
    |   'inventory' '(' n=STRING ',' x=expression ',' y=expression ',' act=STRING ')' ';'
                                            -> ^(INVENTORY $n $x $y $act)
    |   'inventory' '(' n=STRING ',' x=expression ',' y=expression ',' act=STRING ',' mod=expression ')' ';'
                                            -> ^(INVENTORY $n $x $y $act $mod)
    |   'map_abs_click' '(' x=expression ',' y=expression ',' btn=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_ABS_CLICK $x $y $btn $mod)
    |   'wait_craft' '(' wnd=STRING ')' ';'
                                            -> ^(WAIT_CRAFT $wnd)
    |   'open_inventory' '(' ')'            -> ^(OPEN_INVENTORY)
    |   'set_show_var' '(' s=STRING ')' ';' -> ^(SET_SHOW_VAR $s)
    |   'render_mode' '(' x=expression ')' ';'
                                            -> ^(RENDER_MODE $x)
    |   'reset_buff' '(' ')' ';'            -> ^(RESET_BUFF)
    |   'map_place' '(' x=expression ',' y=expression ',' btn=expression ',' mod=expression ')' ';'
                                            -> ^(MAP_PLACE $x $y $btn $mod)
    |   'build_click' '(' ')' ';'           -> ^(BUILD_CLICK)
    |   'set_item_equip' '(' i=expression ')' ';'
                                            -> ^(SET_ITEM_EQUIP $i)

    |   block
    ;

for_statement
    :   'for' '(' ini=expression ';' tes=expression ';' inc=expression ')' statement
                                            -> $ini ^(WHILE $tes ^(BLOCK statement $inc))
    |   'for' '(' t=TYPE name=IDENT '=' ini=expression ';' tes=expression ';' inc=expression ')' statement
                                            -> ^(VARDECL $t $name) ^(ASSIGN $name $ini) ^(WHILE $tes ^(BLOCK statement $inc))
    ;

if_statement
options { backtrack = true; }
    :   'if' '(' expression ')' a1=statement 'else' a2=statement -> ^(IF ^(EXPR expression) $a1 $a2)
    |   'if' '(' expression ')' a1=statement   -> ^(IF ^(EXPR expression) $a1 NOP)
    ;

while_statement
    :   'while' '(' expression ')' statement -> ^(WHILE expression statement)
    |   'do' st=statement 'while' '(' e=expression ')' ';' -> $st ^(WHILE $e $st)
    ;

varList
    :   varDeclaration*
    ;

varDeclaration
    :   TYPE IDENT ';'                      -> ^(VARDECL TYPE IDENT)
    |   TYPE IDENT '=' expression ';'       -> ^(VARDECL TYPE IDENT) ^(ASSIGN IDENT expression)
    |   TYPE IDENT '[' INT ']' ';'          -> ^(ARRAYDECL TYPE IDENT INT)
    ;

expressionList
    :   '(' ')'                             -> ^(EXPRLIST)
    |   '(' expression (',' expression)* ')' -> ^(EXPRLIST expression+)
    ;

expression
options {backtrack=true;}
    :   IDENT '=' expression                -> ^(ASSIGN IDENT expression)
    |   arrayIndex '=' expression           -> ^(ASSIGN arrayIndex expression)
    |   orExpression
    ;

orExpression
    :   andExpression ( ('or' | '||')^ andExpression)*
    ;

andExpression
    :   equalExpression ( ('and' | '&&')^ equalExpression)*
    ;

equalExpression
    :   comparsionExpression ( ('==' | '!=' | '<>')^ comparsionExpression)*
    ;

comparsionExpression
    :   addExpression ( ('>' | '<' | '>=' | '<=')^ addExpression)*
    ;

addExpression
    :   multExpression ( ('+' | '-')^ multExpression)*
    ;

multExpression
    :   notExpression ( ('*' | '/' | '%')^ notExpression)*
    ;

notExpression
    :   (op='!'|'not')? negationExpression  -> {$op != null}? ^(NOT negationExpression)
                                            -> negationExpression
    ;

negationExpression
    :   (op='-')? primary                   -> {$op != null}? ^(NEGATE primary)
                                            -> primary
    ;

primary
    :   atom
    |   '(' expression ')'                  -> expression
    ;

atom
    :   IDENT '++' -> ^(POSTFIX ^(VAR IDENT) ^(NUM {adaptor.create(INT,"1")}) )
    |   IDENT '--' -> ^(POSTFIX ^(VAR IDENT) ^(NUM {adaptor.create(INT,"-1")}))
    |   '++' IDENT -> ^(PREFIX ^(VAR IDENT) ^(NUM {adaptor.create(INT,"1")}))
    |   '--' IDENT -> ^(PREFIX ^(VAR IDENT) ^(NUM {adaptor.create(INT,"-1")}))
    |   IDENT                                   -> ^(VAR IDENT)
    |   INT                                     -> ^(NUM INT)
    |   IDENT expressionList                    -> ^(CALL IDENT expressionList)
    |   'is_cursor' '(' cur=STRING ')'          -> ^(IS_CURSOR $cur)
    |   arrayIndex
    |   'input_get_object' '(' msg=STRING ')'   -> ^(INPUT_GET_OBJECT $msg)
    |   'have_inventory' '(' name=STRING ')'    -> ^(HAVE_INVENTORY $name)
    |   'set_inventory' '(' name=STRING ')'
                                                -> ^(SET_INVENTORY $name)
    |   'next_item' '(' ')'                     -> ^(NEXT_ITEM)
    |   'get_items_count' '(' ')'               -> ^(GET_ITEMS_COUNT)
    |   'is_item_name' '(' name=STRING ')'      -> ^(IS_ITEM_NAME $name)
    |   'is_item_tooltip' '(' name=STRING ')'   -> ^(IS_ITEM_TOOLTIP $name)
    |   'item_quality' '(' ')'                  -> ^(ITEM_QUALITY)
    |   'item_coord_x' '(' ')'                  -> ^(ITEM_COORD_X)
    |   'item_coord_y' '(' ')'                  -> ^(ITEM_COORD_Y)
    |   'item_num' '(' ')'                      -> ^(ITEM_NUM)
    |   'item_meter' '(' ')'                    -> ^(ITEM_METER)
    |   'find_object_by_name' '(' n=STRING ',' r=expression ')' -> ^(FIND_OBJECT_BY_NAME $n $r)
    |   'find_object_by_type' '(' n=STRING ',' r=expression ')' -> ^(FIND_OBJECT_BY_TYPE $n $r)
    |   'find_map_object' '(' n=STRING ',' r=expression ',' x=expression ',' y=expression ')' -> ^(FIND_MAP_OBJECT $n $r $x $y)
    |   'my_coord_x' '(' ')'                    -> ^(MY_COORD_X)
    |   'my_coord_y' '(' ')'                    -> ^(MY_COORD_Y)
    |   'check_craft' '(' wnd=STRING ')'        -> ^(CHECK_CRAFT $wnd)
    |   'get_object_blob' '(' id=expression ',' ind=expression ')' -> ^(GET_OBJECT_BLOB $id $ind)
    |   'next_buff' '(' ')'                     -> ^(NEXT_BUFF)
    |   'buff_meter' '(' ')'                    -> ^(BUFF_METER)
    |   'buff_time_meter' '(' ')'                -> ^(BUFF_TIME_METER)
    |   'is_buff_name' '(' n=STRING ')'         -> ^(IS_BUFF_NAME $n)

    ;

arrayIndex
    :   s=IDENT '[' expression ']'              -> ^(INDEX IDENT expression)
;

//----------------------------------------------------------------------
// LEXER

TYPE
    :   'void'
    |   'int'
    ;

IDENT
    :   (LETTER | '_') (LETTER | DIGIT | '_')*
    ;

STRING
//    :  '"' ( LETTER | DIGIT )* '"'
    :   '"'
        { StringBuilder b = new StringBuilder(); }
        (   '"' '"'             { b.appendCodePoint('"');}
        |   c=~('"'|'\r'|'\n')  { b.appendCodePoint(c);}
        )*
        '"'
        { setText(b.toString()); }
        ;

INT :   DIGIT+
    ;

fragment DIGIT
    :    '0'..'9'
    ;

fragment LETTER
    :   ('a'..'z' | 'A'..'Z')
    ;

fragment NEWLINE
    :   '\r'|'\n'
    ;

MULTILINE_COMMENT : '/*' .* '*/' {$channel = HIDDEN;} ;
LINECOMMENT : '//' ~('\r'|'\n')* NEWLINE {$channel=HIDDEN;}
;
WS : (' ' | '\t' | '\n' | '\r' | '\f')+ {$channel = HIDDEN;};