diff --git a/code/fgame/CMakeLists.txt b/code/fgame/CMakeLists.txt index 1654cd14..179e0c4f 100644 --- a/code/fgame/CMakeLists.txt +++ b/code/fgame/CMakeLists.txt @@ -16,7 +16,14 @@ set(SOURCES_SHARED "../qcommon/str.cpp" ) -file(GLOB_RECURSE SOURCES_GAME "./*.c*" "../parser/*.c*" "../script/*.c*") +file( + GLOB_RECURSE + SOURCES_GAME + "./*.c*" + "../script/*.c*" + "../parser/generated/*.c*" + "../parser/parsetree.cpp" +) add_library(fgame SHARED ${SOURCES_GAME}) diff --git a/code/parser/bison_source.txt b/code/parser/bison_source.txt index c461c4f0..5a3064ba 100644 --- a/code/parser/bison_source.txt +++ b/code/parser/bison_source.txt @@ -34,28 +34,43 @@ extern int prev_yylex; extern yyparsedata parsedata; -#define YYLLOC node_pos( parsedata.pos - yyleng ) +int prev_yylex; +int out_pos; +int success_pos; + +#define YYLLOC node_pos(success_pos - yyleng) +#define TOKPOS(pos) node_pos(pos.sourcePos) %} %define parse.error verbose +%locations +%define api.location.type { parse_pos_t } -%expect 306 +%expect 127 -%token END 0 -%token TOKEN_EOL - -%left TOKEN_COMMA +%precedence TOKEN_EOF 0 "end of file" +%precedence TOKEN_EOL %union { stype_t s; } +%left TOKEN_COMMA + +%precedence TOKEN_IF +%right TOKEN_ELSE +%precedence TOKEN_WHILE TOKEN_FOR TOKEN_DO +%precedence TOKEN_IDENTIFIER + +%precedence TOKEN_LEFT_BRACES TOKEN_RIGHT_BRACES +%right TOKEN_LEFT_BRACKET TOKEN_RIGHT_BRACKET TOKEN_LEFT_SQUARE_BRACKET TOKEN_RIGHT_SQUARE_BRACKET + %right TOKEN_ASSIGNMENT TOKEN_PLUS_EQUALS TOKEN_MINUS_EQUALS TOKEN_MULTIPLY_EQUALS TOKEN_DIVIDE_EQUALS TOKEN_MODULUS_EQUALS TOKEN_AND_EQUALS TOKEN_EXCL_OR_EQUALS TOKEN_OR_EQUALS TOKEN_SHIFT_LEFT_EQUALS TOKEN_SHIFT_RIGHT_EQUALS - TOKEN_TERNARY + TOKEN_TERNARY TOKEN_COLON %left TOKEN_LOGICAL_OR %left TOKEN_LOGICAL_AND @@ -71,186 +86,216 @@ extern yyparsedata parsedata; %left TOKEN_PLUS TOKEN_MINUS %left TOKEN_MULTIPLY TOKEN_DIVIDE TOKEN_MODULUS -%token TOKEN_LISTENER - %right TOKEN_NEG TOKEN_NOT TOKEN_COMPLEMENT -%token TOKEN_FLOAT TOKEN_INTEGER TOKEN_IDENTIFIER TOKEN_STRING TOKEN_NIL TOKEN_NULL +%precedence TOKEN_STRING +%precedence TOKEN_INTEGER +%precedence TOKEN_FLOAT -%token TOKEN_LBRACKET TOKEN_RBRACKET +%precedence TOKEN_LISTENER +%precedence TOKEN_NIL TOKEN_NULL -%token TOKEN_COLON TOKEN_SEMICOLON TOKEN_DOLLAR TOKEN_DOUBLE_COLON TOKEN_NUMBER +%token TOKEN_DOUBLE_COLON +%left TOKEN_SEMICOLON +%right TOKEN_DOLLAR +%left TOKEN_NUMBER -%left TOKEN_LSQUARE TOKEN_RSQUARE TOKEN_LPAREN TOKEN_RPAREN TOKEN_INCREMENT TOKEN_DECREMENT TOKEN_PERIOD +%left TOKEN_INCREMENT TOKEN_DECREMENT TOKEN_PERIOD -%token TOKEN_MAKEARRAY TOKEN_ENDARRAY - TOKEN_CATCH TOKEN_TRY - TOKEN_DO TOKEN_FOR TOKEN_IF TOKEN_ELSE TOKEN_SWITCH TOKEN_WHILE - TOKEN_BREAK TOKEN_CASE TOKEN_CONTINUE - TOKEN_SIZE - TOKEN_END TOKEN_RETURN +%precedence TOKEN_CATCH TOKEN_TRY + TOKEN_SWITCH TOKEN_CASE + TOKEN_BREAK TOKEN_CONTINUE + TOKEN_SIZE + TOKEN_END TOKEN_RETURN + TOKEN_MAKEARRAY TOKEN_ENDARRAY -%type event_parameter_list event_parameter_list_need -%type statement_list statement makearray_statement_list makearray_statement -%type compound_statement +%type event_parameter_list event_parameter_list_need event_parameter +%type statement_list statement statement_declaration makearray_statement_list makearray_statement +%type compound_statement selection_statement iteration_statement %type expr %type func_prim_expr %type prim_expr %type nonident_prim_expr -%type number -%type identifier_prim +%type const_array_list +%type const_array +%type identifier_prim %start program %% -program: - newline statement_list { parsedata.val = node1( sval_statement_list, $2 ); } +program + : statement_list[list] { parsedata.val = node1(ENUM_statement_list, $list); } + | line_opt { parsedata.val = node0(ENUM_NOP); } ; -statement_list: - statement_list statement newline { $$ = append_node( $1, $2 ); } - //| statement_list error TOKEN_EOL { yyerrok; } - | statement newline { $$ = linked_list_end( $1 ); } - | newline { $$ = node0( sval_none ); } +statement_list + : statement { $$ = linked_list_end($1); } + | statement_list statement[stmt] { $$ = append_node($1, $stmt); } ; -statement: - TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON { $$ = node3( sval_label, $1.val, $2, YYLLOC ); } - | TOKEN_PLUS TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON { $$ = node3( sval_label, $2.val, $3, YYLLOC ); } - | TOKEN_MINUS TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON { $$ = node3( sval_privatelabel, $2.val, $3, YYLLOC ); } - | TOKEN_CASE prim_expr event_parameter_list TOKEN_COLON { $$ = node3( sval_case, $2, $3, YYLLOC ); } +statement + : line_opt statement_declaration[stmt_decl] line_opt { $$ = $stmt_decl; } + ; + +statement_declaration + : TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON { $$ = node3(ENUM_labeled_statement, $1, $2, TOKPOS(@1)); } + | TOKEN_CASE prim_expr event_parameter_list TOKEN_COLON { $$ = node3(ENUM_int_labeled_statement, $2, $3, TOKPOS(@1)); } | compound_statement - | TOKEN_IF prim_expr newline statement[S] newline { $$ = node3( sval_if, $2, $S, YYLLOC ); } - | TOKEN_IF prim_expr newline statement[S1] newline TOKEN_ELSE newline statement[S2] { $$ = node4( sval_ifelse, $2, $S1, $S2, YYLLOC ); } - | TOKEN_WHILE prim_expr newline statement { $$ = node4( sval_while, $2, $4, node0( sval_none ), YYLLOC ); } - | TOKEN_FOR TOKEN_LPAREN statement[SINIT] TOKEN_SEMICOLON expr[E] TOKEN_SEMICOLON statement_list[INC] TOKEN_RPAREN newline statement[S] - { - sval_u while_stmt = node4( sval_while, $E, $S, node1( sval_statement_list, $INC ), YYLLOC ); - $$ = node1( sval_statement_list, append_node( linked_list_end( $SINIT ), while_stmt ) ); - } - | TOKEN_FOR TOKEN_LPAREN TOKEN_SEMICOLON expr[E] TOKEN_SEMICOLON statement_list[INC] TOKEN_RPAREN newline statement[S] - { - $$ = node4( sval_while, $E, $S, node1( sval_statement_list, $INC ), YYLLOC ); - } - | TOKEN_DO newline statement[S] newline TOKEN_WHILE prim_expr[E] { $$ = node3( sval_do, $S, $E, YYLLOC ); } - | TOKEN_TRY newline compound_statement newline TOKEN_CATCH newline compound_statement { $$ = node3( sval_catch, $3, $7, YYLLOC ); } - | TOKEN_SWITCH prim_expr newline compound_statement { $$ = node3( sval_switch, $2, $4, YYLLOC ); } - | TOKEN_BREAK { $$ = node1( sval_break, YYLLOC ); } - | TOKEN_CONTINUE { $$ = node1( sval_continue, YYLLOC ); } - | TOKEN_IDENTIFIER event_parameter_list { $$ = node3( sval_cmd, $1.val, node1( sval_none, $2 ), node_pos( $1.sourcePos ) ); } - //| TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list { $$ = node3( sval_cmd, node_string( parsetree_string( str( $1.stringValue ) + "::" + $3.stringValue ) ), node1( sval_none, $4 ), $1.sourcePos ); } - | nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list { $$ = node4( sval_cmd_method, $1, $2.val, node1( sval_none, $3 ), node_pos( $2.sourcePos ) ); } - //| nonident_prim_expr TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list { $$ = node4( sval_cmd_method, $1, node_string( parsetree_string( str( $2.stringValue ) + "::" + $4.stringValue ) ), node1( sval_none, $5 ), $2.sourcePos ); } - | nonident_prim_expr TOKEN_ASSIGNMENT expr { $$ = node3( sval_assignment, $1, $3, YYLLOC ); } - | nonident_prim_expr TOKEN_PLUS_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_PLUS ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_MINUS_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_MINUS ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_MULTIPLY_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_MULTIPLY ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_DIVIDE_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_DIVIDE ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_MODULUS_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_PERCENTAGE ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_AND_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_BITWISE_AND ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_EXCL_OR_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_BITWISE_EXCL_OR ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_OR_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_BITWISE_OR ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_SHIFT_LEFT_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_SHIFT_LEFT ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_SHIFT_RIGHT_EQUALS expr { $$ = node3( sval_assignment, $1, node4( sval_operation, node1b( OP_BIN_SHIFT_RIGHT ), $1, $3, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_INCREMENT { $$ = node3( sval_assignment, $1, node3( sval_func1, node1b( OP_UN_INC ), $1, YYLLOC ), YYLLOC ); } - | nonident_prim_expr TOKEN_DECREMENT { $$ = node3( sval_assignment, $1, node3( sval_func1, node1b( OP_UN_DEC ), $1, YYLLOC ), YYLLOC ); } - | statement TOKEN_SEMICOLON + | selection_statement + | iteration_statement + | TOKEN_TRY compound_statement[C1] TOKEN_CATCH compound_statement[C2] { $$ = node3(ENUM_try, $C1, $C2, TOKPOS(@1)); } + | TOKEN_BREAK { $$ = node1(ENUM_break, TOKPOS(@1)); } + | TOKEN_CONTINUE { $$ = node1(ENUM_continue, TOKPOS(@1)); } + | TOKEN_IDENTIFIER event_parameter_list { $$ = node3(ENUM_cmd_event_statement, $1, $2, TOKPOS(@1)); } + | nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list { $$ = node4(ENUM_method_event_statement, $1, $2, $3, TOKPOS(@2)); } + | nonident_prim_expr TOKEN_ASSIGNMENT expr { $$ = node3(ENUM_assignment_statement, $1, $3, TOKPOS(@2)); } + | nonident_prim_expr TOKEN_PLUS_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_PLUS), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_MINUS_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_MINUS), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_MULTIPLY_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_MULTIPLY), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_DIVIDE_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_DIVIDE), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_MODULUS_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_PERCENTAGE), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_AND_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_AND), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_EXCL_OR_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_EXCL_OR), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_OR_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_OR), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_SHIFT_LEFT_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_SHIFT_LEFT), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_SHIFT_RIGHT_EQUALS expr { $$ = node3(ENUM_assignment_statement, $1, node4(ENUM_func2_expr, node1b(OP_BIN_SHIFT_RIGHT), $1, $3, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_INCREMENT { $$ = node3(ENUM_assignment_statement, $1, node3(ENUM_func1_expr, node1b(OP_UN_INC), $1, TOKPOS(@2)), TOKPOS(@2)); } + | nonident_prim_expr TOKEN_DECREMENT { $$ = node3(ENUM_assignment_statement, $1, node3(ENUM_func1_expr, node1b(OP_UN_DEC), $1, TOKPOS(@2)), TOKPOS(@2)); } + | TOKEN_SEMICOLON { $$ = node0(ENUM_NOP); } + //| TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list { $$ = node3( ENUM_method_event_statement, node_string( parsetree_string( str( $1.stringValue ) + "::" + $3.stringValue ) ), node1( ENUM_NOP, $4 ), TOKPOS(@1) ); } + //| nonident_prim_expr TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list { $$ = node4( ENUM_method_event_statement, $1, node_string( parsetree_string( str( $2.stringValue ) + "::" + $4.stringValue ) ), node1( ENUM_NOP, $5 ), TOKPOS(@2) ); } ; -compound_statement: - TOKEN_LBRACKET newline statement_list newline TOKEN_RBRACKET { $$ = node1( sval_statement_list, $3 ); } +compound_statement + : TOKEN_LEFT_BRACES statement_list TOKEN_RIGHT_BRACES { $$ = node1(ENUM_statement_list, $2); } + | TOKEN_LEFT_BRACES line_opt TOKEN_RIGHT_BRACES { $$ = node0(ENUM_NOP); } + | line_opt compound_statement[comp_stmt] line_opt { $$ = $comp_stmt; } + ; + +selection_statement + : TOKEN_IF prim_expr[exp] statement[stmt] { $$ = node3(ENUM_if_statement, $exp, $stmt, TOKPOS(@1)); } + | TOKEN_IF prim_expr[exp] statement[if_stmt] TOKEN_ELSE statement[else_stmt] { $$ = node4(ENUM_if_else_statement, $exp, $if_stmt, $else_stmt, TOKPOS(@1)); } + | TOKEN_SWITCH prim_expr[exp] compound_statement[comp_stmt] { $$ = node3(ENUM_switch, $exp, $comp_stmt, TOKPOS(@1)); } + ; + +iteration_statement + : TOKEN_WHILE prim_expr[exp] statement[stmt]{ $$ = node4(ENUM_while_statement, $exp, $stmt, node0(ENUM_NOP), TOKPOS(@1)); } + | TOKEN_FOR TOKEN_LEFT_BRACKET statement[init_stmt] TOKEN_SEMICOLON expr[exp] TOKEN_SEMICOLON statement_list[inc_stmt] TOKEN_RIGHT_BRACKET statement[stmt] + { + sval_t while_stmt = node4(ENUM_while_statement, $exp, $stmt, node1(ENUM_statement_list, $inc_stmt), TOKPOS(@1)); + $$ = node1(ENUM_statement_list, append_node(linked_list_end($init_stmt), while_stmt)); + } + | TOKEN_FOR TOKEN_LEFT_BRACKET TOKEN_SEMICOLON expr[exp] TOKEN_SEMICOLON statement_list[inc_stmt] TOKEN_RIGHT_BRACKET statement[stmt] + { + $$ = node4(ENUM_while_statement, $exp, $stmt, node1(ENUM_statement_list, $inc_stmt), TOKPOS(@1)); + } + | TOKEN_DO statement[stmt] TOKEN_WHILE prim_expr[exp]{ $$ = node3(ENUM_do, $stmt, $exp, TOKPOS(@1)); } ; expr: - expr TOKEN_LOGICAL_AND newline expr { $$ = node3( sval_and, $1, $4, YYLLOC ); } - | expr TOKEN_LOGICAL_OR newline expr { $$ = node3( sval_or, $1, $4, YYLLOC ); } - | expr TOKEN_BITWISE_AND newline expr { $$ = node4( sval_operation, node1b( OP_BIN_BITWISE_AND ), $1, $4, YYLLOC ); } - | expr TOKEN_BITWISE_EXCL_OR newline expr { $$ = node4( sval_operation, node1b( OP_BIN_BITWISE_EXCL_OR ), $1, $4, YYLLOC ); } - | expr TOKEN_BITWISE_OR newline expr { $$ = node4( sval_operation, node1b( OP_BIN_BITWISE_OR ), $1, $4, YYLLOC ); } - | expr TOKEN_EQUALITY newline expr { $$ = node4( sval_operation, node1b( OP_BIN_EQUALITY ), $1, $4, YYLLOC ); } - | expr TOKEN_INEQUALITY newline expr { $$ = node4( sval_operation, node1b( OP_BIN_INEQUALITY ), $1, $4, YYLLOC ); } - | expr TOKEN_LESS_THAN newline expr { $$ = node4( sval_operation, node1b( OP_BIN_LESS_THAN ), $1, $4, YYLLOC ); } - | expr TOKEN_GREATER_THAN newline expr { $$ = node4( sval_operation, node1b( OP_BIN_GREATER_THAN ), $1, $4, YYLLOC ); } - | expr TOKEN_LESS_THAN_OR_EQUAL newline expr { $$ = node4( sval_operation, node1b( OP_BIN_LESS_THAN_OR_EQUAL ), $1, $4, YYLLOC ); } - | expr TOKEN_GREATER_THAN_OR_EQUAL newline expr { $$ = node4( sval_operation, node1b( OP_BIN_GREATER_THAN_OR_EQUAL ), $1, $4, YYLLOC ); } - | expr TOKEN_PLUS newline expr { $$ = node4( sval_operation, node1b( OP_BIN_PLUS ), $1, $4, YYLLOC ); } - | expr TOKEN_MINUS newline expr { $$ = node4( sval_operation, node1b( OP_BIN_MINUS ), $1, $4, YYLLOC ); } - | expr TOKEN_MULTIPLY newline expr { $$ = node4( sval_operation, node1b( OP_BIN_MULTIPLY ), $1, $4, YYLLOC ); } - | expr TOKEN_DIVIDE newline expr { $$ = node4( sval_operation, node1b( OP_BIN_DIVIDE ), $1, $4, YYLLOC ); } - | expr TOKEN_MODULUS newline expr { $$ = node4( sval_operation, node1b( OP_BIN_PERCENTAGE ), $1, $4, YYLLOC ); } - | expr TOKEN_SHIFT_LEFT newline expr { $$ = node4( sval_operation, node1b( OP_BIN_SHIFT_LEFT ), $1, $4, YYLLOC ); } - | expr TOKEN_SHIFT_RIGHT newline expr { $$ = node4( sval_operation, node1b( OP_BIN_SHIFT_RIGHT ), $1, $4, YYLLOC ); } - | expr TOKEN_TERNARY expr TOKEN_COLON expr { $$ = node4( sval_ifelse, $1, $3, $5, YYLLOC ); } + expr TOKEN_LOGICAL_AND expr { $$ = node3( ENUM_logical_and, $1, $3, TOKPOS(@2) ); } + | expr TOKEN_LOGICAL_OR expr { $$ = node3( ENUM_logical_or, $1, $3, TOKPOS(@2) ); } + | expr TOKEN_BITWISE_AND expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_AND ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_BITWISE_OR expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_OR ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_BITWISE_EXCL_OR expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_EXCL_OR ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_EQUALITY expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_EQUALITY ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_INEQUALITY expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_INEQUALITY ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_LESS_THAN expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_LESS_THAN ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_GREATER_THAN expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_GREATER_THAN ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_LESS_THAN_OR_EQUAL expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_LESS_THAN_OR_EQUAL ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_GREATER_THAN_OR_EQUAL expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_GREATER_THAN_OR_EQUAL ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_PLUS expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_PLUS ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_MINUS expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_MINUS ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_MULTIPLY expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_MULTIPLY ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_DIVIDE expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_DIVIDE ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_MODULUS expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_PERCENTAGE ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_SHIFT_LEFT expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_SHIFT_LEFT ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_SHIFT_RIGHT expr { $$ = node4( ENUM_func2_expr, node1b( OP_BIN_SHIFT_RIGHT ), $1, $3, TOKPOS(@2) ); } + | expr TOKEN_TERNARY expr TOKEN_COLON expr { $$ = node4( ENUM_if_else_statement, $1, $3, $5, TOKPOS(@2) ); } + | TOKEN_EOL expr[exp] { $$ = $exp; } | nonident_prim_expr | func_prim_expr - | identifier_prim { $$ = node1( sval_store_string, $1.val ); } + | TOKEN_IDENTIFIER { $$ = node2(ENUM_string, $1, TOKPOS(@1)); } ; func_prim_expr: - TOKEN_IDENTIFIER event_parameter_list_need { $$ = node3( sval_cmd_default_ret, $1.val, node1( sval_none, $2 ), node_pos( $1.sourcePos ) ); } - //| TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list_need { $$ = node3( sval_cmd_default_ret, node_string( parsetree_string( str( $1.val.stringValue ) + "::" + $3.val.stringValue ) ), node1( sval_none, $4 ), $1.sourcePos ); } - | nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list { $$ = node4( sval_cmd_method_ret, $1, $2.val, node1( sval_none, $3 ), node_pos( $2.sourcePos ) ); } - //| nonident_prim_expr TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON TOKEN_IDENTIFIER event_parameter_list { $$ = node4( sval_cmd_method_ret, $1, node_string( parsetree_string( str( $2.val.stringValue ) + "::" + $4.val.stringValue ) ), node1( sval_none, $5 ), $2.sourcePos ); } - | TOKEN_NEG func_prim_expr { $$ = node3( sval_func1, node1b( OP_UN_MINUS ), $2, YYLLOC ); } - | TOKEN_COMPLEMENT func_prim_expr { $$ = node3( sval_func1, node1b( OP_UN_COMPLEMENT ), $2, YYLLOC ); } - | TOKEN_NOT func_prim_expr { $$ = node2( sval_not, $2, YYLLOC ); } - | TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON prim_expr { $$ = node3( sval_constarray, node2( sval_store_string, $1.val, node_pos( $1.sourcePos ) ), $3, YYLLOC ); } - | nonident_prim_expr TOKEN_DOUBLE_COLON prim_expr { $$ = node3( sval_constarray, $1, $3, YYLLOC ); } - | TOKEN_MAKEARRAY newline makearray_statement_list newline TOKEN_ENDARRAY { $$ = node1( sval_makearray, $3 ); } + TOKEN_IDENTIFIER event_parameter_list_need { $$ = node3(ENUM_cmd_event_expr, $1, $2, TOKPOS(@1)); } + | nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list { $$ = node4(ENUM_method_event_expr, $1, $2, $3, TOKPOS(@2)); } + | TOKEN_NEG func_prim_expr { $$ = node3(ENUM_func1_expr, node1b(OP_UN_MINUS), $2, TOKPOS(@1)); } + | TOKEN_COMPLEMENT func_prim_expr { $$ = node3(ENUM_func1_expr, node1b(OP_UN_COMPLEMENT), $2, TOKPOS(@1)); } + | TOKEN_NOT func_prim_expr { $$ = node2(ENUM_bool_not, $2, TOKPOS(@1)); } + | TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON const_array_list + { + $$ = node3(ENUM_const_array_expr, node2(ENUM_string, $1, TOKPOS(@1)), $3, TOKPOS(@2)); + } + | nonident_prim_expr TOKEN_DOUBLE_COLON const_array_list + { + $$ = node3(ENUM_const_array_expr, $1, $3, TOKPOS(@2)); + } + | TOKEN_MAKEARRAY makearray_statement_list[stmt] TOKEN_ENDARRAY + { + $$ = node2(ENUM_makearray, $stmt, TOKPOS(@1)); + } ; -event_parameter_list: - { $$ = node0( sval_none ); } - | event_parameter_list prim_expr { $$ = append_node( $1, $2 ); } - | prim_expr { $$ = linked_list_end( $1 ); } +event_parameter_list + : { $$ = sval_u{}; } + | event_parameter { $$ = $1; } ; -event_parameter_list_need: - event_parameter_list_need prim_expr { $$ = append_node( $1, $2 ); } - | prim_expr { $$ = linked_list_end( $1 ); } +event_parameter_list_need + : event_parameter { $$ = $1; } ; -prim_expr: - nonident_prim_expr - | identifier_prim { $$ = node1( sval_store_string, $1.val ); } - | prim_expr TOKEN_DOUBLE_COLON prim_expr { $$ = node3( sval_constarray, $1, $3, YYLLOC ); } +event_parameter + : prim_expr { $$ = linked_list_end($1); } + | event_parameter prim_expr { $$ = append_node($1, $2); } ; -nonident_prim_expr: - TOKEN_DOLLAR TOKEN_LPAREN expr TOKEN_RPAREN { $$ = node3( sval_func1, node1b( OP_UN_TARGETNAME ), $3, YYLLOC ); } - | TOKEN_DOLLAR TOKEN_IDENTIFIER { $$ = node3( sval_func1, node1b( OP_UN_TARGETNAME ), node1( sval_store_string, $2.val ), YYLLOC ); } - | TOKEN_DOLLAR TOKEN_STRING { $$ = node3( sval_func1, node1b( OP_UN_TARGETNAME ), node1( sval_store_string, $2.val ), YYLLOC ); } - | nonident_prim_expr TOKEN_PERIOD TOKEN_IDENTIFIER { $$ = node3( sval_field, $1, $3.val, node_pos( $3.sourcePos ) ); } - | nonident_prim_expr TOKEN_PERIOD TOKEN_STRING { $$ = node3( sval_field, $1, $3.val, node_pos( $3.sourcePos ) ); } - | nonident_prim_expr TOKEN_PERIOD TOKEN_SIZE { $$ = node3( sval_func1, node1b( OP_UN_SIZE ), $1, YYLLOC ); } - | nonident_prim_expr TOKEN_LSQUARE expr TOKEN_RSQUARE { $$ = node3( sval_array, $1, $3, $1 ); } - | TOKEN_STRING { $$ = node1( sval_store_string, $1.val ); } - | number - | TOKEN_LPAREN expr expr expr TOKEN_RPAREN { $$ = node4( sval_calc_vector, $2, $3, $4, YYLLOC ); } - | TOKEN_LISTENER { $$ = node2( sval_store_method, $1.val, YYLLOC ); } - | TOKEN_LPAREN expr TOKEN_RPAREN { $$ = $2; } - | TOKEN_LPAREN TOKEN_RPAREN { $$ = node0( sval_none ); } - | TOKEN_NEG nonident_prim_expr { $$ = node3( sval_func1, node1b( OP_UN_MINUS ), $2, YYLLOC ); } - | TOKEN_COMPLEMENT nonident_prim_expr { $$ = node3( sval_func1, node1b( OP_UN_COMPLEMENT ), $2, YYLLOC ); } - | TOKEN_NOT nonident_prim_expr { $$ = node2( sval_not, $2, YYLLOC ); } - | TOKEN_NULL { $$ = node1( sval_store_null, YYLLOC ); } - | TOKEN_NIL { $$ = node1( sval_store_nil, YYLLOC ); } +const_array_list + : const_array { $$ = linked_list_end($1); } + | const_array_list TOKEN_DOUBLE_COLON const_array { $$ = append_node($1, $3); } ; -number: - TOKEN_FLOAT { $$ = node1( sval_store_float, $1.val ); } - | TOKEN_INTEGER { $$ = node1( sval_store_integer, $1.val ); } +const_array + : nonident_prim_expr + | identifier_prim { $$ = node2(ENUM_string, $1, TOKPOS(@1)); } + ; + +prim_expr + : nonident_prim_expr + | identifier_prim { $$ = node2(ENUM_string, $1, TOKPOS(@1)); } + | prim_expr TOKEN_DOUBLE_COLON const_array_list { $$ = node3(ENUM_const_array_expr, $1, $3, TOKPOS(@2)); } + ; + +nonident_prim_expr + : TOKEN_DOLLAR prim_expr { $$ = node3(ENUM_func1_expr, node1b(OP_UN_TARGETNAME), $2, TOKPOS(@1)); } + | nonident_prim_expr TOKEN_PERIOD TOKEN_IDENTIFIER { $$ = node3(ENUM_field, $1, $3, TOKPOS(@3)); } + | nonident_prim_expr TOKEN_PERIOD TOKEN_SIZE { $$ = node3(ENUM_func1_expr, node1b(OP_UN_SIZE), $1, TOKPOS(@3)); } + | nonident_prim_expr TOKEN_LEFT_SQUARE_BRACKET expr TOKEN_RIGHT_SQUARE_BRACKET { $$ = node3(ENUM_array_expr, $1, $3, TOKPOS(@2)); } + | TOKEN_STRING { $$ = node2(ENUM_string, $1, TOKPOS(@1)); } + | TOKEN_INTEGER { $$ = node2(ENUM_integer, $1, TOKPOS(@1)); } + | TOKEN_FLOAT { $$ = node2(ENUM_float, $1, TOKPOS(@1)); } + | TOKEN_LEFT_BRACKET expr[exp1] expr[exp2] expr[exp3] TOKEN_RIGHT_BRACKET { $$ = node4(ENUM_vector, $exp1, $exp2, $exp3, TOKPOS(@1)); } + | TOKEN_LISTENER { $$ = node2(ENUM_listener, $1, TOKPOS(@1)); } + | TOKEN_LEFT_BRACKET expr TOKEN_RIGHT_BRACKET { $$ = $2; } + | TOKEN_NEG nonident_prim_expr { $$ = node3(ENUM_func1_expr, node1b(OP_UN_MINUS), $2, TOKPOS(@1)); } + | TOKEN_COMPLEMENT nonident_prim_expr { $$ = node3(ENUM_func1_expr, node1b(OP_UN_COMPLEMENT), $2, TOKPOS(@1)); } + | TOKEN_NOT nonident_prim_expr { $$ = node2(ENUM_bool_not, $2, TOKPOS(@1)); } + | TOKEN_NULL { $$ = node1(ENUM_NULL, TOKPOS(@1)); } + | TOKEN_NIL { $$ = node1(ENUM_NIL, TOKPOS(@1)); } ; identifier_prim: - TOKEN_IDENTIFIER + TOKEN_IDENTIFIER { $$ = $1; @$ = @1; } ; makearray_statement_list: - { $$ = node0( sval_none ); } - | makearray_statement_list makearray_statement newline { $$ = append_node( $1, node1( sval_makearray, $2 ) ); } - | makearray_statement newline { $$ = linked_list_end( node1( sval_makearray, $1 ) ); } + { $$ = node0(ENUM_NOP); } + | makearray_statement_list[list] makearray_statement[ma_stmt] TOKEN_EOL { $$ = append_node($list, node2(ENUM_makearray, $ma_stmt, TOKPOS(@ma_stmt))); } + | makearray_statement[ma_stmt] TOKEN_EOL { $$ = linked_list_end(node2(ENUM_makearray, $ma_stmt, TOKPOS(@ma_stmt))); } + | TOKEN_EOL makearray_statement_list { $$ = $2; @$ = @2; } ; makearray_statement: @@ -258,8 +303,8 @@ makearray_statement: | makearray_statement prim_expr { $$ = append_node( $1, $2 ); } ; -newline: - {} +line_opt + : {} | TOKEN_EOL ; diff --git a/code/parser/generated/yyLexer.cpp b/code/parser/generated/yyLexer.cpp index fd42d18a..110c20ad 100644 --- a/code/parser/generated/yyLexer.cpp +++ b/code/parser/generated/yyLexer.cpp @@ -370,12 +370,13 @@ static void yynoreturn yy_fatal_error ( const char* msg ); */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ + (yytext_ptr) -= (yy_more_len); \ + yyleng = (int) (yy_cp - (yytext_ptr)); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 92 -#define YY_END_OF_BUFFER 93 +#define YY_NUM_RULES 96 +#define YY_END_OF_BUFFER 97 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -383,75 +384,32 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_acclist[358] = +static const flex_int16_t yy_accept[218] = { 0, - 14, 15, 23, 14, 15, 23, 8, 8, 93, 91, - 92, 15, 91, 92, 14, 92, 14, 91, 92, 15, - 91, 92, 73, 91, 92, 91, 92, 77, 91, 92, - 72, 91, 92, 63, 91, 92, 45, 91, 92, 32, - 91, 92, 33, 91, 92, 59, 91, 92, 52, 91, - 92, 76, 91, 92, 55, 90, 91, 92, 75, 81, - 90, 91, 92, 61, 90, 91, 92, 80, 81, 90, - 91, 92, 37, 91, 92, 39, 91, 92, 47, 91, - 92, 36, 91, 92, 48, 91, 92, 17, 91, 92, - 90, 91, 92, 90, 91, 92, 34, 91, 92, 90, + 21, 21, 0, 0, 0, 0, 0, 0, 90, 90, + 97, 93, 87, 86, 86, 87, 71, 93, 75, 70, + 61, 43, 30, 31, 57, 50, 74, 53, 73, 59, + 88, 35, 37, 45, 34, 46, 15, 93, 93, 32, + 93, 33, 42, 93, 93, 93, 93, 93, 93, 93, + 93, 93, 93, 93, 93, 93, 93, 28, 41, 29, + 72, 4, 3, 4, 96, 13, 12, 12, 11, 9, + 11, 11, 90, 91, 91, 92, 86, 0, 49, 44, + 0, 14, 0, 62, 40, 67, 5, 58, 52, 51, + 53, 56, 54, 89, 0, 1, 7, 60, 88, 94, - 91, 92, 35, 91, 92, 44, 91, 92, 90, 91, - 92, 90, 91, 92, 90, 91, 92, 90, 91, 92, - 90, 91, 92, 90, 91, 92, 90, 91, 92, 90, - 91, 92, 90, 91, 92, 90, 91, 92, 90, 91, - 92, 90, 91, 92, 90, 91, 92, 90, 91, 92, - 30, 91, 92, 43, 91, 92, 31, 91, 92, 74, - 91, 92, 4, 92, 3, 92, 4, 92, 92, 13, - 92, 8, 92, 8, 13, 92, 12, 13, 92, 10, - 13, 92, 12, 13, 92, 12, 13, 92, 15, 14, - 51, 46, 16, 64, 42, 69, 5, 60, 54, 53, + 94, 36, 63, 47, 38, 48, 65, 94, 94, 6, + 68, 94, 94, 94, 20, 94, 94, 94, 94, 94, + 16, 94, 94, 94, 94, 94, 94, 94, 94, 94, + 69, 39, 2, 0, 10, 11, 0, 11, 11, 90, + 55, 0, 7, 64, 66, 77, 94, 94, 94, 94, + 94, 94, 94, 19, 94, 94, 94, 94, 94, 94, + 94, 94, 94, 78, 94, 10, 11, 89, 76, 94, + 81, 94, 94, 17, 94, 94, 21, 94, 94, 94, + 94, 94, 25, 27, 94, 94, 8, 82, 79, 94, + 94, 94, 22, 23, 24, 94, 94, 26, 94, 18, - 55, 58, 90, 90, 56, 81, 90, 90, 1, 7, - 90, 62, 80, 81, 90, 38, 65, 49, 40, 50, - 67, 90, 90, 6, 70, 90, 90, 90, 22, 90, - 90, 90, 90, 90, 90, 18, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 71, 41, 2, 8, - 11, 12, 12, 12, 12, 58, 57, 90, 7, 7, - 90, 66, 68, 79, 90, 90, 90, 90, 90, 90, - 90, 90, 21, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 82, 90, 90, 11, 12, 81, 81, - 90, 78, 90, 90, 85, 90, 90, 90, 19, 90, - - 90, 90, 23, 90, 90, 90, 90, 90, 90, 27, - 90, 29, 90, 90, 90, 9, 12, 86, 90, 83, - 90, 90, 90, 90, 24, 90, 25, 90, 26, 90, - 90, 90, 28, 90, 90, 20, 90, 90, 90, 90, - 90, 90, 84, 90, 90, 90, 90, 90, 90, 87, - 90, 89, 90, 90, 90, 88, 90 - } ; - -static const flex_int16_t yy_accept[220] = - { 0, - 1, 4, 7, 7, 7, 7, 7, 8, 9, 9, - 9, 10, 12, 15, 17, 20, 23, 26, 28, 31, - 34, 37, 40, 43, 46, 49, 52, 55, 59, 64, - 68, 73, 76, 79, 82, 85, 88, 91, 94, 97, - 100, 103, 106, 109, 112, 115, 118, 121, 124, 127, - 130, 133, 136, 139, 142, 145, 148, 151, 154, 157, - 160, 163, 165, 167, 169, 170, 172, 174, 177, 180, - 183, 186, 189, 190, 191, 191, 192, 193, 193, 194, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 204, - 205, 206, 208, 209, 210, 212, 213, 216, 217, 218, - - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 231, 232, 233, 234, 235, 236, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 251, 253, 254, 254, 255, 256, 257, 258, 258, - 259, 260, 262, 263, 264, 266, 267, 268, 269, 270, - 271, 272, 273, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 286, 287, 288, 289, 290, 290, 292, - 294, 295, 297, 298, 299, 301, 302, 303, 305, 306, - 307, 308, 309, 310, 312, 314, 315, 316, 318, 320, - 322, 323, 324, 325, 327, 329, 331, 332, 333, 335, - - 336, 338, 339, 340, 341, 342, 343, 345, 346, 347, - 348, 349, 350, 352, 354, 355, 356, 358, 358 + 94, 94, 94, 94, 94, 80, 94, 94, 94, 94, + 94, 83, 85, 94, 94, 84, 0 } ; static const YY_CHAR yy_ec[256] = @@ -465,11 +423,11 @@ static const YY_CHAR yy_ec[256] = 24, 25, 26, 1, 27, 28, 28, 28, 28, 28, 28, 28, 29, 28, 28, 30, 28, 31, 28, 28, 28, 28, 28, 28, 32, 28, 28, 28, 28, 28, - 33, 34, 35, 36, 28, 1, 37, 38, 39, 40, + 33, 34, 35, 36, 37, 1, 38, 39, 40, 41, - 41, 42, 43, 44, 45, 28, 46, 47, 48, 49, - 50, 51, 28, 52, 53, 54, 55, 56, 57, 28, - 58, 59, 60, 61, 62, 63, 1, 1, 1, 1, + 42, 43, 44, 45, 46, 28, 47, 48, 49, 50, + 51, 52, 28, 53, 54, 55, 56, 57, 58, 28, + 59, 60, 61, 62, 63, 64, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -486,173 +444,151 @@ static const YY_CHAR yy_ec[256] = 1, 1, 1, 1, 1 } ; -static const YY_CHAR yy_meta[64] = +static const YY_CHAR yy_meta[65] = { 0, - 1, 1, 2, 2, 3, 1, 4, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 3, 3, 3, 5, - 1, 1, 1, 3, 1, 1, 5, 5, 5, 5, - 5, 5, 1, 3, 1, 1, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, - 1, 1, 1 + 1, 2, 3, 3, 2, 1, 4, 1, 1, 1, + 1, 2, 2, 1, 1, 2, 1, 5, 1, 6, + 2, 2, 1, 1, 1, 1, 6, 6, 6, 6, + 6, 6, 2, 1, 2, 1, 4, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 2, 1, 2, 1 } ; -static const flex_int16_t yy_base[225] = +static const flex_int16_t yy_base[226] = { 0, - 0, 0, 61, 62, 0, 0, 76, 0, 0, 0, - 331, 784, 64, 64, 67, 138, 232, 134, 784, 784, - 231, 133, 784, 784, 123, 130, 784, 141, 143, 145, - 155, 233, 784, 49, 228, 127, 784, 157, 161, 784, - 167, 784, 227, 171, 175, 177, 173, 178, 181, 182, - 189, 184, 183, 195, 193, 205, 187, 784, 153, 784, - 784, 784, 784, 230, 784, 784, 200, 212, 257, 784, - 0, 203, 233, 233, 231, 316, 784, 219, 784, 206, - 784, 784, 784, 784, 784, 784, 784, 784, 317, 318, - 784, 319, 321, 784, 360, 784, 419, 784, 150, 784, + 0, 0, 62, 63, 0, 0, 77, 0, 140, 202, + 520, 582, 582, 64, 66, 56, 495, 140, 582, 582, + 493, 135, 582, 582, 130, 133, 582, 146, 140, 152, + 147, 495, 582, 51, 491, 144, 582, 494, 154, 582, + 174, 582, 487, 132, 146, 137, 161, 162, 172, 169, + 175, 178, 163, 181, 180, 174, 184, 582, 170, 582, + 582, 582, 582, 491, 582, 582, 582, 582, 265, 582, + 0, 463, 0, 582, 582, 582, 227, 493, 223, 582, + 226, 582, 503, 582, 582, 582, 582, 582, 582, 582, + 582, 582, 582, 216, 224, 582, 0, 582, 312, 485, - 784, 784, 132, 320, 322, 238, 784, 323, 420, 421, - 324, 422, 423, 424, 429, 428, 325, 425, 426, 433, - 431, 430, 437, 427, 435, 459, 784, 784, 784, 240, - 498, 0, 0, 455, 0, 90, 784, 784, 314, 482, - 0, 0, 784, 784, 330, 461, 462, 466, 464, 507, - 491, 487, 489, 492, 553, 493, 554, 555, 557, 558, - 559, 560, 496, 562, 784, 33, 784, 230, 561, 563, - 564, 565, 568, 566, 569, 570, 571, 575, 592, 595, - 597, 600, 602, 608, 610, 612, 615, 0, 623, 624, - 625, 626, 628, 633, 635, 636, 640, 641, 648, 653, + 227, 582, 478, 582, 582, 582, 476, 190, 225, 245, + 582, 313, 315, 316, 388, 317, 318, 319, 324, 323, + 387, 320, 321, 328, 326, 325, 331, 322, 327, 334, + 582, 582, 582, 380, 0, 0, 350, 0, 344, 0, + 582, 340, 0, 582, 582, 384, 232, 329, 346, 345, + 338, 347, 363, 380, 373, 385, 374, 376, 424, 425, + 395, 427, 344, 379, 428, 582, 354, 582, 377, 430, + 333, 429, 432, 332, 330, 431, 246, 433, 434, 435, + 437, 436, 243, 241, 439, 438, 0, 239, 238, 440, + 441, 442, 236, 235, 234, 443, 444, 233, 447, 228, - 657, 658, 661, 662, 663, 664, 665, 666, 670, 671, - 686, 695, 678, 679, 696, 700, 701, 784, 758, 763, - 768, 771, 773, 778 + 445, 450, 453, 451, 454, 182, 463, 455, 468, 475, + 480, 177, 173, 469, 481, 54, 582, 540, 546, 552, + 558, 560, 563, 569, 575 } ; -static const flex_int16_t yy_def[225] = +static const flex_int16_t yy_def[226] = { 0, - 218, 1, 219, 219, 220, 220, 218, 7, 220, 220, - 218, 218, 218, 218, 218, 218, 218, 221, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 222, 222, 222, - 222, 218, 218, 218, 218, 218, 218, 222, 222, 218, - 222, 218, 218, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 223, 223, 218, 218, 218, 218, 218, 221, 218, 221, - 218, 218, 218, 218, 218, 218, 218, 218, 222, 222, - 218, 222, 222, 218, 218, 218, 222, 218, 218, 218, + 217, 1, 218, 218, 219, 219, 217, 7, 220, 220, + 217, 217, 217, 217, 217, 217, 217, 221, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 222, 217, 217, 217, 217, 217, 217, 222, 222, 217, + 217, 217, 217, 222, 222, 222, 222, 222, 222, 222, + 222, 222, 222, 222, 222, 222, 222, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 223, 223, 224, 217, 217, 217, 217, 217, 217, 217, + 221, 217, 221, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 225, 217, 222, 222, - 218, 218, 218, 222, 222, 218, 218, 222, 222, 222, + 222, 217, 217, 217, 217, 217, 217, 222, 222, 217, + 217, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 218, 218, 218, 218, - 69, 223, 69, 131, 223, 223, 218, 218, 218, 222, - 224, 95, 218, 218, 222, 222, 222, 222, 222, 222, + 217, 217, 217, 69, 223, 69, 134, 223, 223, 224, + 217, 217, 225, 217, 217, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 218, 223, 218, 218, 222, 222, + 222, 222, 222, 222, 222, 217, 223, 217, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 223, 222, 222, + 222, 222, 222, 222, 222, 222, 223, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, 222, - 222, 222, 222, 222, 222, 222, 222, 0, 218, 218, - 218, 218, 218, 218 + 222, 222, 222, 222, 222, 222, 0, 217, 217, 217, + 217, 217, 217, 217, 217 } ; -static const flex_int16_t yy_nxt[848] = +static const flex_int16_t yy_nxt[647] = { 0, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 38, 38, 38, - 39, 38, 40, 41, 42, 43, 38, 44, 45, 46, - 47, 48, 49, 38, 50, 38, 51, 52, 38, 53, - 54, 38, 55, 56, 38, 38, 57, 38, 38, 58, - 59, 60, 61, 63, 63, 73, 74, 74, 73, 74, - 74, 99, 100, 188, 64, 64, 66, 66, 67, 68, - 66, 66, 69, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 70, 66, 71, 66, 66, 66, 66, + 39, 38, 40, 41, 42, 43, 12, 38, 44, 45, + 46, 47, 48, 49, 38, 50, 38, 51, 52, 38, + 53, 54, 38, 55, 56, 38, 38, 57, 38, 38, + 58, 59, 60, 61, 63, 63, 77, 77, 77, 77, + 78, 217, 79, 103, 104, 64, 64, 66, 67, 68, + 67, 67, 66, 69, 66, 66, 66, 66, 66, 66, + 66, 66, 66, 66, 70, 66, 71, 66, 66, 66, - 66, 66, 71, 71, 71, 71, 71, 71, 66, 66, - 66, 66, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 72, 71, - 71, 71, 71, 71, 71, 66, 66, 66, 66, 73, - 79, 84, 73, 82, 86, 88, 85, 218, 166, 218, - 102, 103, 75, 87, 76, 144, 83, 89, 94, 218, - 92, 218, 92, 95, 91, 218, 218, 80, 96, 106, - 106, 218, 92, 143, 97, 218, 127, 218, 218, 218, - 218, 218, 218, 93, 218, 218, 218, 218, 218, 104, - 218, 218, 105, 218, 218, 93, 218, 218, 218, 218, + 66, 66, 66, 71, 71, 71, 71, 71, 71, 66, + 66, 66, 66, 71, 71, 71, 71, 71, 71, 71, + 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, + 72, 71, 71, 71, 71, 71, 71, 66, 66, 66, + 66, 74, 75, 74, 74, 85, 82, 89, 87, 217, + 91, 76, 76, 88, 217, 76, 90, 94, 86, 94, + 76, 76, 92, 217, 94, 96, 99, 106, 107, 93, + 97, 217, 76, 83, 76, 98, 110, 110, 217, 217, + 217, 95, 108, 113, 112, 109, 217, 115, 101, 217, + 217, 217, 217, 131, 217, 217, 114, 217, 217, 217, - 218, 218, 130, 130, 218, 218, 218, 218, 218, 218, - 218, 109, 218, 128, 130, 130, 218, 115, 218, 112, - 120, 113, 108, 117, 110, 79, 111, 114, 218, 118, - 126, 122, 116, 123, 73, 74, 74, 73, 119, 121, - 106, 106, 130, 130, 139, 86, 139, 136, 129, 124, - 107, 101, 80, 98, 81, 77, 125, 131, 131, 131, - 131, 131, 131, 132, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 133, 131, 131, 131, - 131, 131, 131, 133, 133, 133, 133, 133, 133, 131, - 134, 131, 131, 133, 133, 133, 133, 133, 133, 133, + 76, 217, 76, 74, 75, 74, 74, 217, 116, 119, + 117, 121, 118, 76, 76, 124, 122, 76, 126, 146, + 125, 127, 76, 76, 120, 123, 129, 91, 130, 77, + 77, 132, 82, 94, 76, 94, 76, 128, 142, 92, + 142, 142, 217, 142, 217, 217, 141, 110, 110, 217, + 217, 217, 217, 217, 147, 217, 217, 95, 217, 83, + 217, 169, 76, 217, 76, 134, 134, 134, 134, 134, + 134, 135, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 136, 134, 134, 134, 134, 134, + 134, 136, 136, 136, 136, 136, 136, 134, 137, 134, - 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, - 133, 133, 133, 133, 133, 133, 131, 131, 131, 131, - 88, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 167, 137, 167, 218, 139, 92, 140, 92, 138, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 145, - 218, 146, 218, 218, 168, 218, 218, 218, 218, 93, - 141, 141, 218, 147, 141, 141, 141, 141, 141, 141, - 141, 141, 141, 141, 141, 141, 142, 142, 142, 142, - 141, 141, 141, 141, 141, 141, 142, 142, 142, 142, - 142, 142, 141, 142, 141, 141, 142, 142, 142, 142, + 134, 136, 136, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 134, 134, 134, 134, 94, + 217, 99, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 101, 148, 217, 134, 168, 153, 168, + 158, 217, 217, 217, 217, 151, 170, 163, 149, 150, + 152, 154, 155, 156, 159, 160, 157, 161, 162, 165, + 217, 95, 191, 134, 172, 164, 166, 171, 174, 175, + 217, 217, 173, 217, 217, 187, 217, 217, 185, 134, - 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, - 142, 142, 142, 142, 142, 142, 142, 142, 142, 141, - 141, 141, 141, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 92, 218, 97, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 93, - 218, 131, 152, 218, 157, 218, 218, 218, 218, 150, - 218, 162, 148, 149, 151, 153, 154, 155, 158, 159, - 156, 160, 218, 161, 218, 218, 218, 218, 131, 218, - 170, 218, 163, 218, 218, 218, 218, 218, 171, 169, + 176, 217, 217, 167, 217, 217, 134, 134, 134, 134, + 134, 134, 217, 180, 177, 179, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 178, 217, 217, 183, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 196, 217, 181, 182, 217, 217, 184, + 217, 217, 217, 189, 197, 186, 188, 190, 199, 200, + 217, 194, 195, 192, 193, 217, 217, 208, 198, 201, + 209, 206, 217, 202, 203, 204, 205, 217, 217, 145, - 218, 169, 173, 164, 165, 218, 172, 218, 218, 218, - 218, 218, 218, 176, 218, 218, 218, 131, 218, 218, - 218, 218, 93, 177, 131, 131, 131, 131, 131, 131, - 218, 175, 178, 180, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 218, 218, 218, - 174, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 181, 218, 218, 218, 218, 182, 218, 183, 218, 218, + 207, 144, 217, 210, 212, 217, 211, 89, 139, 133, + 111, 217, 214, 213, 105, 102, 84, 215, 80, 217, + 217, 217, 217, 217, 217, 217, 213, 216, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 216, + 62, 62, 62, 62, 62, 62, 65, 65, 65, 65, + 65, 65, 73, 73, 73, 73, 73, 73, 81, 81, + 81, 81, 81, 81, 100, 100, 138, 217, 138, 140, + 217, 217, 140, 140, 140, 143, 143, 217, 143, 143, + 143, 11, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, - 185, 218, 218, 218, 218, 184, 218, 179, 187, 189, - 191, 190, 218, 186, 218, 218, 218, 218, 218, 218, - 218, 192, 193, 218, 218, 218, 197, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 198, 218, 218, 218, - 218, 195, 194, 196, 218, 218, 218, 218, 218, 218, - 200, 218, 218, 199, 218, 201, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 202, 218, 218, 218, 203, 218, 204, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 205, 206, 218, 218, 218, 207, 209, 210, 218, - - 218, 218, 218, 218, 218, 218, 213, 218, 218, 218, - 218, 218, 208, 218, 211, 212, 218, 218, 218, 218, - 218, 218, 215, 218, 218, 218, 218, 214, 214, 218, - 218, 216, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 217, 218, 218, 218, 217, 62, 62, - 62, 62, 62, 65, 65, 65, 65, 65, 78, 78, - 78, 78, 78, 90, 218, 90, 135, 135, 141, 218, - 141, 141, 141, 11, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218 + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217 } ; -static const flex_int16_t yy_chk[848] = +static const flex_int16_t yy_chk[647] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -660,120 +596,96 @@ static const flex_int16_t yy_chk[848] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 4, 13, 14, 14, 13, 15, - 15, 34, 34, 166, 3, 4, 7, 7, 7, 7, + 1, 1, 1, 1, 3, 4, 14, 14, 15, 15, + 16, 216, 16, 34, 34, 3, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 16, - 18, 25, 16, 22, 26, 28, 25, 29, 136, 30, - 36, 36, 16, 26, 16, 103, 22, 28, 30, 31, - 29, 38, 29, 30, 28, 39, 29, 18, 30, 41, - 41, 41, 31, 99, 31, 44, 59, 47, 31, 45, - 38, 46, 48, 29, 39, 49, 50, 53, 52, 39, - 41, 57, 39, 51, 44, 31, 47, 55, 45, 54, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 9, 9, 9, 9, 22, 18, 26, 25, 44, + 28, 9, 9, 25, 46, 9, 26, 29, 22, 29, + 9, 9, 28, 45, 31, 30, 31, 36, 36, 28, + 30, 39, 9, 18, 9, 30, 41, 41, 47, 48, + 53, 29, 39, 45, 44, 39, 50, 46, 31, 49, + 213, 56, 51, 59, 212, 52, 45, 55, 54, 206, - 46, 48, 67, 67, 49, 50, 53, 52, 80, 56, - 57, 45, 51, 59, 68, 68, 55, 49, 54, 47, - 52, 47, 44, 50, 45, 78, 46, 48, 56, 51, - 57, 54, 49, 55, 73, 74, 74, 73, 51, 53, - 106, 106, 130, 130, 168, 75, 168, 72, 64, 55, - 43, 35, 78, 32, 21, 17, 56, 69, 69, 69, - 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 9, 57, 9, 10, 10, 10, 10, 108, 47, 49, + 47, 50, 48, 10, 10, 52, 51, 10, 54, 108, + 53, 55, 10, 10, 49, 51, 56, 79, 57, 77, + 77, 59, 81, 94, 10, 94, 10, 55, 95, 79, + 95, 101, 109, 101, 101, 200, 79, 110, 110, 147, + 198, 195, 194, 193, 109, 189, 188, 94, 184, 81, + 183, 147, 10, 177, 10, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, - 76, 89, 90, 92, 104, 93, 105, 108, 111, 117, - 11, 139, 76, 139, 145, 93, 92, 93, 92, 76, - 89, 90, 92, 104, 93, 105, 108, 111, 117, 104, - 0, 105, 0, 145, 139, 0, 0, 0, 0, 92, - 95, 95, 0, 108, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 99, + 112, 99, 113, 114, 116, 117, 118, 122, 123, 128, + 120, 119, 126, 125, 129, 124, 148, 175, 127, 174, + 171, 130, 137, 99, 112, 151, 137, 142, 117, 142, + 123, 163, 150, 149, 152, 114, 148, 128, 113, 113, + 116, 118, 119, 120, 124, 125, 122, 126, 127, 130, + 153, 142, 175, 137, 150, 129, 134, 149, 152, 153, + 155, 157, 151, 158, 169, 167, 164, 154, 163, 134, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, - 95, 95, 95, 97, 109, 110, 112, 113, 114, 118, - 119, 124, 116, 115, 122, 121, 97, 120, 97, 125, - 0, 123, 97, 109, 110, 112, 113, 114, 118, 119, - 124, 116, 115, 122, 121, 0, 120, 134, 125, 97, - 123, 134, 113, 126, 119, 146, 147, 0, 149, 110, - 148, 124, 109, 109, 112, 114, 115, 116, 120, 121, - 118, 122, 126, 123, 146, 147, 140, 149, 134, 148, - 146, 152, 125, 153, 0, 151, 154, 156, 147, 140, + 153, 146, 156, 139, 121, 115, 134, 134, 134, 134, + 134, 134, 161, 158, 155, 157, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 156, 159, 160, 161, 162, 165, 172, 170, 176, 173, + 178, 179, 180, 182, 181, 186, 185, 190, 191, 192, + 196, 197, 201, 181, 199, 159, 160, 202, 204, 162, + 203, 205, 208, 172, 181, 165, 170, 173, 185, 186, + 207, 179, 180, 176, 178, 209, 214, 202, 182, 190, + 203, 199, 210, 191, 192, 196, 197, 211, 215, 107, - 163, 140, 149, 126, 131, 140, 148, 0, 0, 0, - 152, 150, 153, 152, 151, 154, 156, 131, 0, 163, - 0, 0, 140, 152, 131, 131, 131, 131, 131, 131, - 150, 151, 154, 156, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 131, 155, 157, 158, - 150, 159, 160, 161, 162, 169, 164, 170, 171, 172, - 174, 0, 173, 175, 176, 177, 155, 157, 158, 178, - 159, 160, 161, 162, 169, 164, 170, 171, 172, 174, - 157, 173, 175, 176, 177, 158, 179, 159, 178, 180, + 201, 103, 100, 204, 207, 83, 205, 78, 72, 64, + 43, 38, 210, 208, 35, 32, 21, 211, 17, 11, + 0, 0, 0, 0, 0, 0, 209, 214, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 215, + 218, 218, 218, 218, 218, 218, 219, 219, 219, 219, + 219, 219, 220, 220, 220, 220, 220, 220, 221, 221, + 221, 221, 221, 221, 222, 222, 223, 0, 223, 224, + 0, 0, 224, 224, 224, 225, 225, 0, 225, 225, + 225, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, - 161, 181, 0, 0, 182, 160, 183, 155, 164, 171, - 174, 173, 184, 162, 185, 179, 186, 0, 180, 187, - 181, 176, 177, 182, 0, 183, 182, 189, 190, 191, - 192, 184, 193, 185, 0, 186, 182, 194, 187, 195, - 196, 180, 179, 181, 197, 198, 189, 190, 191, 192, - 186, 193, 199, 183, 0, 187, 194, 200, 195, 196, - 0, 201, 202, 197, 198, 203, 204, 205, 206, 207, - 208, 199, 0, 191, 209, 210, 200, 192, 0, 193, - 201, 202, 213, 214, 203, 204, 205, 206, 207, 208, - 211, 197, 198, 209, 210, 0, 200, 203, 204, 212, - - 215, 213, 214, 0, 216, 217, 208, 0, 0, 211, - 0, 0, 202, 0, 205, 206, 0, 0, 212, 215, - 0, 0, 211, 216, 217, 0, 0, 209, 210, 0, - 0, 212, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 215, 0, 0, 0, 216, 219, 219, - 219, 219, 219, 220, 220, 220, 220, 220, 221, 221, - 221, 221, 221, 222, 0, 222, 223, 223, 224, 0, - 224, 224, 224, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, - 218, 218, 218, 218, 218, 218, 218 + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217, 217, 217, 217, 217, + 217, 217, 217, 217, 217, 217 } ; /* Table of booleans, true if rule could match eol. */ -static const flex_int32_t yy_rule_can_match_eol[93] = +static const flex_int32_t yy_rule_can_match_eol[97] = { 0, -0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, +0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, }; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; extern int yy_flex_debug; int yy_flex_debug = 0; -static yy_state_type *yy_state_buf=0, *yy_state_ptr=0; -static char *yy_full_match; -static int yy_lp; -#define REJECT \ -{ \ -*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \ -yy_cp = (yy_full_match); /* restore poss. backed-over text */ \ -++(yy_lp); \ -goto find_rule; \ -} - -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() ((yy_more_flag) = 1) +#define YY_MORE_ADJ (yy_more_len) #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "E:/Src/openmohaa/code/parser/lex_source.txt" @@ -822,14 +734,61 @@ void fprintf2( FILE *f, const char *format, ... ) #define fprintf fprintf2 -int prev_yylex = 0; +extern int prev_yylex; +extern int out_pos; +extern int success_pos; +parseStage_e parseStage; + +/* +extern "C" int yywrap(void); + +int yywrap(void) { + if (parseStage == PS_TYPE) { + parseStage = PS_BODY; + out_pos = 0; + success_pos = 0; + return 0; + } + + if (parseStage == PS_BODY) + { + if (YY_START != 0) + { + parseStage = PS_BODY_END; + return 0; + } + + Compiler.CompileError(success_pos, "unexpected end of file found in comment"); + } + + return 1; +} +*/ extern yyparsedata parsedata; -#define YYLLOCSET { yylval.s.sourcePos = parsedata.pos - yyleng; } -#define YYLEX(n) { prev_yylex = n; return n; } +void yyllocset(YYLTYPE *loc, uint32_t off) +{ + success_pos = out_pos - yyleng + off; + loc->sourcePos = success_pos; + parsedata.pos = success_pos; +} + +void yyreducepos(uint32_t off) +{ + out_pos -= off; +} + +#define YYLEX(n) { yyllocset(&yylloc, 0); prev_yylex = n; return n; } +#define YYLEXOFF(n, off) { yyllocset(&yylloc, off); prev_yylex = n; return n; } + +#define YY_USER_ACTION \ +{ \ + out_pos += yyleng - yy_more_len; \ + yylloc.sourcePos = out_pos; \ + parsedata.pos = out_pos; \ +} -#define YY_USER_ACTION parsedata.pos; parsedata.pos += yyleng; #define YY_FATAL_ERROR( n ) yylexerror( n ) void yylexerror( const char *msg ) @@ -887,28 +846,22 @@ static void TextEscapeValue( char *str, size_t len ) static void TextValue( char *str, size_t len ) { - yylval.s.val.stringValue = parsetree_malloc( len + 1 ); - strncpy( yylval.s.val.stringValue, str, len ); - yylval.s.val.stringValue[ len ] = 0; + char* s = parsetree_malloc(len + 1); + strncpy(s, str, len); + s[len] = 0; + yylval.s.val.stringValue = s; } static bool UseField( void ) { - //return prev_yylex == TOKEN_PERIOD || prev_yylex == TOKEN_DOLLAR; - return ( !strncmp( yytext, "game.", 5 ) || - !strncmp( yytext, "group.", 6 ) || - !strncmp( yytext, "level.", 6 ) || - !strncmp( yytext, "local.", 6 ) || - !strncmp( yytext, "parm.", 5 ) || - !strncmp( yytext, "owner.", 6 ) || - !strncmp( yytext, "self.", 5 ) || - *yytext == '$' || *yytext == '-' || *yytext == '/' ); + return prev_yylex == TOKEN_PERIOD + || prev_yylex == TOKEN_DOLLAR; } -#line 908 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" +#line 861 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" /*%option debug*/ -#line 911 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" +#line 864 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" #define INITIAL 0 #define C_COMMENT 1 @@ -1102,12 +1055,6 @@ YY_DECL YY_USER_INIT; #endif - /* Create the reject buffer large enough to save one state per allowed character. */ - if ( ! (yy_state_buf) ) - (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE ); - if ( ! (yy_state_buf) ) - YY_FATAL_ERROR( "out of dynamic memory in yylex()" ); - if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ @@ -1127,13 +1074,19 @@ YY_DECL } { -#line 148 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 190 "E:/Src/openmohaa/code/parser/lex_source.txt" -#line 1133 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" +#line 1080 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { + (yy_more_len) = 0; + if ( (yy_more_flag) ) + { + (yy_more_len) = (int) ((yy_c_buf_p) - (yytext_ptr)); + (yy_more_flag) = 0; + } yy_cp = (yy_c_buf_p); /* Support of yytext. */ @@ -1145,53 +1098,37 @@ YY_DECL yy_bp = yy_cp; yy_current_state = (yy_start); - - (yy_state_ptr) = (yy_state_buf); - *(yy_state_ptr)++ = yy_current_state; - yy_match: do { YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 219 ) + if ( yy_current_state >= 218 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - *(yy_state_ptr)++ = yy_current_state; ++yy_cp; } - while ( yy_current_state != 218 ); + while ( yy_current_state != 217 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); yy_find_action: - yy_current_state = *--(yy_state_ptr); - (yy_lp) = yy_accept[yy_current_state]; - -find_rule: /* we branch to this label when backing up */ - - for ( ; ; ) /* until we find what rule we matched */ - { - if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] ) - { - yy_act = yy_acclist[(yy_lp)]; - { - (yy_full_match) = yy_cp; - break; - } - } - --yy_cp; - yy_current_state = *--(yy_state_ptr); - (yy_lp) = yy_accept[yy_current_state]; - } + yy_act = yy_accept[yy_current_state]; YY_DO_BEFORE_ACTION; if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { int yyl; - for ( yyl = 0; yyl < yyleng; ++yyl ) + for ( yyl = (yy_more_len); yyl < yyleng; ++yyl ) if ( yytext[yyl] == '\n' ) yylineno++; @@ -1202,511 +1139,555 @@ do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + case 1: YY_RULE_SETUP -#line 150 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 192 "E:/Src/openmohaa/code/parser/lex_source.txt" { BEGIN( C_COMMENT ); } YY_BREAK case 2: YY_RULE_SETUP -#line 151 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 193 "E:/Src/openmohaa/code/parser/lex_source.txt" { BEGIN( INITIAL ); } YY_BREAK case 3: /* rule 3 can match eol */ YY_RULE_SETUP -#line 152 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 194 "E:/Src/openmohaa/code/parser/lex_source.txt" { ; } YY_BREAK case 4: YY_RULE_SETUP -#line 153 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 195 "E:/Src/openmohaa/code/parser/lex_source.txt" { ; } YY_BREAK case 5: YY_RULE_SETUP -#line 154 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 196 "E:/Src/openmohaa/code/parser/lex_source.txt" { Compiler.CompileError( parsedata.pos - yyleng, "'*/' found outside of comment" ); } YY_BREAK case 6: /* rule 6 can match eol */ YY_RULE_SETUP -#line 157 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 198 "E:/Src/openmohaa/code/parser/lex_source.txt" { ; } YY_BREAK case 7: YY_RULE_SETUP -#line 158 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 199 "E:/Src/openmohaa/code/parser/lex_source.txt" { if( prev_yylex != TOKEN_EOL ) YYLEX( TOKEN_EOL ); } YY_BREAK case 8: -/* rule 8 can match eol */ YY_RULE_SETUP -#line 160 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( INITIAL ); YYLEX( TOKEN_EOL ); } +#line 201 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN(INITIAL); YYLEX(TOKEN_SIZE); } YY_BREAK case 9: YY_RULE_SETUP -#line 161 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SIZE ); } +#line 202 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX(TOKEN_PERIOD); } YY_BREAK case 10: +/* rule 10 can match eol */ YY_RULE_SETUP -#line 162 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_PERIOD ); } +#line 203 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN(INITIAL); TextEscapeValue(yytext + 1, strlen( yytext ) - 2 ); YYLEX(TOKEN_STRING); } YY_BREAK case 11: -/* rule 11 can match eol */ YY_RULE_SETUP -#line 163 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLLOCSET; TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } +#line 204 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + TextValue(yytext, strlen(yytext)); + YYLEX(TOKEN_IDENTIFIER); + } YY_BREAK case 12: +/* rule 12 can match eol */ YY_RULE_SETUP -#line 164 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLLOCSET; TextValue( yytext, strlen( yytext ) ); YYLEX( TOKEN_IDENTIFIER ); } +#line 208 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + } YY_BREAK case 13: YY_RULE_SETUP -#line 165 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 213 "E:/Src/openmohaa/code/parser/lex_source.txt" { - for ( int i = yyleng - 1; i >= 0; --i ) - unput( yytext[ i ] ); - - parsedata.pos -= yyleng; - - BEGIN( INITIAL ); + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); } YY_BREAK case 14: /* rule 14 can match eol */ YY_RULE_SETUP -#line 174 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ if( prev_yylex != TOKEN_EOL ) YYLEX( TOKEN_EOL ); } +#line 219 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } YY_BREAK case 15: YY_RULE_SETUP -#line 175 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ ; } +#line 222 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_TERNARY ); } YY_BREAK case 16: -/* rule 16 can match eol */ YY_RULE_SETUP -#line 177 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLLOCSET; TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } +#line 223 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_IF ); } YY_BREAK case 17: YY_RULE_SETUP -#line 180 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_TERNARY ); } +#line 224 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_ELSE ); } YY_BREAK case 18: YY_RULE_SETUP -#line 181 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_IF ); } +#line 225 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_WHILE ); } YY_BREAK case 19: YY_RULE_SETUP -#line 182 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_ELSE ); } +#line 226 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_FOR ); } YY_BREAK case 20: YY_RULE_SETUP -#line 183 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_WHILE ); } +#line 227 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_DO ); } YY_BREAK case 21: YY_RULE_SETUP -#line 184 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_FOR ); } +#line 229 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_game ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 22: YY_RULE_SETUP -#line 185 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_DO ); } +#line 230 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_group ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 23: YY_RULE_SETUP -#line 187 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_game ); YYLEX( TOKEN_LISTENER ); } +#line 231 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_level ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 24: YY_RULE_SETUP -#line 188 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_group ); YYLEX( TOKEN_LISTENER ); } +#line 232 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_local ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 25: YY_RULE_SETUP -#line 189 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_level ); YYLEX( TOKEN_LISTENER ); } +#line 233 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_parm ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 26: YY_RULE_SETUP -#line 190 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_local ); YYLEX( TOKEN_LISTENER ); } +#line 234 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_owner ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 27: YY_RULE_SETUP -#line 191 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_parm ); YYLEX( TOKEN_LISTENER ); } +#line 235 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_self ); YYLEX( TOKEN_LISTENER ); } YY_BREAK case 28: YY_RULE_SETUP -#line 192 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_owner ); YYLEX( TOKEN_LISTENER ); } +#line 237 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ parsedata.braces_count++; YYLEX( TOKEN_LEFT_BRACES ); } YY_BREAK case 29: YY_RULE_SETUP -#line 193 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); yylval.s.val = node1_( method_self ); YYLEX( TOKEN_LISTENER ); } +#line 238 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ parsedata.braces_count--; YYLEX( TOKEN_RIGHT_BRACES ); } YY_BREAK case 30: YY_RULE_SETUP -#line 195 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ parsedata.braces_count++; YYLEX( TOKEN_LBRACKET ); } +#line 239 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX(TOKEN_LEFT_BRACKET); } YY_BREAK case 31: YY_RULE_SETUP -#line 196 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ parsedata.braces_count--; YYLEX( TOKEN_RBRACKET ); } +#line 240 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN(VARIABLES); YYLEX(TOKEN_RIGHT_BRACKET); } YY_BREAK case 32: YY_RULE_SETUP -#line 197 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLLOCSET; YYLEX( TOKEN_LPAREN ); } +#line 241 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX(TOKEN_LEFT_SQUARE_BRACKET); } YY_BREAK case 33: YY_RULE_SETUP -#line 198 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); YYLLOCSET; YYLEX( TOKEN_RPAREN ); } +#line 242 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN(VARIABLES); YYLEX(TOKEN_RIGHT_SQUARE_BRACKET); } YY_BREAK case 34: YY_RULE_SETUP -#line 199 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_LSQUARE ); } +#line 244 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_ASSIGNMENT ); } YY_BREAK case 35: YY_RULE_SETUP -#line 200 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); YYLEX( TOKEN_RSQUARE ); } +#line 245 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_COLON ); } YY_BREAK case 36: YY_RULE_SETUP -#line 202 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_ASSIGNMENT ); } +#line 246 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_DOUBLE_COLON ); } YY_BREAK case 37: YY_RULE_SETUP -#line 203 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_COLON ); } +#line 247 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SEMICOLON ); } YY_BREAK case 38: YY_RULE_SETUP -#line 204 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_DOUBLE_COLON ); } +#line 249 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_EQUALITY ); } YY_BREAK case 39: YY_RULE_SETUP -#line 205 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SEMICOLON ); } +#line 250 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_LOGICAL_OR ); } YY_BREAK case 40: YY_RULE_SETUP -#line 207 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_EQUALITY ); } +#line 251 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_LOGICAL_AND ); } YY_BREAK case 41: YY_RULE_SETUP -#line 208 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_LOGICAL_OR ); } +#line 253 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_BITWISE_OR ); } YY_BREAK case 42: YY_RULE_SETUP -#line 209 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_LOGICAL_AND ); } +#line 254 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_BITWISE_EXCL_OR ); } YY_BREAK case 43: YY_RULE_SETUP -#line 211 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_BITWISE_OR ); } +#line 255 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_BITWISE_AND ); } YY_BREAK case 44: YY_RULE_SETUP -#line 212 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_BITWISE_EXCL_OR ); } +#line 256 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_INEQUALITY ); } YY_BREAK case 45: YY_RULE_SETUP -#line 213 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_BITWISE_AND ); } +#line 257 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_LESS_THAN ); } YY_BREAK case 46: YY_RULE_SETUP -#line 214 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_INEQUALITY ); } +#line 258 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_GREATER_THAN ); } YY_BREAK case 47: YY_RULE_SETUP -#line 215 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_LESS_THAN ); } +#line 259 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_LESS_THAN_OR_EQUAL ); } YY_BREAK case 48: YY_RULE_SETUP -#line 216 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_GREATER_THAN ); } +#line 260 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_GREATER_THAN_OR_EQUAL ); } YY_BREAK case 49: YY_RULE_SETUP -#line 217 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_LESS_THAN_OR_EQUAL ); } +#line 261 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_NEG ); } YY_BREAK case 50: YY_RULE_SETUP -#line 218 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_GREATER_THAN_OR_EQUAL ); } +#line 263 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_PLUS ); } YY_BREAK case 51: YY_RULE_SETUP -#line 219 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_NEG ); } +#line 264 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_PLUS_EQUALS ); } YY_BREAK case 52: YY_RULE_SETUP -#line 221 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_PLUS ); } +#line 265 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_INCREMENT ); } YY_BREAK case 53: YY_RULE_SETUP -#line 222 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_PLUS_EQUALS ); } +#line 266 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MINUS ); } YY_BREAK case 54: YY_RULE_SETUP -#line 223 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_INCREMENT ); } +#line 267 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MINUS_EQUALS ); } YY_BREAK case 55: YY_RULE_SETUP -#line 224 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MINUS ); } +#line 268 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MINUS_EQUALS ); } YY_BREAK case 56: YY_RULE_SETUP -#line 225 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MINUS_EQUALS ); } +#line 269 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_DECREMENT ); } YY_BREAK case 57: YY_RULE_SETUP -#line 226 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MINUS_EQUALS ); } +#line 270 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MULTIPLY ); } YY_BREAK case 58: YY_RULE_SETUP -#line 227 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_DECREMENT ); } +#line 271 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MULTIPLY_EQUALS ); } YY_BREAK case 59: YY_RULE_SETUP -#line 228 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MULTIPLY ); } +#line 272 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_DIVIDE ); } YY_BREAK case 60: YY_RULE_SETUP -#line 229 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MULTIPLY_EQUALS ); } +#line 273 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_DIVIDE_EQUALS ); } YY_BREAK case 61: YY_RULE_SETUP -#line 230 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_DIVIDE ); } +#line 274 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MODULUS ); } YY_BREAK case 62: YY_RULE_SETUP -#line 231 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_DIVIDE_EQUALS ); } +#line 275 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MODULUS_EQUALS ); } YY_BREAK case 63: YY_RULE_SETUP -#line 232 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MODULUS ); } +#line 276 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SHIFT_LEFT ); } YY_BREAK case 64: YY_RULE_SETUP -#line 233 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MODULUS_EQUALS ); } +#line 277 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SHIFT_LEFT_EQUALS ); } YY_BREAK case 65: YY_RULE_SETUP -#line 234 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SHIFT_LEFT ); } +#line 278 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SHIFT_RIGHT ); } YY_BREAK case 66: YY_RULE_SETUP -#line 235 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SHIFT_LEFT_EQUALS ); } +#line 279 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SHIFT_RIGHT_EQUALS ); } YY_BREAK case 67: YY_RULE_SETUP -#line 236 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SHIFT_RIGHT ); } +#line 280 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_AND_EQUALS ); } YY_BREAK case 68: YY_RULE_SETUP -#line 237 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SHIFT_RIGHT_EQUALS ); } +#line 281 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_EXCL_OR_EQUALS ); } YY_BREAK case 69: YY_RULE_SETUP -#line 238 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_AND_EQUALS ); } +#line 282 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_OR_EQUALS ); } YY_BREAK case 70: YY_RULE_SETUP -#line 239 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_EXCL_OR_EQUALS ); } +#line 283 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ BEGIN( VARIABLES ); YYLEX( TOKEN_DOLLAR ); } YY_BREAK case 71: YY_RULE_SETUP -#line 240 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_OR_EQUALS ); } +#line 284 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_NOT ); } YY_BREAK case 72: YY_RULE_SETUP -#line 241 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ BEGIN( VARIABLES ); YYLEX( TOKEN_DOLLAR ); } +#line 285 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_COMPLEMENT ); } YY_BREAK case 73: YY_RULE_SETUP -#line 242 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_NOT ); } +#line 287 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_PERIOD ); } YY_BREAK case 74: YY_RULE_SETUP -#line 243 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_COMPLEMENT ); } +#line 289 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_COMMA ); } YY_BREAK case 75: YY_RULE_SETUP -#line 245 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_PERIOD ); } +#line 290 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_NUMBER ); } YY_BREAK case 76: YY_RULE_SETUP -#line 247 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_COMMA ); } +#line 292 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_NULL ); } YY_BREAK case 77: YY_RULE_SETUP -#line 248 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_NUMBER ); } +#line 293 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_NIL ); } YY_BREAK case 78: YY_RULE_SETUP -#line 250 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_NULL ); } +#line 295 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_TRY ); } YY_BREAK case 79: YY_RULE_SETUP -#line 251 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_NIL ); } +#line 296 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_CATCH ); } YY_BREAK case 80: YY_RULE_SETUP -#line 253 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ - char* p = nullptr; - yylval.s.val.intValue = std::strtoll(yytext, &p, 10); - YYLEX(TOKEN_INTEGER); - } +#line 297 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_SWITCH ); } YY_BREAK case 81: YY_RULE_SETUP -#line 258 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 299 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_CASE ); } + YY_BREAK +case 82: +YY_RULE_SETUP +#line 300 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_BREAK ); } + YY_BREAK +case 83: +YY_RULE_SETUP +#line 301 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_CONTINUE ); } + YY_BREAK +case 84: +YY_RULE_SETUP +#line 303 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_MAKEARRAY ); } + YY_BREAK +case 85: +YY_RULE_SETUP +#line 304 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX( TOKEN_ENDARRAY ); } + YY_BREAK +case 86: +/* rule 86 can match eol */ +YY_RULE_SETUP +#line 306 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ if (prev_yylex != TOKEN_EOL) YYLEX(TOKEN_EOL); } + YY_BREAK +case 87: +YY_RULE_SETUP +#line 307 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ ; } + YY_BREAK +case 88: +YY_RULE_SETUP +#line 309 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + char* p = nullptr; + yylval.s.val.intValue = std::strtol(yytext, &p, 10); + YYLEX(TOKEN_INTEGER); + } + YY_BREAK +case 89: +YY_RULE_SETUP +#line 314 "E:/Src/openmohaa/code/parser/lex_source.txt" { char* p = nullptr; yylval.s.val.floatValue = std::strtof(yytext, &p); YYLEX(TOKEN_FLOAT); } YY_BREAK -case 82: -YY_RULE_SETUP -#line 264 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_TRY ); } - YY_BREAK -case 83: -YY_RULE_SETUP -#line 265 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_CATCH ); } - YY_BREAK -case 84: -YY_RULE_SETUP -#line 266 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_SWITCH ); } - YY_BREAK -case 85: -YY_RULE_SETUP -#line 268 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_CASE ); } - YY_BREAK -case 86: -YY_RULE_SETUP -#line 269 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_BREAK ); } - YY_BREAK -case 87: -YY_RULE_SETUP -#line 270 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_CONTINUE ); } - YY_BREAK -case 88: -YY_RULE_SETUP -#line 272 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_MAKEARRAY ); } - YY_BREAK -case 89: -YY_RULE_SETUP -#line 273 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ YYLEX( TOKEN_ENDARRAY ); } - YY_BREAK case 90: YY_RULE_SETUP -#line 275 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 320 "E:/Src/openmohaa/code/parser/lex_source.txt" { - if( UseField() ) - { - parsedata.pos -= yyleng; - REJECT; - } - else - { - YYLLOCSET; - TextEscapeValue( yytext, yyleng ); - YYLEX( TOKEN_IDENTIFIER ); - } + BEGIN(INITIAL); + TextEscapeValue(yytext, yyleng); + YYLEX(TOKEN_IDENTIFIER); } YY_BREAK case 91: +/* rule 91 can match eol */ YY_RULE_SETUP -#line 289 "E:/Src/openmohaa/code/parser/lex_source.txt" -{ yylexerror( "bad token:\n" ); } +#line 325 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + TextEscapeValue(yytext, yyleng - 1); + YYLEXOFF(TOKEN_IDENTIFIER, 1); + } + YY_BREAK +case 92: +YY_RULE_SETUP +#line 332 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + TextEscapeValue(yytext, yyleng - 1); + YYLEXOFF(TOKEN_IDENTIFIER, 1); + } + YY_BREAK +case 93: +YY_RULE_SETUP +#line 340 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + BEGIN(IDENTIFIER); + yymore(); + } + YY_BREAK +case 94: +YY_RULE_SETUP +#line 345 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ + BEGIN(IDENTIFIER); + yymore(); + } + YY_BREAK +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(C_COMMENT): +case YY_STATE_EOF(C_LINE_COMMENT): +case YY_STATE_EOF(VARIABLES): +case YY_STATE_EOF(IDENTIFIER): +#line 350 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YYLEX(TOKEN_EOF); } + YY_BREAK +case 95: +YY_RULE_SETUP +#line 352 "E:/Src/openmohaa/code/parser/lex_source.txt" +{ YY_FATAL_ERROR("bad token:\n"); } YY_BREAK #undef fprintf -case 92: +case 96: YY_RULE_SETUP -#line 297 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 360 "E:/Src/openmohaa/code/parser/lex_source.txt" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 1703 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" - case YY_STATE_EOF(INITIAL): - case YY_STATE_EOF(C_COMMENT): - case YY_STATE_EOF(C_LINE_COMMENT): - case YY_STATE_EOF(VARIABLES): - case YY_STATE_EOF(IDENTIFIER): - yyterminate(); +#line 1690 "E:/Src/openmohaa/code/parser/generated/yyLexer.cpp" case YY_END_OF_BUFFER: { @@ -1771,7 +1752,8 @@ YY_FATAL_ERROR( "flex scanner jammed" ); else { - yy_cp = (yy_c_buf_p); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); goto yy_find_action; } } @@ -1897,8 +1879,38 @@ static int yy_get_next_buffer (void) while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ - YY_FATAL_ERROR( -"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; } @@ -1960,20 +1972,21 @@ static int yy_get_next_buffer (void) yy_current_state = (yy_start); - (yy_state_ptr) = (yy_state_buf); - *(yy_state_ptr)++ = yy_current_state; - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 219 ) + if ( yy_current_state >= 218 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - *(yy_state_ptr)++ = yy_current_state; } return yy_current_state; @@ -1987,18 +2000,22 @@ static int yy_get_next_buffer (void) static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) { int yy_is_jam; - + char *yy_cp = (yy_c_buf_p); + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 219 ) + if ( yy_current_state >= 218 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 218); - if ( ! yy_is_jam ) - *(yy_state_ptr)++ = yy_current_state; + yy_is_jam = (yy_current_state == 217); return yy_is_jam ? 0 : yy_current_state; } @@ -2599,11 +2616,6 @@ static int yy_init_globals (void) (yy_init) = 0; (yy_start) = 0; - (yy_state_buf) = 0; - (yy_state_ptr) = 0; - (yy_full_match) = 0; - (yy_lp) = 0; - /* Defined in main.c */ #ifdef YY_STDINIT yyin = stdin; @@ -2634,9 +2646,6 @@ int yylex_destroy (void) yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; - yyfree ( (yy_state_buf) ); - (yy_state_buf) = NULL; - /* Reset the globals. This is important in a non-reentrant scanner so the next time * yylex() is called, initialization will occur. */ yy_init_globals( ); @@ -2694,6 +2703,6 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 297 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 360 "E:/Src/openmohaa/code/parser/lex_source.txt" diff --git a/code/parser/generated/yyLexer.h b/code/parser/generated/yyLexer.h index 776f3850..a38ea25b 100644 --- a/code/parser/generated/yyLexer.h +++ b/code/parser/generated/yyLexer.h @@ -465,7 +465,7 @@ extern int yylex (void); #undef yyTABLES_NAME #endif -#line 297 "E:/Src/openmohaa/code/parser/lex_source.txt" +#line 360 "E:/Src/openmohaa/code/parser/lex_source.txt" #line 471 "E:/Src/openmohaa/code/parser/generated/yyLexer.h" diff --git a/code/parser/generated/yyParser.cpp b/code/parser/generated/yyParser.cpp index ff4501e9..7c334ce5 100644 --- a/code/parser/generated/yyParser.cpp +++ b/code/parser/generated/yyParser.cpp @@ -104,10 +104,15 @@ extern int prev_yylex; extern yyparsedata parsedata; -#define YYLLOC node_pos( parsedata.pos - yyleng ) +int prev_yylex; +int out_pos; +int success_pos; + +#define YYLLOC node_pos(success_pos - yyleng) +#define TOKPOS(pos) node_pos(pos.sourcePos) -#line 111 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" +#line 116 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" # ifndef YY_CAST # ifdef __cplusplus @@ -135,97 +140,103 @@ extern yyparsedata parsedata; enum yysymbol_kind_t { YYSYMBOL_YYEMPTY = -2, - YYSYMBOL_YYEOF = 0, /* END */ + YYSYMBOL_YYEOF = 0, /* TOKEN_EOF */ YYSYMBOL_YYerror = 1, /* error */ YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ - YYSYMBOL_TOKEN_EOL = 3, /* TOKEN_EOL */ - YYSYMBOL_TOKEN_COMMA = 4, /* TOKEN_COMMA */ - YYSYMBOL_TOKEN_ASSIGNMENT = 5, /* TOKEN_ASSIGNMENT */ - YYSYMBOL_TOKEN_PLUS_EQUALS = 6, /* TOKEN_PLUS_EQUALS */ - YYSYMBOL_TOKEN_MINUS_EQUALS = 7, /* TOKEN_MINUS_EQUALS */ - YYSYMBOL_TOKEN_MULTIPLY_EQUALS = 8, /* TOKEN_MULTIPLY_EQUALS */ - YYSYMBOL_TOKEN_DIVIDE_EQUALS = 9, /* TOKEN_DIVIDE_EQUALS */ - YYSYMBOL_TOKEN_MODULUS_EQUALS = 10, /* TOKEN_MODULUS_EQUALS */ - YYSYMBOL_TOKEN_AND_EQUALS = 11, /* TOKEN_AND_EQUALS */ - YYSYMBOL_TOKEN_EXCL_OR_EQUALS = 12, /* TOKEN_EXCL_OR_EQUALS */ - YYSYMBOL_TOKEN_OR_EQUALS = 13, /* TOKEN_OR_EQUALS */ - YYSYMBOL_TOKEN_SHIFT_LEFT_EQUALS = 14, /* TOKEN_SHIFT_LEFT_EQUALS */ - YYSYMBOL_TOKEN_SHIFT_RIGHT_EQUALS = 15, /* TOKEN_SHIFT_RIGHT_EQUALS */ - YYSYMBOL_TOKEN_TERNARY = 16, /* TOKEN_TERNARY */ - YYSYMBOL_TOKEN_LOGICAL_OR = 17, /* TOKEN_LOGICAL_OR */ - YYSYMBOL_TOKEN_LOGICAL_AND = 18, /* TOKEN_LOGICAL_AND */ - YYSYMBOL_TOKEN_BITWISE_OR = 19, /* TOKEN_BITWISE_OR */ - YYSYMBOL_TOKEN_BITWISE_EXCL_OR = 20, /* TOKEN_BITWISE_EXCL_OR */ - YYSYMBOL_TOKEN_BITWISE_AND = 21, /* TOKEN_BITWISE_AND */ - YYSYMBOL_TOKEN_EQUALITY = 22, /* TOKEN_EQUALITY */ - YYSYMBOL_TOKEN_INEQUALITY = 23, /* TOKEN_INEQUALITY */ - YYSYMBOL_TOKEN_LESS_THAN = 24, /* TOKEN_LESS_THAN */ - YYSYMBOL_TOKEN_LESS_THAN_OR_EQUAL = 25, /* TOKEN_LESS_THAN_OR_EQUAL */ - YYSYMBOL_TOKEN_GREATER_THAN = 26, /* TOKEN_GREATER_THAN */ - YYSYMBOL_TOKEN_GREATER_THAN_OR_EQUAL = 27, /* TOKEN_GREATER_THAN_OR_EQUAL */ - YYSYMBOL_TOKEN_SHIFT_LEFT = 28, /* TOKEN_SHIFT_LEFT */ - YYSYMBOL_TOKEN_SHIFT_RIGHT = 29, /* TOKEN_SHIFT_RIGHT */ - YYSYMBOL_TOKEN_PLUS = 30, /* TOKEN_PLUS */ - YYSYMBOL_TOKEN_MINUS = 31, /* TOKEN_MINUS */ - YYSYMBOL_TOKEN_MULTIPLY = 32, /* TOKEN_MULTIPLY */ - YYSYMBOL_TOKEN_DIVIDE = 33, /* TOKEN_DIVIDE */ - YYSYMBOL_TOKEN_MODULUS = 34, /* TOKEN_MODULUS */ - YYSYMBOL_TOKEN_LISTENER = 35, /* TOKEN_LISTENER */ - YYSYMBOL_TOKEN_NEG = 36, /* TOKEN_NEG */ - YYSYMBOL_TOKEN_NOT = 37, /* TOKEN_NOT */ - YYSYMBOL_TOKEN_COMPLEMENT = 38, /* TOKEN_COMPLEMENT */ - YYSYMBOL_TOKEN_FLOAT = 39, /* TOKEN_FLOAT */ - YYSYMBOL_TOKEN_INTEGER = 40, /* TOKEN_INTEGER */ - YYSYMBOL_TOKEN_IDENTIFIER = 41, /* TOKEN_IDENTIFIER */ - YYSYMBOL_TOKEN_STRING = 42, /* TOKEN_STRING */ - YYSYMBOL_TOKEN_NIL = 43, /* TOKEN_NIL */ - YYSYMBOL_TOKEN_NULL = 44, /* TOKEN_NULL */ - YYSYMBOL_TOKEN_LBRACKET = 45, /* TOKEN_LBRACKET */ - YYSYMBOL_TOKEN_RBRACKET = 46, /* TOKEN_RBRACKET */ - YYSYMBOL_TOKEN_COLON = 47, /* TOKEN_COLON */ - YYSYMBOL_TOKEN_SEMICOLON = 48, /* TOKEN_SEMICOLON */ - YYSYMBOL_TOKEN_DOLLAR = 49, /* TOKEN_DOLLAR */ - YYSYMBOL_TOKEN_DOUBLE_COLON = 50, /* TOKEN_DOUBLE_COLON */ - YYSYMBOL_TOKEN_NUMBER = 51, /* TOKEN_NUMBER */ - YYSYMBOL_TOKEN_LSQUARE = 52, /* TOKEN_LSQUARE */ - YYSYMBOL_TOKEN_RSQUARE = 53, /* TOKEN_RSQUARE */ - YYSYMBOL_TOKEN_LPAREN = 54, /* TOKEN_LPAREN */ - YYSYMBOL_TOKEN_RPAREN = 55, /* TOKEN_RPAREN */ - YYSYMBOL_TOKEN_INCREMENT = 56, /* TOKEN_INCREMENT */ - YYSYMBOL_TOKEN_DECREMENT = 57, /* TOKEN_DECREMENT */ - YYSYMBOL_TOKEN_PERIOD = 58, /* TOKEN_PERIOD */ - YYSYMBOL_TOKEN_MAKEARRAY = 59, /* TOKEN_MAKEARRAY */ - YYSYMBOL_TOKEN_ENDARRAY = 60, /* TOKEN_ENDARRAY */ - YYSYMBOL_TOKEN_CATCH = 61, /* TOKEN_CATCH */ - YYSYMBOL_TOKEN_TRY = 62, /* TOKEN_TRY */ - YYSYMBOL_TOKEN_DO = 63, /* TOKEN_DO */ - YYSYMBOL_TOKEN_FOR = 64, /* TOKEN_FOR */ - YYSYMBOL_TOKEN_IF = 65, /* TOKEN_IF */ - YYSYMBOL_TOKEN_ELSE = 66, /* TOKEN_ELSE */ + YYSYMBOL_3_end_of_file_ = 3, /* "end of file" */ + YYSYMBOL_TOKEN_EOL = 4, /* TOKEN_EOL */ + YYSYMBOL_TOKEN_COMMA = 5, /* TOKEN_COMMA */ + YYSYMBOL_TOKEN_IF = 6, /* TOKEN_IF */ + YYSYMBOL_TOKEN_ELSE = 7, /* TOKEN_ELSE */ + YYSYMBOL_TOKEN_WHILE = 8, /* TOKEN_WHILE */ + YYSYMBOL_TOKEN_FOR = 9, /* TOKEN_FOR */ + YYSYMBOL_TOKEN_DO = 10, /* TOKEN_DO */ + YYSYMBOL_TOKEN_IDENTIFIER = 11, /* TOKEN_IDENTIFIER */ + YYSYMBOL_TOKEN_LEFT_BRACES = 12, /* TOKEN_LEFT_BRACES */ + YYSYMBOL_TOKEN_RIGHT_BRACES = 13, /* TOKEN_RIGHT_BRACES */ + YYSYMBOL_TOKEN_LEFT_BRACKET = 14, /* TOKEN_LEFT_BRACKET */ + YYSYMBOL_TOKEN_RIGHT_BRACKET = 15, /* TOKEN_RIGHT_BRACKET */ + YYSYMBOL_TOKEN_LEFT_SQUARE_BRACKET = 16, /* TOKEN_LEFT_SQUARE_BRACKET */ + YYSYMBOL_TOKEN_RIGHT_SQUARE_BRACKET = 17, /* TOKEN_RIGHT_SQUARE_BRACKET */ + YYSYMBOL_TOKEN_ASSIGNMENT = 18, /* TOKEN_ASSIGNMENT */ + YYSYMBOL_TOKEN_PLUS_EQUALS = 19, /* TOKEN_PLUS_EQUALS */ + YYSYMBOL_TOKEN_MINUS_EQUALS = 20, /* TOKEN_MINUS_EQUALS */ + YYSYMBOL_TOKEN_MULTIPLY_EQUALS = 21, /* TOKEN_MULTIPLY_EQUALS */ + YYSYMBOL_TOKEN_DIVIDE_EQUALS = 22, /* TOKEN_DIVIDE_EQUALS */ + YYSYMBOL_TOKEN_MODULUS_EQUALS = 23, /* TOKEN_MODULUS_EQUALS */ + YYSYMBOL_TOKEN_AND_EQUALS = 24, /* TOKEN_AND_EQUALS */ + YYSYMBOL_TOKEN_EXCL_OR_EQUALS = 25, /* TOKEN_EXCL_OR_EQUALS */ + YYSYMBOL_TOKEN_OR_EQUALS = 26, /* TOKEN_OR_EQUALS */ + YYSYMBOL_TOKEN_SHIFT_LEFT_EQUALS = 27, /* TOKEN_SHIFT_LEFT_EQUALS */ + YYSYMBOL_TOKEN_SHIFT_RIGHT_EQUALS = 28, /* TOKEN_SHIFT_RIGHT_EQUALS */ + YYSYMBOL_TOKEN_TERNARY = 29, /* TOKEN_TERNARY */ + YYSYMBOL_TOKEN_COLON = 30, /* TOKEN_COLON */ + YYSYMBOL_TOKEN_LOGICAL_OR = 31, /* TOKEN_LOGICAL_OR */ + YYSYMBOL_TOKEN_LOGICAL_AND = 32, /* TOKEN_LOGICAL_AND */ + YYSYMBOL_TOKEN_BITWISE_OR = 33, /* TOKEN_BITWISE_OR */ + YYSYMBOL_TOKEN_BITWISE_EXCL_OR = 34, /* TOKEN_BITWISE_EXCL_OR */ + YYSYMBOL_TOKEN_BITWISE_AND = 35, /* TOKEN_BITWISE_AND */ + YYSYMBOL_TOKEN_EQUALITY = 36, /* TOKEN_EQUALITY */ + YYSYMBOL_TOKEN_INEQUALITY = 37, /* TOKEN_INEQUALITY */ + YYSYMBOL_TOKEN_LESS_THAN = 38, /* TOKEN_LESS_THAN */ + YYSYMBOL_TOKEN_LESS_THAN_OR_EQUAL = 39, /* TOKEN_LESS_THAN_OR_EQUAL */ + YYSYMBOL_TOKEN_GREATER_THAN = 40, /* TOKEN_GREATER_THAN */ + YYSYMBOL_TOKEN_GREATER_THAN_OR_EQUAL = 41, /* TOKEN_GREATER_THAN_OR_EQUAL */ + YYSYMBOL_TOKEN_SHIFT_LEFT = 42, /* TOKEN_SHIFT_LEFT */ + YYSYMBOL_TOKEN_SHIFT_RIGHT = 43, /* TOKEN_SHIFT_RIGHT */ + YYSYMBOL_TOKEN_PLUS = 44, /* TOKEN_PLUS */ + YYSYMBOL_TOKEN_MINUS = 45, /* TOKEN_MINUS */ + YYSYMBOL_TOKEN_MULTIPLY = 46, /* TOKEN_MULTIPLY */ + YYSYMBOL_TOKEN_DIVIDE = 47, /* TOKEN_DIVIDE */ + YYSYMBOL_TOKEN_MODULUS = 48, /* TOKEN_MODULUS */ + YYSYMBOL_TOKEN_NEG = 49, /* TOKEN_NEG */ + YYSYMBOL_TOKEN_NOT = 50, /* TOKEN_NOT */ + YYSYMBOL_TOKEN_COMPLEMENT = 51, /* TOKEN_COMPLEMENT */ + YYSYMBOL_TOKEN_STRING = 52, /* TOKEN_STRING */ + YYSYMBOL_TOKEN_INTEGER = 53, /* TOKEN_INTEGER */ + YYSYMBOL_TOKEN_FLOAT = 54, /* TOKEN_FLOAT */ + YYSYMBOL_TOKEN_LISTENER = 55, /* TOKEN_LISTENER */ + YYSYMBOL_TOKEN_NIL = 56, /* TOKEN_NIL */ + YYSYMBOL_TOKEN_NULL = 57, /* TOKEN_NULL */ + YYSYMBOL_TOKEN_DOUBLE_COLON = 58, /* TOKEN_DOUBLE_COLON */ + YYSYMBOL_TOKEN_SEMICOLON = 59, /* TOKEN_SEMICOLON */ + YYSYMBOL_TOKEN_DOLLAR = 60, /* TOKEN_DOLLAR */ + YYSYMBOL_TOKEN_NUMBER = 61, /* TOKEN_NUMBER */ + YYSYMBOL_TOKEN_INCREMENT = 62, /* TOKEN_INCREMENT */ + YYSYMBOL_TOKEN_DECREMENT = 63, /* TOKEN_DECREMENT */ + YYSYMBOL_TOKEN_PERIOD = 64, /* TOKEN_PERIOD */ + YYSYMBOL_TOKEN_CATCH = 65, /* TOKEN_CATCH */ + YYSYMBOL_TOKEN_TRY = 66, /* TOKEN_TRY */ YYSYMBOL_TOKEN_SWITCH = 67, /* TOKEN_SWITCH */ - YYSYMBOL_TOKEN_WHILE = 68, /* TOKEN_WHILE */ + YYSYMBOL_TOKEN_CASE = 68, /* TOKEN_CASE */ YYSYMBOL_TOKEN_BREAK = 69, /* TOKEN_BREAK */ - YYSYMBOL_TOKEN_CASE = 70, /* TOKEN_CASE */ - YYSYMBOL_TOKEN_CONTINUE = 71, /* TOKEN_CONTINUE */ - YYSYMBOL_TOKEN_SIZE = 72, /* TOKEN_SIZE */ - YYSYMBOL_TOKEN_END = 73, /* TOKEN_END */ - YYSYMBOL_TOKEN_RETURN = 74, /* TOKEN_RETURN */ - YYSYMBOL_YYACCEPT = 75, /* $accept */ - YYSYMBOL_program = 76, /* program */ - YYSYMBOL_statement_list = 77, /* statement_list */ - YYSYMBOL_statement = 78, /* statement */ - YYSYMBOL_compound_statement = 79, /* compound_statement */ - YYSYMBOL_expr = 80, /* expr */ - YYSYMBOL_func_prim_expr = 81, /* func_prim_expr */ - YYSYMBOL_event_parameter_list = 82, /* event_parameter_list */ - YYSYMBOL_event_parameter_list_need = 83, /* event_parameter_list_need */ - YYSYMBOL_prim_expr = 84, /* prim_expr */ - YYSYMBOL_nonident_prim_expr = 85, /* nonident_prim_expr */ - YYSYMBOL_number = 86, /* number */ - YYSYMBOL_identifier_prim = 87, /* identifier_prim */ - YYSYMBOL_makearray_statement_list = 88, /* makearray_statement_list */ - YYSYMBOL_makearray_statement = 89, /* makearray_statement */ - YYSYMBOL_newline = 90 /* newline */ + YYSYMBOL_TOKEN_CONTINUE = 70, /* TOKEN_CONTINUE */ + YYSYMBOL_TOKEN_SIZE = 71, /* TOKEN_SIZE */ + YYSYMBOL_TOKEN_END = 72, /* TOKEN_END */ + YYSYMBOL_TOKEN_RETURN = 73, /* TOKEN_RETURN */ + YYSYMBOL_TOKEN_MAKEARRAY = 74, /* TOKEN_MAKEARRAY */ + YYSYMBOL_TOKEN_ENDARRAY = 75, /* TOKEN_ENDARRAY */ + YYSYMBOL_YYACCEPT = 76, /* $accept */ + YYSYMBOL_program = 77, /* program */ + YYSYMBOL_statement_list = 78, /* statement_list */ + YYSYMBOL_statement = 79, /* statement */ + YYSYMBOL_statement_declaration = 80, /* statement_declaration */ + YYSYMBOL_compound_statement = 81, /* compound_statement */ + YYSYMBOL_selection_statement = 82, /* selection_statement */ + YYSYMBOL_iteration_statement = 83, /* iteration_statement */ + YYSYMBOL_expr = 84, /* expr */ + YYSYMBOL_func_prim_expr = 85, /* func_prim_expr */ + YYSYMBOL_event_parameter_list = 86, /* event_parameter_list */ + YYSYMBOL_event_parameter_list_need = 87, /* event_parameter_list_need */ + YYSYMBOL_event_parameter = 88, /* event_parameter */ + YYSYMBOL_const_array_list = 89, /* const_array_list */ + YYSYMBOL_const_array = 90, /* const_array */ + YYSYMBOL_prim_expr = 91, /* prim_expr */ + YYSYMBOL_nonident_prim_expr = 92, /* nonident_prim_expr */ + YYSYMBOL_identifier_prim = 93, /* identifier_prim */ + YYSYMBOL_makearray_statement_list = 94, /* makearray_statement_list */ + YYSYMBOL_makearray_statement = 95, /* makearray_statement */ + YYSYMBOL_line_opt = 96 /* line_opt */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -492,13 +503,15 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ + && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { yy_state_t yyss_alloc; YYSTYPE yyvs_alloc; + YYLTYPE yyls_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ @@ -507,8 +520,9 @@ union yyalloc /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ - ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \ + + YYSIZEOF (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 @@ -551,21 +565,21 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 4 +#define YYFINAL 6 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 1169 +#define YYLAST 806 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 75 +#define YYNTOKENS 76 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 16 +#define YYNNTS 21 /* YYNRULES -- Number of rules. */ -#define YYNRULES 103 +#define YYNRULES 107 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 240 +#define YYNSTATES 206 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 329 +#define YYMAXUTOK 330 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -611,24 +625,25 @@ static const yytype_int8 yytranslate[] = 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 108, 108, 112, 114, 115, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 132, 136, 137, 138, 139, - 140, 141, 143, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 162, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 191, 193, 195, 196, 197, 198, 199, 200, 204, 205, - 206, 210, 211, 215, 216, 217, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 242, 243, 247, 251, 252, 253, - 257, 258, 262, 263 + 0, 128, 128, 129, 133, 134, 138, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 171, 172, 173, 177, 178, 179, 183, 184, 189, + 193, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 223, 224, 225, 226, 227, 228, + 232, 236, 243, 244, 248, 252, 253, 257, 258, 262, + 263, 267, 268, 269, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 291, + 295, 296, 297, 298, 302, 303, 307, 308 }; #endif @@ -644,30 +659,34 @@ static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { - "END", "error", "\"invalid token\"", "TOKEN_EOL", "TOKEN_COMMA", + "TOKEN_EOF", "error", "\"invalid token\"", "\"end of file\"", + "TOKEN_EOL", "TOKEN_COMMA", "TOKEN_IF", "TOKEN_ELSE", "TOKEN_WHILE", + "TOKEN_FOR", "TOKEN_DO", "TOKEN_IDENTIFIER", "TOKEN_LEFT_BRACES", + "TOKEN_RIGHT_BRACES", "TOKEN_LEFT_BRACKET", "TOKEN_RIGHT_BRACKET", + "TOKEN_LEFT_SQUARE_BRACKET", "TOKEN_RIGHT_SQUARE_BRACKET", "TOKEN_ASSIGNMENT", "TOKEN_PLUS_EQUALS", "TOKEN_MINUS_EQUALS", "TOKEN_MULTIPLY_EQUALS", "TOKEN_DIVIDE_EQUALS", "TOKEN_MODULUS_EQUALS", "TOKEN_AND_EQUALS", "TOKEN_EXCL_OR_EQUALS", "TOKEN_OR_EQUALS", "TOKEN_SHIFT_LEFT_EQUALS", "TOKEN_SHIFT_RIGHT_EQUALS", "TOKEN_TERNARY", - "TOKEN_LOGICAL_OR", "TOKEN_LOGICAL_AND", "TOKEN_BITWISE_OR", - "TOKEN_BITWISE_EXCL_OR", "TOKEN_BITWISE_AND", "TOKEN_EQUALITY", - "TOKEN_INEQUALITY", "TOKEN_LESS_THAN", "TOKEN_LESS_THAN_OR_EQUAL", - "TOKEN_GREATER_THAN", "TOKEN_GREATER_THAN_OR_EQUAL", "TOKEN_SHIFT_LEFT", - "TOKEN_SHIFT_RIGHT", "TOKEN_PLUS", "TOKEN_MINUS", "TOKEN_MULTIPLY", - "TOKEN_DIVIDE", "TOKEN_MODULUS", "TOKEN_LISTENER", "TOKEN_NEG", - "TOKEN_NOT", "TOKEN_COMPLEMENT", "TOKEN_FLOAT", "TOKEN_INTEGER", - "TOKEN_IDENTIFIER", "TOKEN_STRING", "TOKEN_NIL", "TOKEN_NULL", - "TOKEN_LBRACKET", "TOKEN_RBRACKET", "TOKEN_COLON", "TOKEN_SEMICOLON", - "TOKEN_DOLLAR", "TOKEN_DOUBLE_COLON", "TOKEN_NUMBER", "TOKEN_LSQUARE", - "TOKEN_RSQUARE", "TOKEN_LPAREN", "TOKEN_RPAREN", "TOKEN_INCREMENT", - "TOKEN_DECREMENT", "TOKEN_PERIOD", "TOKEN_MAKEARRAY", "TOKEN_ENDARRAY", - "TOKEN_CATCH", "TOKEN_TRY", "TOKEN_DO", "TOKEN_FOR", "TOKEN_IF", - "TOKEN_ELSE", "TOKEN_SWITCH", "TOKEN_WHILE", "TOKEN_BREAK", "TOKEN_CASE", - "TOKEN_CONTINUE", "TOKEN_SIZE", "TOKEN_END", "TOKEN_RETURN", "$accept", - "program", "statement_list", "statement", "compound_statement", "expr", - "func_prim_expr", "event_parameter_list", "event_parameter_list_need", - "prim_expr", "nonident_prim_expr", "number", "identifier_prim", - "makearray_statement_list", "makearray_statement", "newline", YY_NULLPTR + "TOKEN_COLON", "TOKEN_LOGICAL_OR", "TOKEN_LOGICAL_AND", + "TOKEN_BITWISE_OR", "TOKEN_BITWISE_EXCL_OR", "TOKEN_BITWISE_AND", + "TOKEN_EQUALITY", "TOKEN_INEQUALITY", "TOKEN_LESS_THAN", + "TOKEN_LESS_THAN_OR_EQUAL", "TOKEN_GREATER_THAN", + "TOKEN_GREATER_THAN_OR_EQUAL", "TOKEN_SHIFT_LEFT", "TOKEN_SHIFT_RIGHT", + "TOKEN_PLUS", "TOKEN_MINUS", "TOKEN_MULTIPLY", "TOKEN_DIVIDE", + "TOKEN_MODULUS", "TOKEN_NEG", "TOKEN_NOT", "TOKEN_COMPLEMENT", + "TOKEN_STRING", "TOKEN_INTEGER", "TOKEN_FLOAT", "TOKEN_LISTENER", + "TOKEN_NIL", "TOKEN_NULL", "TOKEN_DOUBLE_COLON", "TOKEN_SEMICOLON", + "TOKEN_DOLLAR", "TOKEN_NUMBER", "TOKEN_INCREMENT", "TOKEN_DECREMENT", + "TOKEN_PERIOD", "TOKEN_CATCH", "TOKEN_TRY", "TOKEN_SWITCH", "TOKEN_CASE", + "TOKEN_BREAK", "TOKEN_CONTINUE", "TOKEN_SIZE", "TOKEN_END", + "TOKEN_RETURN", "TOKEN_MAKEARRAY", "TOKEN_ENDARRAY", "$accept", + "program", "statement_list", "statement", "statement_declaration", + "compound_statement", "selection_statement", "iteration_statement", + "expr", "func_prim_expr", "event_parameter_list", + "event_parameter_list_need", "event_parameter", "const_array_list", + "const_array", "prim_expr", "nonident_prim_expr", "identifier_prim", + "makearray_statement_list", "makearray_statement", "line_opt", YY_NULLPTR }; static const char * @@ -677,12 +696,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-97) +#define YYPACT_NINF (-90) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-1) +#define YYTABLE_NINF (-3) #define yytable_value_is_error(Yyn) \ 0 @@ -691,30 +710,27 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - -2, -97, 9, 482, -97, -23, -18, -97, 1081, 1081, - 1081, -97, -97, 1061, -97, -97, -97, -2, -25, 911, - -2, -2, -29, 1061, 1061, 1061, -97, 1061, -97, 691, - 5, -97, 313, -97, -97, 1061, 1061, -21, -21, -21, - -97, 360, -11, -21, -97, 482, -97, -97, 457, 936, - 936, 936, 961, -97, -2, 538, -97, -22, -97, -5, - 691, 381, 1, 1, 1, 981, 5, -97, -97, 457, - 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, - 1061, 457, -97, -97, -27, 1001, 1021, -97, -11, 1061, - 482, 747, 961, -97, -22, -97, -22, -97, -22, 1061, - 1061, -11, 1061, 457, -2, -2, -2, -2, -2, -2, - -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, - -2, -2, -97, 582, 1061, 1061, -2, 5, 457, -4, - 691, -5, 691, 1041, -97, 1120, 1120, 1120, 1120, 1120, - 1120, 1120, 1120, 1120, 1120, 1120, 1061, 806, -97, -97, - -97, -97, -97, -11, -19, -97, -11, -11, -11, 98, - 98, 910, 457, 457, 457, 457, 457, 457, 457, 457, - 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, - 766, 1061, -11, -9, -13, 844, 457, 5, -97, 2, - -97, -97, -97, 98, -17, -11, -97, 457, 785, 822, - 1135, 432, 857, 888, 888, 81, 81, 81, 81, 35, - 35, 27, 27, -97, -97, -97, -97, -2, 1061, 482, - 877, 4, -97, -97, 1120, -5, -11, 607, 482, -2, - -97, -2, 649, 691, 691, -2, 2, 2, 691, 2 + 31, -90, 41, 62, -90, 402, -90, -90, 402, 519, + 519, 34, 31, 519, 31, 113, 368, 368, 368, -90, + -90, -90, -90, -90, -90, -90, 519, 56, 519, 519, + -90, -90, 31, -90, -90, -90, 489, 56, -90, 25, + 30, -90, 25, 17, 53, 50, 519, 26, 77, 335, + 113, 236, 424, 424, 424, 189, 268, -90, 27, 0, + 0, 0, 26, 33, 21, 507, -90, 519, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + -90, -90, 6, 31, 519, 92, -90, 113, 43, 519, + -90, 26, -90, -90, 683, 519, -90, 519, 236, -90, + -30, -90, -30, -90, -30, 189, 26, 59, 436, -90, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 323, + 519, 519, 56, -90, 93, -90, 583, 683, 683, 683, + 683, 683, 683, 683, 683, 683, 683, 683, -90, -90, + -90, 49, -90, 30, -90, 31, 603, 113, 26, 49, + 519, -90, 490, -90, 26, 663, 700, 716, 731, 745, + 758, 563, 563, 102, 102, 102, 102, 94, 94, 74, + 74, -90, -90, -90, 551, -90, 49, -90, -90, -90, + 519, -90, 31, 632, -90, 113, -90, -90, 82, 31, + 683, 31, 85, -90, 31, -90 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -722,351 +738,275 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int8 yydefact[] = { - 102, 103, 0, 102, 1, 0, 0, 86, 0, 0, - 0, 94, 95, 68, 83, 93, 92, 102, 0, 0, - 102, 102, 0, 0, 0, 0, 19, 0, 20, 2, - 102, 10, 0, 84, 5, 68, 68, 89, 91, 90, - 96, 21, 70, 73, 74, 102, 77, 78, 0, 0, - 0, 0, 96, 88, 102, 0, 58, 57, 59, 0, - 0, 0, 102, 102, 102, 68, 102, 36, 4, 0, + 106, 107, 0, 106, 4, 3, 1, 5, 0, 0, + 0, 0, 106, 72, 106, 0, 0, 0, 0, 88, + 89, 90, 92, 98, 97, 30, 0, 0, 0, 0, + 13, 14, 106, 9, 10, 11, 0, 0, 99, 106, + 81, 82, 106, 106, 0, 15, 73, 75, 106, 0, + 0, 63, 0, 0, 0, 100, 0, 62, 61, 94, + 96, 95, 84, 0, 0, 72, 6, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 68, 0, 34, 35, 0, 0, 0, 6, 69, 0, - 102, 0, 0, 62, 89, 64, 91, 63, 90, 0, - 60, 72, 97, 0, 102, 102, 102, 102, 102, 102, - 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, - 102, 102, 87, 0, 68, 0, 102, 102, 0, 0, - 0, 0, 0, 0, 3, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 22, 0, 79, 80, - 81, 7, 8, 75, 0, 76, 65, 71, 100, 102, - 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 28, 29, 0, 106, 0, 34, 37, 0, 0, 0, + 7, 76, 31, 32, 60, 0, 64, 74, 0, 66, + 94, 68, 96, 67, 95, 100, 104, 0, 0, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 61, 66, 0, 0, 0, 36, 102, 18, 13, - 9, 82, 37, 102, 0, 101, 99, 0, 39, 38, - 42, 41, 40, 43, 44, 45, 47, 46, 48, 54, - 55, 49, 50, 51, 52, 53, 85, 102, 0, 102, - 0, 11, 98, 67, 56, 0, 16, 0, 102, 102, - 17, 102, 0, 0, 0, 102, 12, 15, 0, 14 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 36, 0, 16, 0, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 85, 86, + 33, 83, 77, 79, 80, 106, 0, 0, 40, 69, + 103, 71, 0, 102, 105, 0, 42, 41, 44, 45, + 43, 46, 47, 48, 50, 49, 51, 57, 58, 52, + 53, 54, 55, 56, 0, 65, 70, 12, 8, 87, + 0, 35, 106, 0, 101, 0, 91, 78, 106, 106, + 59, 106, 106, 39, 106, 38 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -97, -97, -43, -26, -46, 305, 29, -24, -97, 170, - -3, -97, 213, -97, -96, 54 + -90, -90, -13, -3, -90, -7, -90, -90, 141, 78, + -63, -90, -20, -73, -86, 46, -2, -72, 28, -89, + 5 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_uint8 yydefgoto[] = { - 0, 2, 29, 30, 31, 55, 56, 41, 100, 42, - 57, 33, 58, 159, 160, 34 + 0, 2, 3, 4, 32, 33, 34, 35, 56, 57, + 45, 96, 46, 151, 152, 47, 58, 41, 107, 108, + 8 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ -static const yytype_uint8 yytable[] = +static const yytype_int16 yytable[] = { - 32, 1, 90, 66, 1, 37, 38, 39, 1, 4, - 43, 85, 86, 126, 148, 149, 46, 47, 35, 124, - 43, 43, 43, 36, 43, 61, 32, 192, 125, 48, - 81, 81, 43, 43, 127, 129, 84, 84, 43, 89, - 17, 133, 32, 223, 186, 150, 94, 96, 98, 43, - 67, 89, 217, 67, 3, 218, 146, 32, 32, 119, - 120, 121, 43, 193, 66, 117, 118, 119, 120, 121, - 229, 45, 0, 0, 59, 60, 0, 43, 93, 95, - 97, 0, 43, 43, 68, 188, 43, 32, 0, 43, - 0, 0, 0, 0, 0, 0, 43, 43, 0, 43, - 181, 1, 0, 0, 187, 0, 189, 0, 102, 115, - 116, 117, 118, 119, 120, 121, 130, 131, 132, 0, - 134, 43, 43, 0, 0, 0, 0, 32, 0, 32, - 43, 0, 0, 7, 8, 9, 10, 11, 12, 40, - 14, 15, 16, 43, 154, 0, 0, 18, 0, 0, - 0, 0, 19, 0, 0, 0, 43, 43, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 227, 0, 43, 230, - 183, 184, 0, 0, 0, 232, 0, 0, 0, 0, - 43, 0, 0, 62, 63, 64, 0, 65, 0, 0, - 0, 66, 0, 0, 0, 0, 66, 236, 237, 0, - 0, 88, 239, 194, 196, 43, 32, 0, 0, 0, - 0, 0, 101, 0, 32, 32, 44, 0, 0, 32, - 32, 32, 0, 0, 0, 32, 44, 44, 44, 0, - 44, 221, 0, 0, 0, 0, 0, 222, 44, 44, - 0, 0, 0, 0, 44, 88, 88, 0, 0, 153, - 0, 0, 101, 0, 0, 44, 0, 0, 0, 156, - 157, 225, 158, 0, 0, 0, 0, 0, 44, 0, - 0, 0, 0, 233, 0, 234, 0, 0, 0, 238, - 0, 0, 0, 44, 0, 182, 0, 0, 44, 44, - 0, 0, 44, 88, 0, 44, 0, 0, 0, 0, - 0, 0, 44, 44, 0, 44, 88, 0, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 158, - 195, 0, 0, 0, 0, 0, 0, 44, 44, 0, - 0, 0, 0, 0, 0, 0, 44, 0, 0, 0, - 0, 88, 0, 91, 80, 0, 0, 0, 0, 44, - 123, 0, 0, 195, 0, 81, 0, 0, 0, 82, - 83, 84, 44, 44, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 0, 147, 0, 226, 0, - 0, 0, 0, 0, 44, 7, 8, 9, 10, 11, - 12, 40, 14, 15, 16, 0, 44, 87, 161, 18, - 0, 5, 6, 0, 19, 0, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 0, 180, 128, - 18, 44, 0, 185, 0, 19, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 0, 24, 25, - 26, 27, 28, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 1, 0, 0, 0, 0, - 0, 220, 7, 49, 50, 51, 11, 12, 52, 14, - 15, 16, 224, 0, 0, 0, 18, 0, 0, 0, - 0, 19, 5, 6, 0, 0, 54, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 0, 0, - 0, 18, 0, 0, 0, 0, 19, 0, 0, 0, - 0, 0, 0, 0, 20, 21, 22, 23, 0, 24, - 25, 26, 27, 28, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 7, 49, 50, 51, 11, 12, 52, - 14, 15, 16, 0, 0, 0, 0, 18, 0, 0, - 0, 0, 19, 122, 0, 0, 0, 54, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 7, 49, 50, - 51, 11, 12, 52, 14, 15, 16, 0, 0, 0, - 0, 18, 0, 0, 0, 0, 19, 5, 6, 0, - 0, 54, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 0, 0, 0, 18, 0, 0, 0, - 0, 19, 231, 0, 0, 0, 0, 0, 0, 20, - 21, 22, 23, 0, 24, 25, 26, 27, 28, 5, - 6, 0, 0, 0, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 0, 0, 0, 18, 0, - 0, 0, 0, 19, 235, 0, 0, 0, 0, 0, - 0, 20, 21, 22, 23, 0, 24, 25, 26, 27, - 28, 5, 6, 0, 0, 0, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 0, 0, 0, - 18, 0, 0, 0, 0, 19, 0, 0, 0, 0, - 0, 0, 0, 20, 21, 22, 23, 0, 24, 25, - 26, 27, 28, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 0, 155, 105, 106, 107, 108, 109, 110, 111, + 7, 48, 134, 36, 135, 5, 36, 40, 40, 44, + 37, 40, 154, 37, 59, 60, 61, 148, 162, 49, + 63, 1, 159, 154, 40, 1, 40, 40, 131, 1, + 83, 97, 37, 14, 82, 1, 85, 66, 130, 86, + 88, 6, 37, 68, 40, 7, 68, 36, 43, 40, + 100, 102, 104, 40, 37, 39, 42, 133, 186, 154, + 1, 89, -2, 40, 82, 40, 1, 185, 14, 37, + 38, 162, 62, 15, 64, 65, 87, 149, 97, 84, + 90, 1, 153, 84, 84, 131, 1, 40, 150, 1, + 92, 82, 91, 153, 82, 40, 40, 201, 132, 155, + 204, 106, 157, 40, 197, 40, 40, 190, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 50, 154, 26, + 126, 127, 128, 188, 51, 187, 0, 15, 40, 153, + 99, 101, 103, 160, 161, 158, 0, 37, 124, 125, + 126, 127, 128, 91, 122, 123, 124, 125, 126, 127, + 128, 106, 191, 106, 164, 0, 0, 0, 40, 0, + 40, 0, 52, 53, 54, 19, 20, 21, 22, 23, + 24, 0, 0, 26, 0, 0, 0, 0, 0, 198, + 0, 0, 0, 0, 0, 0, 202, 55, 153, 0, + 0, 94, 0, 105, 0, 7, 0, 129, 203, 7, + 38, 205, 0, 15, 0, 0, 106, 0, 164, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 0, 0, 0, 0, 0, 0, 0, 156, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 38, 0, 26, + 15, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 184, 0, 50, 0, 0, 0, 0, 0, 0, 51, + 0, 0, 15, 109, 0, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 95, 0, 26, 110, 193, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 0, 216, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 0, 0, 191, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 219, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 0, 0, 228, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 0, 7, 49, 50, 51, - 11, 12, 52, 14, 15, 16, 0, 197, 0, 0, - 18, 0, 0, 0, 0, 19, 53, 0, 0, 0, - 54, 7, 49, 50, 51, 11, 12, 92, 14, 15, - 16, 0, 0, 0, 0, 18, 0, 0, 0, 0, - 19, 0, 0, 0, 0, 54, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 0, 0, - 18, 99, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 0, 0, - 18, 89, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 151, 0, - 18, 0, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 152, 0, - 18, 0, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 190, 0, - 18, 0, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 40, 14, 15, 16, 0, 0, 0, 0, - 18, 0, 0, 0, 0, 19, 7, 8, 9, 10, - 11, 12, 0, 14, 15, 16, 0, 0, 0, 0, - 18, 0, 0, 0, 0, 19, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121 + 122, 123, 124, 125, 126, 127, 128, 52, 53, 54, + 19, 20, 21, 22, 23, 24, 0, 50, 26, 0, + 0, 0, 0, 0, 51, 0, 200, 15, 0, 1, + 0, 9, 55, 10, 11, 12, 13, 14, 93, 15, + 0, 0, 110, 0, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 52, 53, 54, 19, 20, 21, 22, 23, + 24, 0, 15, 26, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 0, 25, 26, 0, 55, 0, 0, + 0, 27, 28, 29, 30, 31, 1, 0, 9, 0, + 10, 11, 12, 13, 14, 0, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 0, 0, 26, 0, + 0, 0, 0, 0, 0, 98, 0, 0, 15, 0, + 163, 0, 0, 0, 0, 0, 0, 38, 0, 0, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 0, 25, 26, 0, 0, 0, 0, 0, 27, 28, + 29, 30, 31, 52, 53, 54, 19, 20, 21, 22, + 23, 24, 0, 0, 26, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 194, 0, 26, 0, 55, 0, + 67, 38, 0, 0, 15, 68, 0, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 38, 0, + 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, + 38, 0, 0, 15, 0, 0, 0, 0, 0, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 0, 0, + 26, 80, 81, 82, 0, 0, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 84, 196, 26, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 0, 0, 26, + 110, 0, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 189, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 110, 0, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 110, 0, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 110, 192, 111, 112, 113, 114, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 199, 110, 195, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 110, 0, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128 }; static const yytype_int16 yycheck[] = { - 3, 3, 45, 29, 3, 8, 9, 10, 3, 0, - 13, 35, 36, 59, 41, 42, 41, 42, 41, 41, - 23, 24, 25, 41, 27, 54, 29, 46, 50, 54, - 52, 52, 35, 36, 60, 61, 58, 58, 41, 50, - 45, 65, 45, 60, 48, 72, 49, 50, 51, 52, - 48, 50, 61, 48, 0, 68, 80, 60, 61, 32, - 33, 34, 65, 159, 90, 30, 31, 32, 33, 34, - 66, 17, -1, -1, 20, 21, -1, 80, 49, 50, - 51, -1, 85, 86, 30, 131, 89, 90, -1, 92, - -1, -1, -1, -1, -1, -1, 99, 100, -1, 102, - 124, 3, -1, -1, 130, -1, 132, -1, 54, 28, - 29, 30, 31, 32, 33, 34, 62, 63, 64, -1, - 66, 124, 125, -1, -1, -1, -1, 130, -1, 132, - 133, -1, -1, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 146, 90, -1, -1, 49, -1, -1, - -1, -1, 54, -1, -1, -1, 159, 160, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 219, -1, 181, 225, - 126, 127, -1, -1, -1, 228, -1, -1, -1, -1, - 193, -1, -1, 23, 24, 25, -1, 27, -1, -1, - -1, 227, -1, -1, -1, -1, 232, 233, 234, -1, - -1, 41, 238, 159, 160, 218, 219, -1, -1, -1, - -1, -1, 52, -1, 227, 228, 13, -1, -1, 232, - 233, 234, -1, -1, -1, 238, 23, 24, 25, -1, - 27, 187, -1, -1, -1, -1, -1, 193, 35, 36, - -1, -1, -1, -1, 41, 85, 86, -1, -1, 89, - -1, -1, 92, -1, -1, 52, -1, -1, -1, 99, - 100, 217, 102, -1, -1, -1, -1, -1, 65, -1, - -1, -1, -1, 229, -1, 231, -1, -1, -1, 235, - -1, -1, -1, 80, -1, 125, -1, -1, 85, 86, - -1, -1, 89, 133, -1, 92, -1, -1, -1, -1, - -1, -1, 99, 100, -1, 102, 146, -1, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 159, - 160, -1, -1, -1, -1, -1, -1, 124, 125, -1, - -1, -1, -1, -1, -1, -1, 133, -1, -1, -1, - -1, 181, -1, 48, 41, -1, -1, -1, -1, 146, - 55, -1, -1, 193, -1, 52, -1, -1, -1, 56, - 57, 58, 159, 160, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, -1, 81, -1, 218, -1, - -1, -1, -1, -1, 181, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, -1, 193, 47, 103, 49, - -1, 30, 31, -1, 54, -1, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, -1, 123, 48, - 49, 218, -1, 128, -1, 54, -1, -1, -1, -1, - -1, -1, -1, 62, 63, 64, 65, -1, 67, 68, - 69, 70, 71, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 3, -1, -1, -1, -1, - -1, 186, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 197, -1, -1, -1, 49, -1, -1, -1, - -1, 54, 30, 31, -1, -1, 59, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, - -1, 49, -1, -1, -1, -1, 54, -1, -1, -1, - -1, -1, -1, -1, 62, 63, 64, 65, -1, 67, - 68, 69, 70, 71, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 3, 14, 65, 5, 67, 0, 8, 9, 10, 12, + 5, 13, 84, 8, 16, 17, 18, 11, 107, 14, + 27, 4, 95, 95, 26, 4, 28, 29, 58, 4, + 37, 51, 27, 12, 64, 4, 39, 32, 11, 42, + 43, 0, 37, 16, 46, 48, 16, 49, 14, 51, + 52, 53, 54, 55, 49, 9, 10, 64, 131, 131, + 4, 8, 0, 65, 64, 67, 4, 130, 12, 64, + 11, 160, 26, 14, 28, 29, 59, 71, 98, 58, + 30, 4, 84, 58, 58, 58, 4, 89, 83, 4, + 13, 64, 46, 95, 64, 97, 98, 15, 65, 7, + 15, 55, 59, 105, 190, 107, 108, 58, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 4, 190, 60, + 46, 47, 48, 30, 11, 132, -1, 14, 130, 131, + 52, 53, 54, 105, 75, 89, -1, 132, 44, 45, + 46, 47, 48, 97, 42, 43, 44, 45, 46, 47, + 48, 105, 155, 107, 108, -1, -1, -1, 160, -1, + 162, -1, 49, 50, 51, 52, 53, 54, 55, 56, + 57, -1, -1, 60, -1, -1, -1, -1, -1, 192, + -1, -1, -1, -1, -1, -1, 199, 74, 190, -1, + -1, 50, -1, 4, -1, 198, -1, 56, 201, 202, + 11, 204, -1, 14, -1, -1, 160, -1, 162, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, -1, -1, -1, -1, -1, -1, -1, 87, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 11, -1, 60, + 14, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, -1, 4, -1, -1, -1, -1, -1, -1, 11, + -1, -1, 14, 15, -1, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, -1, 60, 29, 157, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, -1, -1, -1, -1, 49, -1, -1, - -1, -1, 54, 55, -1, -1, -1, 59, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, -1, -1, -1, - -1, 49, -1, -1, -1, -1, 54, 30, 31, -1, - -1, 59, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, -1, -1, -1, 49, -1, -1, -1, - -1, 54, 55, -1, -1, -1, -1, -1, -1, 62, - 63, 64, 65, -1, 67, 68, 69, 70, 71, 30, - 31, -1, -1, -1, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, -1, -1, -1, 49, -1, - -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, - -1, 62, 63, 64, 65, -1, 67, 68, 69, 70, - 71, 30, 31, -1, -1, -1, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, - 49, -1, -1, -1, -1, 54, -1, -1, -1, -1, - -1, -1, -1, 62, 63, 64, 65, -1, 67, 68, - 69, 70, 71, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, -1, 55, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - -1, 55, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, -1, -1, 53, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 48, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, -1, -1, 48, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, -1, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, 47, -1, -1, - 49, -1, -1, -1, -1, 54, 55, -1, -1, -1, - 59, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, -1, -1, -1, -1, 49, -1, -1, -1, -1, - 54, -1, -1, -1, -1, 59, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, -1, -1, - 49, 50, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, -1, -1, - 49, 50, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, 47, -1, - 49, -1, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, 47, -1, - 49, -1, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, 47, -1, - 49, -1, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, -1, -1, -1, -1, - 49, -1, -1, -1, -1, 54, 35, 36, 37, 38, - 39, 40, -1, 42, 43, 44, -1, -1, -1, -1, - 49, -1, -1, -1, -1, 54, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 4, 60, -1, + -1, -1, -1, -1, 11, -1, 195, 14, -1, 4, + -1, 6, 74, 8, 9, 10, 11, 12, 13, 14, + -1, -1, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, -1, 14, 60, 49, 50, 51, 52, 53, 54, + 55, 56, 57, -1, 59, 60, -1, 74, -1, -1, + -1, 66, 67, 68, 69, 70, 4, -1, 6, -1, + 8, 9, 10, 11, 12, -1, 14, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, -1, 60, -1, + -1, -1, -1, -1, -1, 11, -1, -1, 14, -1, + 4, -1, -1, -1, -1, -1, -1, 11, -1, -1, + 14, 49, 50, 51, 52, 53, 54, 55, 56, 57, + -1, 59, 60, -1, -1, -1, -1, -1, 66, 67, + 68, 69, 70, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, -1, 60, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 4, -1, 60, -1, 74, -1, + 11, 11, -1, -1, 14, 16, -1, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 11, -1, + -1, 14, -1, -1, -1, -1, -1, -1, -1, -1, + 11, -1, -1, 14, -1, -1, -1, -1, -1, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, -1, + 60, 62, 63, 64, -1, -1, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 15, 60, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, -1, 60, + 29, -1, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 17, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 29, 59, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 59, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 29, -1, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of state STATE-NUM. */ static const yytype_int8 yystos[] = { - 0, 3, 76, 90, 0, 30, 31, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 49, 54, - 62, 63, 64, 65, 67, 68, 69, 70, 71, 77, - 78, 79, 85, 86, 90, 41, 41, 85, 85, 85, - 41, 82, 84, 85, 87, 90, 41, 42, 54, 36, - 37, 38, 41, 55, 59, 80, 81, 85, 87, 90, - 90, 54, 84, 84, 84, 84, 78, 48, 90, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 41, 52, 56, 57, 58, 82, 82, 47, 84, 50, - 77, 80, 41, 81, 85, 81, 85, 81, 85, 50, - 83, 84, 90, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 55, 80, 41, 50, 79, 78, 48, 78, - 90, 90, 90, 82, 90, 80, 80, 80, 80, 80, - 80, 80, 80, 80, 80, 80, 82, 80, 41, 42, - 72, 47, 47, 84, 90, 55, 84, 84, 84, 88, - 89, 80, 90, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 80, 82, 84, 90, 90, 80, 48, 78, 79, 78, - 47, 53, 46, 89, 90, 84, 90, 47, 80, 80, - 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, - 80, 80, 80, 80, 80, 80, 55, 61, 68, 48, - 80, 90, 90, 60, 80, 90, 84, 77, 48, 66, - 79, 55, 77, 90, 90, 55, 78, 78, 90, 78 + 0, 4, 77, 78, 79, 96, 0, 79, 96, 6, + 8, 9, 10, 11, 12, 14, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 59, 60, 66, 67, 68, + 69, 70, 80, 81, 82, 83, 92, 96, 11, 91, + 92, 93, 91, 14, 79, 86, 88, 91, 78, 96, + 4, 11, 49, 50, 51, 74, 84, 85, 92, 92, + 92, 92, 91, 81, 91, 91, 96, 11, 16, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 62, 63, 64, 81, 58, 79, 79, 59, 79, 8, + 30, 91, 13, 13, 84, 58, 87, 88, 11, 85, + 92, 85, 92, 85, 92, 4, 91, 94, 95, 15, + 29, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 84, + 11, 58, 65, 81, 86, 86, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 11, 71, + 96, 89, 90, 92, 93, 7, 84, 59, 91, 89, + 94, 75, 95, 4, 91, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 86, 89, 81, 30, 17, + 58, 79, 59, 84, 4, 30, 15, 90, 78, 59, + 84, 15, 78, 79, 15, 79 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_int8 yyr1[] = { - 0, 75, 76, 77, 77, 77, 78, 78, 78, 78, - 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, - 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, - 78, 78, 78, 78, 78, 78, 78, 79, 80, 80, + 0, 76, 77, 77, 78, 78, 79, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, - 81, 81, 81, 81, 81, 81, 81, 81, 82, 82, - 82, 83, 83, 84, 84, 84, 85, 85, 85, 85, - 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, - 85, 85, 85, 85, 86, 86, 87, 88, 88, 88, - 89, 89, 90, 90 + 80, 81, 81, 81, 82, 82, 82, 83, 83, 83, + 83, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 85, 85, 85, 85, 85, 85, + 85, 85, 86, 86, 87, 88, 88, 89, 89, 90, + 90, 91, 91, 91, 92, 92, 92, 92, 92, 92, + 92, 92, 92, 92, 92, 92, 92, 92, 92, 93, + 94, 94, 94, 94, 95, 95, 96, 96 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ static const yytype_int8 yyr2[] = { - 0, 2, 2, 3, 2, 1, 3, 4, 4, 4, - 1, 5, 8, 4, 10, 9, 6, 7, 4, 1, - 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 2, 2, 2, 5, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 5, 1, 1, 1, - 2, 3, 2, 2, 2, 3, 3, 5, 0, 2, - 1, 2, 1, 1, 1, 3, 4, 2, 2, 3, - 3, 3, 4, 1, 1, 5, 1, 3, 2, 2, - 2, 2, 1, 1, 1, 1, 1, 0, 3, 2, - 1, 2, 0, 1 + 0, 2, 1, 1, 1, 2, 3, 3, 4, 1, + 1, 1, 4, 1, 1, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, + 1, 3, 3, 3, 3, 5, 3, 3, 9, 8, + 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 2, 1, 1, 1, 2, 3, 2, 2, 2, 3, + 3, 3, 0, 1, 1, 1, 2, 1, 3, 1, + 1, 1, 1, 3, 2, 3, 3, 4, 1, 1, + 1, 5, 1, 3, 2, 2, 2, 1, 1, 1, + 0, 3, 2, 2, 1, 2, 0, 1 }; @@ -1104,6 +1044,32 @@ enum { YYENOMEM = -2 }; Use YYerror or YYUNDEF. */ #define YYERRCODE YYUNDEF +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) + /* Enable debugging if requested. */ #if YYDEBUG @@ -1120,6 +1086,63 @@ do { \ } while (0) +/* YYLOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +# ifndef YYLOCATION_PRINT + +# if defined YY_LOCATION_PRINT + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YYLOCATION_PRINT(File, Loc) YY_LOCATION_PRINT(File, *(Loc)) + +# elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL + +/* Print *YYLOCP on YYO. Private, do not rely on its existence. */ + +YY_ATTRIBUTE_UNUSED +static int +yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp) +{ + int res = 0; + int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0; + if (0 <= yylocp->first_line) + { + res += YYFPRINTF (yyo, "%d", yylocp->first_line); + if (0 <= yylocp->first_column) + res += YYFPRINTF (yyo, ".%d", yylocp->first_column); + } + if (0 <= yylocp->last_line) + { + if (yylocp->first_line < yylocp->last_line) + { + res += YYFPRINTF (yyo, "-%d", yylocp->last_line); + if (0 <= end_col) + res += YYFPRINTF (yyo, ".%d", end_col); + } + else if (0 <= end_col && yylocp->first_column < end_col) + res += YYFPRINTF (yyo, "-%d", end_col); + } + return res; +} + +# define YYLOCATION_PRINT yy_location_print_ + + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT(File, Loc) YYLOCATION_PRINT(File, &(Loc)) + +# else + +# define YYLOCATION_PRINT(File, Loc) ((void) 0) + /* Temporary convenience wrapper in case some people defined the + undocumented and private YY_LOCATION_PRINT macros. */ +# define YY_LOCATION_PRINT YYLOCATION_PRINT + +# endif +# endif /* !defined YYLOCATION_PRINT */ # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ @@ -1128,7 +1151,7 @@ do { \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ - Kind, Value); \ + Kind, Value, Location); \ YYFPRINTF (stderr, "\n"); \ } \ } while (0) @@ -1140,10 +1163,11 @@ do { \ static void yy_symbol_value_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp) { FILE *yyoutput = yyo; YY_USE (yyoutput); + YY_USE (yylocationp); if (!yyvaluep) return; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN @@ -1158,12 +1182,14 @@ yy_symbol_value_print (FILE *yyo, static void yy_symbol_print (FILE *yyo, - yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp) { YYFPRINTF (yyo, "%s %s (", yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); - yy_symbol_value_print (yyo, yykind, yyvaluep); + YYLOCATION_PRINT (yyo, yylocationp); + YYFPRINTF (yyo, ": "); + yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp); YYFPRINTF (yyo, ")"); } @@ -1196,7 +1222,7 @@ do { \ `------------------------------------------------*/ static void -yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule) { int yylno = yyrline[yyrule]; @@ -1210,7 +1236,8 @@ yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), - &yyvsp[(yyi + 1) - (yynrhs)]); + &yyvsp[(yyi + 1) - (yynrhs)], + &(yylsp[(yyi + 1) - (yynrhs)])); YYFPRINTF (stderr, "\n"); } } @@ -1218,7 +1245,7 @@ yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ - yy_reduce_print (yyssp, yyvsp, Rule); \ + yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \ } while (0) /* Nonzero means print parse trace. It is left uninitialized so that @@ -1254,6 +1281,7 @@ typedef struct { yy_state_t *yyssp; yysymbol_kind_t yytoken; + YYLTYPE *yylloc; } yypcontext_t; /* Put in YYARG at most YYARGN of the expected tokens given the @@ -1526,9 +1554,10 @@ yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, static void yydestruct (const char *yymsg, - yysymbol_kind_t yykind, YYSTYPE *yyvaluep) + yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp) { YY_USE (yyvaluep); + YY_USE (yylocationp); if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); @@ -1544,6 +1573,12 @@ int yychar; /* The semantic value of the lookahead symbol. */ YYSTYPE yylval; +/* Location data for the lookahead symbol. */ +YYLTYPE yylloc +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL + = { 1, 1, 1, 1 } +# endif +; /* Number of syntax errors so far. */ int yynerrs; @@ -1577,6 +1612,11 @@ yyparse (void) YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvsp = yyvs; + /* The location stack: array, bottom, top. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp = yyls; + int yyn; /* The return value of yyparse. */ int yyresult; @@ -1585,13 +1625,17 @@ yyparse (void) /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; + YYLTYPE yyloc; + + /* The locations where the error started and ended. */ + YYLTYPE yyerror_range[3]; /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ @@ -1601,6 +1645,7 @@ yyparse (void) yychar = YYEMPTY; /* Cause a token to be read. */ + yylsp[0] = yylloc; goto yysetstate; @@ -1639,6 +1684,7 @@ yysetstate: memory. */ yy_state_t *yyss1 = yyss; YYSTYPE *yyvs1 = yyvs; + YYLTYPE *yyls1 = yyls; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a @@ -1647,9 +1693,11 @@ yysetstate: yyoverflow (YY_("memory exhausted"), &yyss1, yysize * YYSIZEOF (*yyssp), &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yyls1, yysize * YYSIZEOF (*yylsp), &yystacksize); yyss = yyss1; yyvs = yyvs1; + yyls = yyls1; } # else /* defined YYSTACK_RELOCATE */ /* Extend the stack our own way. */ @@ -1668,6 +1716,7 @@ yysetstate: YYNOMEM; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); + YYSTACK_RELOCATE (yyls_alloc, yyls); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); @@ -1676,6 +1725,7 @@ yysetstate: yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; + yylsp = yyls + yysize - 1; YY_IGNORE_USELESS_CAST_BEGIN YYDPRINTF ((stderr, "Stack size increased to %ld\n", @@ -1715,9 +1765,9 @@ yybackup: yychar = yylex (); } - if (yychar <= END) + if (yychar <= TOKEN_EOF) { - yychar = END; + yychar = TOKEN_EOF; yytoken = YYSYMBOL_YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } @@ -1729,6 +1779,7 @@ yybackup: loop in error recovery. */ yychar = YYUNDEF; yytoken = YYSYMBOL_YYerror; + yyerror_range[1] = yylloc; goto yyerrlab1; } else @@ -1762,6 +1813,7 @@ yybackup: YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END + *++yylsp = yylloc; /* Discard the shifted token. */ yychar = YYEMPTY; @@ -1795,581 +1847,613 @@ yyreduce: GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; - + /* Default location. */ + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); + yyerror_range[1] = yyloc; YY_REDUCE_PRINT (yyn); switch (yyn) { - case 2: /* program: newline statement_list */ -#line 108 "E:/Src/openmohaa/code/parser/bison_source.txt" - { parsedata.val = node1( sval_statement_list, (yyvsp[0].s.val) ); } -#line 1806 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 3: /* statement_list: statement_list statement newline */ -#line 112 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = append_node( (yyvsp[-2].s.val), (yyvsp[-1].s.val) ); } -#line 1812 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 4: /* statement_list: statement newline */ -#line 114 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = linked_list_end( (yyvsp[-1].s.val) ); } -#line 1818 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 5: /* statement_list: newline */ -#line 115 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node0( sval_none ); } -#line 1824 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 6: /* statement: TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON */ -#line 119 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_label, (yyvsp[-2].s).val, (yyvsp[-1].s.val), YYLLOC ); } -#line 1830 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 7: /* statement: TOKEN_PLUS TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON */ -#line 120 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_label, (yyvsp[-2].s).val, (yyvsp[-1].s.val), YYLLOC ); } -#line 1836 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 8: /* statement: TOKEN_MINUS TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON */ -#line 121 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_privatelabel, (yyvsp[-2].s).val, (yyvsp[-1].s.val), YYLLOC ); } -#line 1842 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 9: /* statement: TOKEN_CASE prim_expr event_parameter_list TOKEN_COLON */ -#line 122 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_case, (yyvsp[-2].s.val), (yyvsp[-1].s.val), YYLLOC ); } -#line 1848 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 11: /* statement: TOKEN_IF prim_expr newline statement newline */ -#line 124 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_if, (yyvsp[-3].s.val), (yyvsp[-1].s.val), YYLLOC ); } -#line 1854 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 12: /* statement: TOKEN_IF prim_expr newline statement newline TOKEN_ELSE newline statement */ -#line 125 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_ifelse, (yyvsp[-6].s.val), (yyvsp[-4].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 2: /* program: statement_list */ +#line 128 "E:/Src/openmohaa/code/parser/bison_source.txt" + { parsedata.val = node1(ENUM_statement_list, (yyvsp[0].s.val)); } #line 1860 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 13: /* statement: TOKEN_WHILE prim_expr newline statement */ -#line 126 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_while, (yyvsp[-2].s.val), (yyvsp[0].s.val), node0( sval_none ), YYLLOC ); } + case 3: /* program: line_opt */ +#line 129 "E:/Src/openmohaa/code/parser/bison_source.txt" + { parsedata.val = node0(ENUM_NOP); } #line 1866 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 14: /* statement: TOKEN_FOR TOKEN_LPAREN statement TOKEN_SEMICOLON expr TOKEN_SEMICOLON statement_list TOKEN_RPAREN newline statement */ -#line 128 "E:/Src/openmohaa/code/parser/bison_source.txt" - { - sval_u while_stmt = node4( sval_while, (yyvsp[-5].s.val), (yyvsp[0].s.val), node1( sval_statement_list, (yyvsp[-3].s.val) ), YYLLOC ); - (yyval.s.val) = node1( sval_statement_list, append_node( linked_list_end( (yyvsp[-7].s.val) ), while_stmt ) ); - } -#line 1875 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 15: /* statement: TOKEN_FOR TOKEN_LPAREN TOKEN_SEMICOLON expr TOKEN_SEMICOLON statement_list TOKEN_RPAREN newline statement */ + case 4: /* statement_list: statement */ #line 133 "E:/Src/openmohaa/code/parser/bison_source.txt" - { - (yyval.s.val) = node4( sval_while, (yyvsp[-5].s.val), (yyvsp[0].s.val), node1( sval_statement_list, (yyvsp[-3].s.val) ), YYLLOC ); - } -#line 1883 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = linked_list_end((yyvsp[0].s.val)); } +#line 1872 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 16: /* statement: TOKEN_DO newline statement newline TOKEN_WHILE prim_expr */ -#line 136 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_do, (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 1889 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 5: /* statement_list: statement_list statement */ +#line 134 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = append_node((yyvsp[-1].s.val), (yyvsp[0].s.val)); } +#line 1878 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 17: /* statement: TOKEN_TRY newline compound_statement newline TOKEN_CATCH newline compound_statement */ -#line 137 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_catch, (yyvsp[-4].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 1895 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 18: /* statement: TOKEN_SWITCH prim_expr newline compound_statement */ + case 6: /* statement: line_opt statement_declaration line_opt */ #line 138 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_switch, (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 1901 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = (yyvsp[-1].s.val); } +#line 1884 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 19: /* statement: TOKEN_BREAK */ -#line 139 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_break, YYLLOC ); } -#line 1907 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 7: /* statement_declaration: TOKEN_IDENTIFIER event_parameter_list TOKEN_COLON */ +#line 142 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_labeled_statement, (yyvsp[-2].s.val), (yyvsp[-1].s.val), TOKPOS((yylsp[-2]))); } +#line 1890 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 20: /* statement: TOKEN_CONTINUE */ -#line 140 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_continue, YYLLOC ); } -#line 1913 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 21: /* statement: TOKEN_IDENTIFIER event_parameter_list */ -#line 141 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_cmd, (yyvsp[-1].s).val, node1( sval_none, (yyvsp[0].s.val) ), node_pos( (yyvsp[-1].s).sourcePos ) ); } -#line 1919 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 22: /* statement: nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list */ + case 8: /* statement_declaration: TOKEN_CASE prim_expr event_parameter_list TOKEN_COLON */ #line 143 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_cmd_method, (yyvsp[-2].s.val), (yyvsp[-1].s).val, node1( sval_none, (yyvsp[0].s.val) ), node_pos( (yyvsp[-1].s).sourcePos ) ); } -#line 1925 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_int_labeled_statement, (yyvsp[-2].s.val), (yyvsp[-1].s.val), TOKPOS((yylsp[-3]))); } +#line 1896 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 23: /* statement: nonident_prim_expr TOKEN_ASSIGNMENT expr */ -#line 145 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 1931 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 24: /* statement: nonident_prim_expr TOKEN_PLUS_EQUALS expr */ -#line 146 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_PLUS ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1937 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 25: /* statement: nonident_prim_expr TOKEN_MINUS_EQUALS expr */ + case 12: /* statement_declaration: TOKEN_TRY compound_statement TOKEN_CATCH compound_statement */ #line 147 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_MINUS ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1943 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_try, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-3]))); } +#line 1902 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 26: /* statement: nonident_prim_expr TOKEN_MULTIPLY_EQUALS expr */ + case 13: /* statement_declaration: TOKEN_BREAK */ #line 148 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_MULTIPLY ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1949 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node1(ENUM_break, TOKPOS((yylsp[0]))); } +#line 1908 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 27: /* statement: nonident_prim_expr TOKEN_DIVIDE_EQUALS expr */ + case 14: /* statement_declaration: TOKEN_CONTINUE */ #line 149 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_DIVIDE ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1955 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node1(ENUM_continue, TOKPOS((yylsp[0]))); } +#line 1914 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 28: /* statement: nonident_prim_expr TOKEN_MODULUS_EQUALS expr */ + case 15: /* statement_declaration: TOKEN_IDENTIFIER event_parameter_list */ #line 150 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_PERCENTAGE ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1961 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_cmd_event_statement, (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 1920 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 29: /* statement: nonident_prim_expr TOKEN_AND_EQUALS expr */ + case 16: /* statement_declaration: nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list */ #line 151 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_BITWISE_AND ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1967 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node4(ENUM_method_event_statement, (yyvsp[-2].s.val), (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 1926 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 30: /* statement: nonident_prim_expr TOKEN_EXCL_OR_EQUALS expr */ + case 17: /* statement_declaration: nonident_prim_expr TOKEN_ASSIGNMENT expr */ #line 152 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_BITWISE_EXCL_OR ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1973 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 1932 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 31: /* statement: nonident_prim_expr TOKEN_OR_EQUALS expr */ + case 18: /* statement_declaration: nonident_prim_expr TOKEN_PLUS_EQUALS expr */ #line 153 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_BITWISE_OR ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1979 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_PLUS), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1938 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 32: /* statement: nonident_prim_expr TOKEN_SHIFT_LEFT_EQUALS expr */ + case 19: /* statement_declaration: nonident_prim_expr TOKEN_MINUS_EQUALS expr */ #line 154 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_SHIFT_LEFT ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1985 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_MINUS), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1944 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 33: /* statement: nonident_prim_expr TOKEN_SHIFT_RIGHT_EQUALS expr */ + case 20: /* statement_declaration: nonident_prim_expr TOKEN_MULTIPLY_EQUALS expr */ #line 155 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-2].s.val), node4( sval_operation, node1b( OP_BIN_SHIFT_RIGHT ), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ), YYLLOC ); } -#line 1991 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_MULTIPLY), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1950 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 34: /* statement: nonident_prim_expr TOKEN_INCREMENT */ + case 21: /* statement_declaration: nonident_prim_expr TOKEN_DIVIDE_EQUALS expr */ #line 156 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-1].s.val), node3( sval_func1, node1b( OP_UN_INC ), (yyvsp[-1].s.val), YYLLOC ), YYLLOC ); } -#line 1997 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_DIVIDE), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1956 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 35: /* statement: nonident_prim_expr TOKEN_DECREMENT */ + case 22: /* statement_declaration: nonident_prim_expr TOKEN_MODULUS_EQUALS expr */ #line 157 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_assignment, (yyvsp[-1].s.val), node3( sval_func1, node1b( OP_UN_DEC ), (yyvsp[-1].s.val), YYLLOC ), YYLLOC ); } -#line 2003 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_PERCENTAGE), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1962 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 37: /* compound_statement: TOKEN_LBRACKET newline statement_list newline TOKEN_RBRACKET */ + case 23: /* statement_declaration: nonident_prim_expr TOKEN_AND_EQUALS expr */ +#line 158 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_AND), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1968 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 24: /* statement_declaration: nonident_prim_expr TOKEN_EXCL_OR_EQUALS expr */ +#line 159 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_EXCL_OR), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1974 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 25: /* statement_declaration: nonident_prim_expr TOKEN_OR_EQUALS expr */ +#line 160 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_BITWISE_OR), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1980 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 26: /* statement_declaration: nonident_prim_expr TOKEN_SHIFT_LEFT_EQUALS expr */ +#line 161 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_SHIFT_LEFT), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1986 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 27: /* statement_declaration: nonident_prim_expr TOKEN_SHIFT_RIGHT_EQUALS expr */ #line 162 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_statement_list, (yyvsp[-2].s.val) ); } -#line 2009 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-2].s.val), node4(ENUM_func2_expr, node1b(OP_BIN_SHIFT_RIGHT), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))), TOKPOS((yylsp[-1]))); } +#line 1992 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 38: /* expr: expr TOKEN_LOGICAL_AND newline expr */ -#line 166 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_and, (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2015 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 28: /* statement_declaration: nonident_prim_expr TOKEN_INCREMENT */ +#line 163 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-1].s.val), node3(ENUM_func1_expr, node1b(OP_UN_INC), (yyvsp[-1].s.val), TOKPOS((yylsp[0]))), TOKPOS((yylsp[0]))); } +#line 1998 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 39: /* expr: expr TOKEN_LOGICAL_OR newline expr */ -#line 167 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_or, (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2021 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 29: /* statement_declaration: nonident_prim_expr TOKEN_DECREMENT */ +#line 164 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_assignment_statement, (yyvsp[-1].s.val), node3(ENUM_func1_expr, node1b(OP_UN_DEC), (yyvsp[-1].s.val), TOKPOS((yylsp[0]))), TOKPOS((yylsp[0]))); } +#line 2004 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 40: /* expr: expr TOKEN_BITWISE_AND newline expr */ -#line 168 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_BITWISE_AND ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2027 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 30: /* statement_declaration: TOKEN_SEMICOLON */ +#line 165 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node0(ENUM_NOP); } +#line 2010 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 41: /* expr: expr TOKEN_BITWISE_EXCL_OR newline expr */ -#line 169 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_BITWISE_EXCL_OR ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2033 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 42: /* expr: expr TOKEN_BITWISE_OR newline expr */ -#line 170 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_BITWISE_OR ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2039 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 43: /* expr: expr TOKEN_EQUALITY newline expr */ + case 31: /* compound_statement: TOKEN_LEFT_BRACES statement_list TOKEN_RIGHT_BRACES */ #line 171 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_EQUALITY ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2045 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node1(ENUM_statement_list, (yyvsp[-1].s.val)); } +#line 2016 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 44: /* expr: expr TOKEN_INEQUALITY newline expr */ + case 32: /* compound_statement: TOKEN_LEFT_BRACES line_opt TOKEN_RIGHT_BRACES */ #line 172 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_INEQUALITY ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2051 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = node0(ENUM_NOP); } +#line 2022 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 45: /* expr: expr TOKEN_LESS_THAN newline expr */ + case 33: /* compound_statement: line_opt compound_statement line_opt */ #line 173 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_LESS_THAN ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2057 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + { (yyval.s.val) = (yyvsp[-1].s.val); } +#line 2028 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 46: /* expr: expr TOKEN_GREATER_THAN newline expr */ -#line 174 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_GREATER_THAN ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } -#line 2063 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 34: /* selection_statement: TOKEN_IF prim_expr statement */ +#line 177 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_if_statement, (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-2]))); } +#line 2034 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 47: /* expr: expr TOKEN_LESS_THAN_OR_EQUAL newline expr */ -#line 175 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_LESS_THAN_OR_EQUAL ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 35: /* selection_statement: TOKEN_IF prim_expr statement TOKEN_ELSE statement */ +#line 178 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4(ENUM_if_else_statement, (yyvsp[-3].s.val), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-4]))); } +#line 2040 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 36: /* selection_statement: TOKEN_SWITCH prim_expr compound_statement */ +#line 179 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_switch, (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-2]))); } +#line 2046 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 37: /* iteration_statement: TOKEN_WHILE prim_expr statement */ +#line 183 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4(ENUM_while_statement, (yyvsp[-1].s.val), (yyvsp[0].s.val), node0(ENUM_NOP), TOKPOS((yylsp[-2]))); } +#line 2052 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 38: /* iteration_statement: TOKEN_FOR TOKEN_LEFT_BRACKET statement TOKEN_SEMICOLON expr TOKEN_SEMICOLON statement_list TOKEN_RIGHT_BRACKET statement */ +#line 185 "E:/Src/openmohaa/code/parser/bison_source.txt" + { + sval_t while_stmt = node4(ENUM_while_statement, (yyvsp[-4].s.val), (yyvsp[0].s.val), node1(ENUM_statement_list, (yyvsp[-2].s.val)), TOKPOS((yylsp[-8]))); + (yyval.s.val) = node1(ENUM_statement_list, append_node(linked_list_end((yyvsp[-6].s.val)), while_stmt)); + } +#line 2061 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 39: /* iteration_statement: TOKEN_FOR TOKEN_LEFT_BRACKET TOKEN_SEMICOLON expr TOKEN_SEMICOLON statement_list TOKEN_RIGHT_BRACKET statement */ +#line 190 "E:/Src/openmohaa/code/parser/bison_source.txt" + { + (yyval.s.val) = node4(ENUM_while_statement, (yyvsp[-4].s.val), (yyvsp[0].s.val), node1(ENUM_statement_list, (yyvsp[-2].s.val)), TOKPOS((yylsp[-7]))); + } #line 2069 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 48: /* expr: expr TOKEN_GREATER_THAN_OR_EQUAL newline expr */ -#line 176 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_GREATER_THAN_OR_EQUAL ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 40: /* iteration_statement: TOKEN_DO statement TOKEN_WHILE prim_expr */ +#line 193 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_do, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-3]))); } #line 2075 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 49: /* expr: expr TOKEN_PLUS newline expr */ -#line 177 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_PLUS ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 41: /* expr: expr TOKEN_LOGICAL_AND expr */ +#line 197 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3( ENUM_logical_and, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2081 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 50: /* expr: expr TOKEN_MINUS newline expr */ -#line 178 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_MINUS ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 42: /* expr: expr TOKEN_LOGICAL_OR expr */ +#line 198 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3( ENUM_logical_or, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2087 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 51: /* expr: expr TOKEN_MULTIPLY newline expr */ -#line 179 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_MULTIPLY ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 43: /* expr: expr TOKEN_BITWISE_AND expr */ +#line 199 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_AND ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2093 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 52: /* expr: expr TOKEN_DIVIDE newline expr */ -#line 180 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_DIVIDE ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 44: /* expr: expr TOKEN_BITWISE_OR expr */ +#line 200 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_OR ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2099 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 53: /* expr: expr TOKEN_MODULUS newline expr */ -#line 181 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_PERCENTAGE ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 45: /* expr: expr TOKEN_BITWISE_EXCL_OR expr */ +#line 201 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_BITWISE_EXCL_OR ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2105 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 54: /* expr: expr TOKEN_SHIFT_LEFT newline expr */ -#line 182 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_SHIFT_LEFT ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 46: /* expr: expr TOKEN_EQUALITY expr */ +#line 202 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_EQUALITY ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2111 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 55: /* expr: expr TOKEN_SHIFT_RIGHT newline expr */ -#line 183 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_operation, node1b( OP_BIN_SHIFT_RIGHT ), (yyvsp[-3].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 47: /* expr: expr TOKEN_INEQUALITY expr */ +#line 203 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_INEQUALITY ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2117 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 56: /* expr: expr TOKEN_TERNARY expr TOKEN_COLON expr */ -#line 184 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_ifelse, (yyvsp[-4].s.val), (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 48: /* expr: expr TOKEN_LESS_THAN expr */ +#line 204 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_LESS_THAN ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2123 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 59: /* expr: identifier_prim */ -#line 187 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_string, (yyvsp[0].s).val ); } + case 49: /* expr: expr TOKEN_GREATER_THAN expr */ +#line 205 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_GREATER_THAN ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2129 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 60: /* func_prim_expr: TOKEN_IDENTIFIER event_parameter_list_need */ -#line 191 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_cmd_default_ret, (yyvsp[-1].s).val, node1( sval_none, (yyvsp[0].s.val) ), node_pos( (yyvsp[-1].s).sourcePos ) ); } + case 50: /* expr: expr TOKEN_LESS_THAN_OR_EQUAL expr */ +#line 206 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_LESS_THAN_OR_EQUAL ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2135 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 61: /* func_prim_expr: nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list */ -#line 193 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_cmd_method_ret, (yyvsp[-2].s.val), (yyvsp[-1].s).val, node1( sval_none, (yyvsp[0].s.val) ), node_pos( (yyvsp[-1].s).sourcePos ) ); } + case 51: /* expr: expr TOKEN_GREATER_THAN_OR_EQUAL expr */ +#line 207 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_GREATER_THAN_OR_EQUAL ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2141 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 62: /* func_prim_expr: TOKEN_NEG func_prim_expr */ -#line 195 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_MINUS ), (yyvsp[0].s.val), YYLLOC ); } + case 52: /* expr: expr TOKEN_PLUS expr */ +#line 208 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_PLUS ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2147 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 63: /* func_prim_expr: TOKEN_COMPLEMENT func_prim_expr */ -#line 196 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_COMPLEMENT ), (yyvsp[0].s.val), YYLLOC ); } + case 53: /* expr: expr TOKEN_MINUS expr */ +#line 209 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_MINUS ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2153 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 64: /* func_prim_expr: TOKEN_NOT func_prim_expr */ -#line 197 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node2( sval_not, (yyvsp[0].s.val), YYLLOC ); } + case 54: /* expr: expr TOKEN_MULTIPLY expr */ +#line 210 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_MULTIPLY ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2159 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 65: /* func_prim_expr: TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON prim_expr */ -#line 198 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_constarray, node2( sval_store_string, (yyvsp[-2].s).val, node_pos( (yyvsp[-2].s).sourcePos ) ), (yyvsp[0].s.val), YYLLOC ); } + case 55: /* expr: expr TOKEN_DIVIDE expr */ +#line 211 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_DIVIDE ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2165 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 66: /* func_prim_expr: nonident_prim_expr TOKEN_DOUBLE_COLON prim_expr */ -#line 199 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_constarray, (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 56: /* expr: expr TOKEN_MODULUS expr */ +#line 212 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_PERCENTAGE ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2171 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 67: /* func_prim_expr: TOKEN_MAKEARRAY newline makearray_statement_list newline TOKEN_ENDARRAY */ -#line 200 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_makearray, (yyvsp[-2].s.val) ); } + case 57: /* expr: expr TOKEN_SHIFT_LEFT expr */ +#line 213 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_SHIFT_LEFT ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2177 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 68: /* event_parameter_list: %empty */ -#line 204 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node0( sval_none ); } + case 58: /* expr: expr TOKEN_SHIFT_RIGHT expr */ +#line 214 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_func2_expr, node1b( OP_BIN_SHIFT_RIGHT ), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1])) ); } #line 2183 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 69: /* event_parameter_list: event_parameter_list prim_expr */ -#line 205 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = append_node( (yyvsp[-1].s.val), (yyvsp[0].s.val) ); } + case 59: /* expr: expr TOKEN_TERNARY expr TOKEN_COLON expr */ +#line 215 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4( ENUM_if_else_statement, (yyvsp[-4].s.val), (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-3])) ); } #line 2189 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 70: /* event_parameter_list: prim_expr */ -#line 206 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = linked_list_end( (yyvsp[0].s.val) ); } + case 60: /* expr: TOKEN_EOL expr */ +#line 216 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[0].s.val); } #line 2195 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 71: /* event_parameter_list_need: event_parameter_list_need prim_expr */ -#line 210 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = append_node( (yyvsp[-1].s.val), (yyvsp[0].s.val) ); } + case 63: /* expr: TOKEN_IDENTIFIER */ +#line 219 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_string, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2201 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 72: /* event_parameter_list_need: prim_expr */ -#line 211 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = linked_list_end( (yyvsp[0].s.val) ); } + case 64: /* func_prim_expr: TOKEN_IDENTIFIER event_parameter_list_need */ +#line 223 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_cmd_event_expr, (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2207 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 74: /* prim_expr: identifier_prim */ -#line 216 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_string, (yyvsp[0].s).val ); } + case 65: /* func_prim_expr: nonident_prim_expr TOKEN_IDENTIFIER event_parameter_list */ +#line 224 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4(ENUM_method_event_expr, (yyvsp[-2].s.val), (yyvsp[-1].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2213 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 75: /* prim_expr: prim_expr TOKEN_DOUBLE_COLON prim_expr */ -#line 217 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_constarray, (yyvsp[-2].s.val), (yyvsp[0].s.val), YYLLOC ); } + case 66: /* func_prim_expr: TOKEN_NEG func_prim_expr */ +#line 225 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_MINUS), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2219 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 76: /* nonident_prim_expr: TOKEN_DOLLAR TOKEN_LPAREN expr TOKEN_RPAREN */ -#line 221 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_TARGETNAME ), (yyvsp[-1].s.val), YYLLOC ); } + case 67: /* func_prim_expr: TOKEN_COMPLEMENT func_prim_expr */ +#line 226 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_COMPLEMENT), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2225 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 77: /* nonident_prim_expr: TOKEN_DOLLAR TOKEN_IDENTIFIER */ -#line 222 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_TARGETNAME ), node1( sval_store_string, (yyvsp[0].s).val ), YYLLOC ); } + case 68: /* func_prim_expr: TOKEN_NOT func_prim_expr */ +#line 227 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_bool_not, (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2231 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 78: /* nonident_prim_expr: TOKEN_DOLLAR TOKEN_STRING */ -#line 223 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_TARGETNAME ), node1( sval_store_string, (yyvsp[0].s).val ), YYLLOC ); } -#line 2237 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 69: /* func_prim_expr: TOKEN_IDENTIFIER TOKEN_DOUBLE_COLON const_array_list */ +#line 229 "E:/Src/openmohaa/code/parser/bison_source.txt" + { + (yyval.s.val) = node3(ENUM_const_array_expr, node2(ENUM_string, (yyvsp[-2].s.val), TOKPOS((yylsp[-2]))), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); + } +#line 2239 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 79: /* nonident_prim_expr: nonident_prim_expr TOKEN_PERIOD TOKEN_IDENTIFIER */ -#line 224 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_field, (yyvsp[-2].s.val), (yyvsp[0].s).val, node_pos( (yyvsp[0].s).sourcePos ) ); } -#line 2243 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 70: /* func_prim_expr: nonident_prim_expr TOKEN_DOUBLE_COLON const_array_list */ +#line 233 "E:/Src/openmohaa/code/parser/bison_source.txt" + { + (yyval.s.val) = node3(ENUM_const_array_expr, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); + } +#line 2247 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 80: /* nonident_prim_expr: nonident_prim_expr TOKEN_PERIOD TOKEN_STRING */ -#line 225 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_field, (yyvsp[-2].s.val), (yyvsp[0].s).val, node_pos( (yyvsp[0].s).sourcePos ) ); } -#line 2249 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" - break; - - case 81: /* nonident_prim_expr: nonident_prim_expr TOKEN_PERIOD TOKEN_SIZE */ -#line 226 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_SIZE ), (yyvsp[-2].s.val), YYLLOC ); } + case 71: /* func_prim_expr: TOKEN_MAKEARRAY makearray_statement_list TOKEN_ENDARRAY */ +#line 237 "E:/Src/openmohaa/code/parser/bison_source.txt" + { + (yyval.s.val) = node2(ENUM_makearray, (yyvsp[-1].s.val), TOKPOS((yylsp[-2]))); + } #line 2255 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 82: /* nonident_prim_expr: nonident_prim_expr TOKEN_LSQUARE expr TOKEN_RSQUARE */ -#line 227 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_array, (yyvsp[-3].s.val), (yyvsp[-1].s.val), (yyvsp[-3].s.val) ); } + case 72: /* event_parameter_list: %empty */ +#line 243 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = sval_u{}; } #line 2261 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 83: /* nonident_prim_expr: TOKEN_STRING */ -#line 228 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_string, (yyvsp[0].s).val ); } + case 73: /* event_parameter_list: event_parameter */ +#line 244 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[0].s.val); } #line 2267 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 85: /* nonident_prim_expr: TOKEN_LPAREN expr expr expr TOKEN_RPAREN */ -#line 230 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node4( sval_calc_vector, (yyvsp[-3].s.val), (yyvsp[-2].s.val), (yyvsp[-1].s.val), YYLLOC ); } + case 74: /* event_parameter_list_need: event_parameter */ +#line 248 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[0].s.val); } #line 2273 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 86: /* nonident_prim_expr: TOKEN_LISTENER */ -#line 231 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node2( sval_store_method, (yyvsp[0].s).val, YYLLOC ); } + case 75: /* event_parameter: prim_expr */ +#line 252 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = linked_list_end((yyvsp[0].s.val)); } #line 2279 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 87: /* nonident_prim_expr: TOKEN_LPAREN expr TOKEN_RPAREN */ -#line 232 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = (yyvsp[-1].s.val); } + case 76: /* event_parameter: event_parameter prim_expr */ +#line 253 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = append_node((yyvsp[-1].s.val), (yyvsp[0].s.val)); } #line 2285 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 88: /* nonident_prim_expr: TOKEN_LPAREN TOKEN_RPAREN */ -#line 233 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node0( sval_none ); } + case 77: /* const_array_list: const_array */ +#line 257 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = linked_list_end((yyvsp[0].s.val)); } #line 2291 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 89: /* nonident_prim_expr: TOKEN_NEG nonident_prim_expr */ -#line 234 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_MINUS ), (yyvsp[0].s.val), YYLLOC ); } + case 78: /* const_array_list: const_array_list TOKEN_DOUBLE_COLON const_array */ +#line 258 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = append_node((yyvsp[-2].s.val), (yyvsp[0].s.val)); } #line 2297 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 90: /* nonident_prim_expr: TOKEN_COMPLEMENT nonident_prim_expr */ -#line 235 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node3( sval_func1, node1b( OP_UN_COMPLEMENT ), (yyvsp[0].s.val), YYLLOC ); } + case 80: /* const_array: identifier_prim */ +#line 263 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_string, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2303 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 91: /* nonident_prim_expr: TOKEN_NOT nonident_prim_expr */ -#line 236 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node2( sval_not, (yyvsp[0].s.val), YYLLOC ); } + case 82: /* prim_expr: identifier_prim */ +#line 268 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_string, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2309 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 92: /* nonident_prim_expr: TOKEN_NULL */ -#line 237 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_null, YYLLOC ); } + case 83: /* prim_expr: prim_expr TOKEN_DOUBLE_COLON const_array_list */ +#line 269 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_const_array_expr, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2315 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 93: /* nonident_prim_expr: TOKEN_NIL */ -#line 238 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_nil, YYLLOC ); } + case 84: /* nonident_prim_expr: TOKEN_DOLLAR prim_expr */ +#line 273 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_TARGETNAME), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } #line 2321 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 94: /* number: TOKEN_FLOAT */ -#line 242 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_float, (yyvsp[0].s).val ); } + case 85: /* nonident_prim_expr: nonident_prim_expr TOKEN_PERIOD TOKEN_IDENTIFIER */ +#line 274 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_field, (yyvsp[-2].s.val), (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2327 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 95: /* number: TOKEN_INTEGER */ -#line 243 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node1( sval_store_integer, (yyvsp[0].s).val ); } + case 86: /* nonident_prim_expr: nonident_prim_expr TOKEN_PERIOD TOKEN_SIZE */ +#line 275 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_SIZE), (yyvsp[-2].s.val), TOKPOS((yylsp[0]))); } #line 2333 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 97: /* makearray_statement_list: %empty */ -#line 251 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = node0( sval_none ); } + case 87: /* nonident_prim_expr: nonident_prim_expr TOKEN_LEFT_SQUARE_BRACKET expr TOKEN_RIGHT_SQUARE_BRACKET */ +#line 276 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_array_expr, (yyvsp[-3].s.val), (yyvsp[-1].s.val), TOKPOS((yylsp[-2]))); } #line 2339 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 98: /* makearray_statement_list: makearray_statement_list makearray_statement newline */ -#line 252 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = append_node( (yyvsp[-2].s.val), node1( sval_makearray, (yyvsp[-1].s.val) ) ); } + case 88: /* nonident_prim_expr: TOKEN_STRING */ +#line 277 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_string, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2345 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 99: /* makearray_statement_list: makearray_statement newline */ -#line 253 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = linked_list_end( node1( sval_makearray, (yyvsp[-1].s.val) ) ); } + case 89: /* nonident_prim_expr: TOKEN_INTEGER */ +#line 278 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_integer, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2351 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 100: /* makearray_statement: prim_expr */ -#line 257 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = linked_list_end( (yyvsp[0].s.val) ); } + case 90: /* nonident_prim_expr: TOKEN_FLOAT */ +#line 279 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_float, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2357 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 101: /* makearray_statement: makearray_statement prim_expr */ -#line 258 "E:/Src/openmohaa/code/parser/bison_source.txt" - { (yyval.s.val) = append_node( (yyvsp[-1].s.val), (yyvsp[0].s.val) ); } + case 91: /* nonident_prim_expr: TOKEN_LEFT_BRACKET expr expr expr TOKEN_RIGHT_BRACKET */ +#line 280 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node4(ENUM_vector, (yyvsp[-3].s.val), (yyvsp[-2].s.val), (yyvsp[-1].s.val), TOKPOS((yylsp[-4]))); } #line 2363 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; - case 102: /* newline: %empty */ -#line 262 "E:/Src/openmohaa/code/parser/bison_source.txt" - {} + case 92: /* nonident_prim_expr: TOKEN_LISTENER */ +#line 281 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_listener, (yyvsp[0].s.val), TOKPOS((yylsp[0]))); } #line 2369 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" break; + case 93: /* nonident_prim_expr: TOKEN_LEFT_BRACKET expr TOKEN_RIGHT_BRACKET */ +#line 282 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[-1].s.val); } +#line 2375 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; -#line 2373 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + case 94: /* nonident_prim_expr: TOKEN_NEG nonident_prim_expr */ +#line 283 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_MINUS), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 2381 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 95: /* nonident_prim_expr: TOKEN_COMPLEMENT nonident_prim_expr */ +#line 284 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node3(ENUM_func1_expr, node1b(OP_UN_COMPLEMENT), (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 2387 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 96: /* nonident_prim_expr: TOKEN_NOT nonident_prim_expr */ +#line 285 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node2(ENUM_bool_not, (yyvsp[0].s.val), TOKPOS((yylsp[-1]))); } +#line 2393 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 97: /* nonident_prim_expr: TOKEN_NULL */ +#line 286 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node1(ENUM_NULL, TOKPOS((yylsp[0]))); } +#line 2399 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 98: /* nonident_prim_expr: TOKEN_NIL */ +#line 287 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node1(ENUM_NIL, TOKPOS((yylsp[0]))); } +#line 2405 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 99: /* identifier_prim: TOKEN_IDENTIFIER */ +#line 291 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[0].s.val); (yyloc) = (yylsp[0]); } +#line 2411 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 100: /* makearray_statement_list: %empty */ +#line 295 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = node0(ENUM_NOP); } +#line 2417 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 101: /* makearray_statement_list: makearray_statement_list makearray_statement TOKEN_EOL */ +#line 296 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = append_node((yyvsp[-2].s.val), node2(ENUM_makearray, (yyvsp[-1].s.val), TOKPOS((yylsp[-1])))); } +#line 2423 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 102: /* makearray_statement_list: makearray_statement TOKEN_EOL */ +#line 297 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = linked_list_end(node2(ENUM_makearray, (yyvsp[-1].s.val), TOKPOS((yylsp[-1])))); } +#line 2429 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 103: /* makearray_statement_list: TOKEN_EOL makearray_statement_list */ +#line 298 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = (yyvsp[0].s.val); (yyloc) = (yylsp[0]); } +#line 2435 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 104: /* makearray_statement: prim_expr */ +#line 302 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = linked_list_end( (yyvsp[0].s.val) ); } +#line 2441 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 105: /* makearray_statement: makearray_statement prim_expr */ +#line 303 "E:/Src/openmohaa/code/parser/bison_source.txt" + { (yyval.s.val) = append_node( (yyvsp[-1].s.val), (yyvsp[0].s.val) ); } +#line 2447 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + case 106: /* line_opt: %empty */ +#line 307 "E:/Src/openmohaa/code/parser/bison_source.txt" + {} +#line 2453 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" + break; + + +#line 2457 "E:/Src/openmohaa/code/parser/generated/yyParser.cpp" default: break; } @@ -2390,6 +2474,7 @@ yyreduce: yylen = 0; *++yyvsp = yyval; + *++yylsp = yyloc; /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule @@ -2418,7 +2503,7 @@ yyerrlab: ++yynerrs; { yypcontext_t yyctx - = {yyssp, yytoken}; + = {yyssp, yytoken, &yylloc}; char const *yymsgp = YY_("syntax error"); int yysyntax_error_status; yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); @@ -2449,21 +2534,22 @@ yyerrlab: } } + yyerror_range[1] = yylloc; if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ - if (yychar <= END) + if (yychar <= TOKEN_EOF) { /* Return failure if at end of input. */ - if (yychar == END) + if (yychar == TOKEN_EOF) YYABORT; } else { yydestruct ("Error: discarding", - yytoken, &yylval); + yytoken, &yylval, &yylloc); yychar = YYEMPTY; } } @@ -2517,9 +2603,9 @@ yyerrlab1: if (yyssp == yyss) YYABORT; - + yyerror_range[1] = *yylsp; yydestruct ("Error: popping", - YY_ACCESSING_SYMBOL (yystate), yyvsp); + YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); @@ -2529,6 +2615,9 @@ yyerrlab1: *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END + yyerror_range[2] = yylloc; + ++yylsp; + YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); @@ -2572,7 +2661,7 @@ yyreturnlab: user semantic actions for why this is necessary. */ yytoken = YYTRANSLATE (yychar); yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); + yytoken, &yylval, &yylloc); } /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ @@ -2581,7 +2670,7 @@ yyreturnlab: while (yyssp != yyss) { yydestruct ("Cleanup: popping", - YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp); YYPOPSTACK (1); } #ifndef yyoverflow @@ -2593,5 +2682,5 @@ yyreturnlab: return yyresult; } -#line 266 "E:/Src/openmohaa/code/parser/bison_source.txt" +#line 311 "E:/Src/openmohaa/code/parser/bison_source.txt" diff --git a/code/parser/generated/yyParser.hpp b/code/parser/generated/yyParser.hpp index 552bb402..190a9be4 100644 --- a/code/parser/generated/yyParser.hpp +++ b/code/parser/generated/yyParser.hpp @@ -51,81 +51,81 @@ extern int yydebug; enum yytokentype { YYEMPTY = -2, - END = 0, /* END */ + TOKEN_EOF = 0, /* TOKEN_EOF */ YYerror = 256, /* error */ YYUNDEF = 257, /* "invalid token" */ - TOKEN_EOL = 258, /* TOKEN_EOL */ - TOKEN_COMMA = 259, /* TOKEN_COMMA */ - TOKEN_ASSIGNMENT = 260, /* TOKEN_ASSIGNMENT */ - TOKEN_PLUS_EQUALS = 261, /* TOKEN_PLUS_EQUALS */ - TOKEN_MINUS_EQUALS = 262, /* TOKEN_MINUS_EQUALS */ - TOKEN_MULTIPLY_EQUALS = 263, /* TOKEN_MULTIPLY_EQUALS */ - TOKEN_DIVIDE_EQUALS = 264, /* TOKEN_DIVIDE_EQUALS */ - TOKEN_MODULUS_EQUALS = 265, /* TOKEN_MODULUS_EQUALS */ - TOKEN_AND_EQUALS = 266, /* TOKEN_AND_EQUALS */ - TOKEN_EXCL_OR_EQUALS = 267, /* TOKEN_EXCL_OR_EQUALS */ - TOKEN_OR_EQUALS = 268, /* TOKEN_OR_EQUALS */ - TOKEN_SHIFT_LEFT_EQUALS = 269, /* TOKEN_SHIFT_LEFT_EQUALS */ - TOKEN_SHIFT_RIGHT_EQUALS = 270, /* TOKEN_SHIFT_RIGHT_EQUALS */ - TOKEN_TERNARY = 271, /* TOKEN_TERNARY */ - TOKEN_LOGICAL_OR = 272, /* TOKEN_LOGICAL_OR */ - TOKEN_LOGICAL_AND = 273, /* TOKEN_LOGICAL_AND */ - TOKEN_BITWISE_OR = 274, /* TOKEN_BITWISE_OR */ - TOKEN_BITWISE_EXCL_OR = 275, /* TOKEN_BITWISE_EXCL_OR */ - TOKEN_BITWISE_AND = 276, /* TOKEN_BITWISE_AND */ - TOKEN_EQUALITY = 277, /* TOKEN_EQUALITY */ - TOKEN_INEQUALITY = 278, /* TOKEN_INEQUALITY */ - TOKEN_LESS_THAN = 279, /* TOKEN_LESS_THAN */ - TOKEN_LESS_THAN_OR_EQUAL = 280, /* TOKEN_LESS_THAN_OR_EQUAL */ - TOKEN_GREATER_THAN = 281, /* TOKEN_GREATER_THAN */ - TOKEN_GREATER_THAN_OR_EQUAL = 282, /* TOKEN_GREATER_THAN_OR_EQUAL */ - TOKEN_SHIFT_LEFT = 283, /* TOKEN_SHIFT_LEFT */ - TOKEN_SHIFT_RIGHT = 284, /* TOKEN_SHIFT_RIGHT */ - TOKEN_PLUS = 285, /* TOKEN_PLUS */ - TOKEN_MINUS = 286, /* TOKEN_MINUS */ - TOKEN_MULTIPLY = 287, /* TOKEN_MULTIPLY */ - TOKEN_DIVIDE = 288, /* TOKEN_DIVIDE */ - TOKEN_MODULUS = 289, /* TOKEN_MODULUS */ - TOKEN_LISTENER = 290, /* TOKEN_LISTENER */ - TOKEN_NEG = 291, /* TOKEN_NEG */ - TOKEN_NOT = 292, /* TOKEN_NOT */ - TOKEN_COMPLEMENT = 293, /* TOKEN_COMPLEMENT */ - TOKEN_FLOAT = 294, /* TOKEN_FLOAT */ - TOKEN_INTEGER = 295, /* TOKEN_INTEGER */ - TOKEN_IDENTIFIER = 296, /* TOKEN_IDENTIFIER */ - TOKEN_STRING = 297, /* TOKEN_STRING */ - TOKEN_NIL = 298, /* TOKEN_NIL */ - TOKEN_NULL = 299, /* TOKEN_NULL */ - TOKEN_LBRACKET = 300, /* TOKEN_LBRACKET */ - TOKEN_RBRACKET = 301, /* TOKEN_RBRACKET */ - TOKEN_COLON = 302, /* TOKEN_COLON */ - TOKEN_SEMICOLON = 303, /* TOKEN_SEMICOLON */ - TOKEN_DOLLAR = 304, /* TOKEN_DOLLAR */ - TOKEN_DOUBLE_COLON = 305, /* TOKEN_DOUBLE_COLON */ - TOKEN_NUMBER = 306, /* TOKEN_NUMBER */ - TOKEN_LSQUARE = 307, /* TOKEN_LSQUARE */ - TOKEN_RSQUARE = 308, /* TOKEN_RSQUARE */ - TOKEN_LPAREN = 309, /* TOKEN_LPAREN */ - TOKEN_RPAREN = 310, /* TOKEN_RPAREN */ - TOKEN_INCREMENT = 311, /* TOKEN_INCREMENT */ - TOKEN_DECREMENT = 312, /* TOKEN_DECREMENT */ - TOKEN_PERIOD = 313, /* TOKEN_PERIOD */ - TOKEN_MAKEARRAY = 314, /* TOKEN_MAKEARRAY */ - TOKEN_ENDARRAY = 315, /* TOKEN_ENDARRAY */ - TOKEN_CATCH = 316, /* TOKEN_CATCH */ - TOKEN_TRY = 317, /* TOKEN_TRY */ - TOKEN_DO = 318, /* TOKEN_DO */ - TOKEN_FOR = 319, /* TOKEN_FOR */ - TOKEN_IF = 320, /* TOKEN_IF */ - TOKEN_ELSE = 321, /* TOKEN_ELSE */ + TOKEN_EOL = 259, /* TOKEN_EOL */ + TOKEN_COMMA = 260, /* TOKEN_COMMA */ + TOKEN_IF = 261, /* TOKEN_IF */ + TOKEN_ELSE = 262, /* TOKEN_ELSE */ + TOKEN_WHILE = 263, /* TOKEN_WHILE */ + TOKEN_FOR = 264, /* TOKEN_FOR */ + TOKEN_DO = 265, /* TOKEN_DO */ + TOKEN_IDENTIFIER = 266, /* TOKEN_IDENTIFIER */ + TOKEN_LEFT_BRACES = 267, /* TOKEN_LEFT_BRACES */ + TOKEN_RIGHT_BRACES = 268, /* TOKEN_RIGHT_BRACES */ + TOKEN_LEFT_BRACKET = 269, /* TOKEN_LEFT_BRACKET */ + TOKEN_RIGHT_BRACKET = 270, /* TOKEN_RIGHT_BRACKET */ + TOKEN_LEFT_SQUARE_BRACKET = 271, /* TOKEN_LEFT_SQUARE_BRACKET */ + TOKEN_RIGHT_SQUARE_BRACKET = 272, /* TOKEN_RIGHT_SQUARE_BRACKET */ + TOKEN_ASSIGNMENT = 273, /* TOKEN_ASSIGNMENT */ + TOKEN_PLUS_EQUALS = 274, /* TOKEN_PLUS_EQUALS */ + TOKEN_MINUS_EQUALS = 275, /* TOKEN_MINUS_EQUALS */ + TOKEN_MULTIPLY_EQUALS = 276, /* TOKEN_MULTIPLY_EQUALS */ + TOKEN_DIVIDE_EQUALS = 277, /* TOKEN_DIVIDE_EQUALS */ + TOKEN_MODULUS_EQUALS = 278, /* TOKEN_MODULUS_EQUALS */ + TOKEN_AND_EQUALS = 279, /* TOKEN_AND_EQUALS */ + TOKEN_EXCL_OR_EQUALS = 280, /* TOKEN_EXCL_OR_EQUALS */ + TOKEN_OR_EQUALS = 281, /* TOKEN_OR_EQUALS */ + TOKEN_SHIFT_LEFT_EQUALS = 282, /* TOKEN_SHIFT_LEFT_EQUALS */ + TOKEN_SHIFT_RIGHT_EQUALS = 283, /* TOKEN_SHIFT_RIGHT_EQUALS */ + TOKEN_TERNARY = 284, /* TOKEN_TERNARY */ + TOKEN_COLON = 285, /* TOKEN_COLON */ + TOKEN_LOGICAL_OR = 286, /* TOKEN_LOGICAL_OR */ + TOKEN_LOGICAL_AND = 287, /* TOKEN_LOGICAL_AND */ + TOKEN_BITWISE_OR = 288, /* TOKEN_BITWISE_OR */ + TOKEN_BITWISE_EXCL_OR = 289, /* TOKEN_BITWISE_EXCL_OR */ + TOKEN_BITWISE_AND = 290, /* TOKEN_BITWISE_AND */ + TOKEN_EQUALITY = 291, /* TOKEN_EQUALITY */ + TOKEN_INEQUALITY = 292, /* TOKEN_INEQUALITY */ + TOKEN_LESS_THAN = 293, /* TOKEN_LESS_THAN */ + TOKEN_LESS_THAN_OR_EQUAL = 294, /* TOKEN_LESS_THAN_OR_EQUAL */ + TOKEN_GREATER_THAN = 295, /* TOKEN_GREATER_THAN */ + TOKEN_GREATER_THAN_OR_EQUAL = 296, /* TOKEN_GREATER_THAN_OR_EQUAL */ + TOKEN_SHIFT_LEFT = 297, /* TOKEN_SHIFT_LEFT */ + TOKEN_SHIFT_RIGHT = 298, /* TOKEN_SHIFT_RIGHT */ + TOKEN_PLUS = 299, /* TOKEN_PLUS */ + TOKEN_MINUS = 300, /* TOKEN_MINUS */ + TOKEN_MULTIPLY = 301, /* TOKEN_MULTIPLY */ + TOKEN_DIVIDE = 302, /* TOKEN_DIVIDE */ + TOKEN_MODULUS = 303, /* TOKEN_MODULUS */ + TOKEN_NEG = 304, /* TOKEN_NEG */ + TOKEN_NOT = 305, /* TOKEN_NOT */ + TOKEN_COMPLEMENT = 306, /* TOKEN_COMPLEMENT */ + TOKEN_STRING = 307, /* TOKEN_STRING */ + TOKEN_INTEGER = 308, /* TOKEN_INTEGER */ + TOKEN_FLOAT = 309, /* TOKEN_FLOAT */ + TOKEN_LISTENER = 310, /* TOKEN_LISTENER */ + TOKEN_NIL = 311, /* TOKEN_NIL */ + TOKEN_NULL = 312, /* TOKEN_NULL */ + TOKEN_DOUBLE_COLON = 313, /* TOKEN_DOUBLE_COLON */ + TOKEN_SEMICOLON = 314, /* TOKEN_SEMICOLON */ + TOKEN_DOLLAR = 315, /* TOKEN_DOLLAR */ + TOKEN_NUMBER = 316, /* TOKEN_NUMBER */ + TOKEN_INCREMENT = 317, /* TOKEN_INCREMENT */ + TOKEN_DECREMENT = 318, /* TOKEN_DECREMENT */ + TOKEN_PERIOD = 319, /* TOKEN_PERIOD */ + TOKEN_CATCH = 320, /* TOKEN_CATCH */ + TOKEN_TRY = 321, /* TOKEN_TRY */ TOKEN_SWITCH = 322, /* TOKEN_SWITCH */ - TOKEN_WHILE = 323, /* TOKEN_WHILE */ + TOKEN_CASE = 323, /* TOKEN_CASE */ TOKEN_BREAK = 324, /* TOKEN_BREAK */ - TOKEN_CASE = 325, /* TOKEN_CASE */ - TOKEN_CONTINUE = 326, /* TOKEN_CONTINUE */ - TOKEN_SIZE = 327, /* TOKEN_SIZE */ - TOKEN_END = 328, /* TOKEN_END */ - TOKEN_RETURN = 329 /* TOKEN_RETURN */ + TOKEN_CONTINUE = 325, /* TOKEN_CONTINUE */ + TOKEN_SIZE = 326, /* TOKEN_SIZE */ + TOKEN_END = 327, /* TOKEN_END */ + TOKEN_RETURN = 328, /* TOKEN_RETURN */ + TOKEN_MAKEARRAY = 329, /* TOKEN_MAKEARRAY */ + TOKEN_ENDARRAY = 330 /* TOKEN_ENDARRAY */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -134,7 +134,7 @@ extern int yydebug; #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { -#line 50 "E:/Src/openmohaa/code/parser/bison_source.txt" +#line 55 "E:/Src/openmohaa/code/parser/bison_source.txt" stype_t s; @@ -146,9 +146,12 @@ typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_DECLARED 1 #endif +/* Location type. */ +typedef parse_pos_t YYLTYPE; + extern YYSTYPE yylval; - +extern YYLTYPE yylloc; int yyparse (void); diff --git a/code/parser/lex_source.txt b/code/parser/lex_source.txt index ecc3bdee..91ffe296 100644 --- a/code/parser/lex_source.txt +++ b/code/parser/lex_source.txt @@ -43,14 +43,61 @@ void fprintf2( FILE *f, const char *format, ... ) #define fprintf fprintf2 -int prev_yylex = 0; +extern int prev_yylex; +extern int out_pos; +extern int success_pos; +parseStage_e parseStage; + +/* +extern "C" int yywrap(void); + +int yywrap(void) { + if (parseStage == PS_TYPE) { + parseStage = PS_BODY; + out_pos = 0; + success_pos = 0; + return 0; + } + + if (parseStage == PS_BODY) + { + if (YY_START != 0) + { + parseStage = PS_BODY_END; + return 0; + } + + Compiler.CompileError(success_pos, "unexpected end of file found in comment"); + } + + return 1; +} +*/ extern yyparsedata parsedata; -#define YYLLOCSET { yylval.s.sourcePos = parsedata.pos - yyleng; } -#define YYLEX(n) { prev_yylex = n; return n; } +void yyllocset(YYLTYPE *loc, uint32_t off) +{ + success_pos = out_pos - yyleng + off; + loc->sourcePos = success_pos; + parsedata.pos = success_pos; +} + +void yyreducepos(uint32_t off) +{ + out_pos -= off; +} + +#define YYLEX(n) { yyllocset(&yylloc, 0); prev_yylex = n; return n; } +#define YYLEXOFF(n, off) { yyllocset(&yylloc, off); prev_yylex = n; return n; } + +#define YY_USER_ACTION \ +{ \ + out_pos += yyleng - yy_more_len; \ + yylloc.sourcePos = out_pos; \ + parsedata.pos = out_pos; \ +} -#define YY_USER_ACTION parsedata.pos; parsedata.pos += yyleng; #define YY_FATAL_ERROR( n ) yylexerror( n ) void yylexerror( const char *msg ) @@ -108,22 +155,16 @@ static void TextEscapeValue( char *str, size_t len ) static void TextValue( char *str, size_t len ) { - yylval.s.val.stringValue = parsetree_malloc( len + 1 ); - strncpy( yylval.s.val.stringValue, str, len ); - yylval.s.val.stringValue[ len ] = 0; + char* s = parsetree_malloc(len + 1); + strncpy(s, str, len); + s[len] = 0; + yylval.s.val.stringValue = s; } static bool UseField( void ) { - //return prev_yylex == TOKEN_PERIOD || prev_yylex == TOKEN_DOLLAR; - return ( !strncmp( yytext, "game.", 5 ) || - !strncmp( yytext, "group.", 6 ) || - !strncmp( yytext, "level.", 6 ) || - !strncmp( yytext, "local.", 6 ) || - !strncmp( yytext, "parm.", 5 ) || - !strncmp( yytext, "owner.", 6 ) || - !strncmp( yytext, "self.", 5 ) || - *yytext == '$' || *yytext == '-' || *yytext == '/' ); + return prev_yylex == TOKEN_PERIOD + || prev_yylex == TOKEN_DOLLAR; } %} @@ -132,8 +173,9 @@ static bool UseField( void ) %option warn nodefault -%option noyywrap never-interactive +%option never-interactive %option yylineno +%option noyywrap %x C_COMMENT %x C_LINE_COMMENT @@ -153,28 +195,28 @@ varname [a-zA-Z0-9_\"]+ . { ; } "*/" { Compiler.CompileError( parsedata.pos - yyleng, "'*/' found outside of comment" ); } - \\[\r\n]+ { ; } "//"[^\r\n]* { if( prev_yylex != TOKEN_EOL ) YYLEX( TOKEN_EOL ); } -[\r\n]* { BEGIN( INITIAL ); YYLEX( TOKEN_EOL ); } -"size" { YYLEX( TOKEN_SIZE ); } -"." { YYLEX( TOKEN_PERIOD ); } -\"([^\\\"]|\\.)*\" { YYLLOCSET; TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } -[a-zA-Z0-9_\"]+ { YYLLOCSET; TextValue( yytext, strlen( yytext ) ); YYLEX( TOKEN_IDENTIFIER ); } +"size" { BEGIN(INITIAL); YYLEX(TOKEN_SIZE); } +"." { YYLEX(TOKEN_PERIOD); } +\"{string}\" { BEGIN(INITIAL); TextEscapeValue(yytext + 1, strlen( yytext ) - 2 ); YYLEX(TOKEN_STRING); } +{varname} { + TextValue(yytext, strlen(yytext)); + YYLEX(TOKEN_IDENTIFIER); + } +[ \t\r\n] { + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + } . { - for ( int i = yyleng - 1; i >= 0; --i ) - unput( yytext[ i ] ); - - parsedata.pos -= yyleng; - - BEGIN( INITIAL ); + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); } -[\r\n]* { if( prev_yylex != TOKEN_EOL ) YYLEX( TOKEN_EOL ); } -[ \t]* { ; } - -\"{string}\" { YYLLOCSET; TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } +\"{string}\" { TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); } "?" { YYLEX( TOKEN_TERNARY ); } @@ -192,12 +234,12 @@ varname [a-zA-Z0-9_\"]+ "owner" { BEGIN( VARIABLES ); yylval.s.val = node1_( method_owner ); YYLEX( TOKEN_LISTENER ); } "self" { BEGIN( VARIABLES ); yylval.s.val = node1_( method_self ); YYLEX( TOKEN_LISTENER ); } -"{" { parsedata.braces_count++; YYLEX( TOKEN_LBRACKET ); } -"}" { parsedata.braces_count--; YYLEX( TOKEN_RBRACKET ); } -"(" { YYLLOCSET; YYLEX( TOKEN_LPAREN ); } -")" { BEGIN( VARIABLES ); YYLLOCSET; YYLEX( TOKEN_RPAREN ); } -"[" { YYLEX( TOKEN_LSQUARE ); } -"]" { BEGIN( VARIABLES ); YYLEX( TOKEN_RSQUARE ); } +"{" { parsedata.braces_count++; YYLEX( TOKEN_LEFT_BRACES ); } +"}" { parsedata.braces_count--; YYLEX( TOKEN_RIGHT_BRACES ); } +"(" { YYLEX(TOKEN_LEFT_BRACKET); } +")" { BEGIN(VARIABLES); YYLEX(TOKEN_RIGHT_BRACKET); } +"[" { YYLEX(TOKEN_LEFT_SQUARE_BRACKET); } +"]" { BEGIN(VARIABLES); YYLEX(TOKEN_RIGHT_SQUARE_BRACKET); } "=" { YYLEX( TOKEN_ASSIGNMENT ); } ":" { YYLEX( TOKEN_COLON ); } @@ -250,17 +292,6 @@ varname [a-zA-Z0-9_\"]+ "NULL" { YYLEX( TOKEN_NULL ); } "NIL" { YYLEX( TOKEN_NIL ); } -[0-9]+ { - char* p = nullptr; - yylval.s.val.intValue = std::strtoll(yytext, &p, 10); - YYLEX(TOKEN_INTEGER); - } -[0-9\.]+|[0-9\.]+("e+"|"e-")+[0-9\.] { - char* p = nullptr; - yylval.s.val.floatValue = std::strtof(yytext, &p); - YYLEX(TOKEN_FLOAT); - } - "try" { YYLEX( TOKEN_TRY ); } "catch" { YYLEX( TOKEN_CATCH ); } "switch" { YYLEX( TOKEN_SWITCH ); } @@ -272,21 +303,53 @@ varname [a-zA-Z0-9_\"]+ "makearray"|"makeArray" { YYLEX( TOKEN_MAKEARRAY ); } "endarray"|"endArray" { YYLEX( TOKEN_ENDARRAY ); } -[a-zA-Z0-9_\./\\-]+ { - if( UseField() ) - { - parsedata.pos -= yyleng; - REJECT; - } - else - { - YYLLOCSET; - TextEscapeValue( yytext, yyleng ); - YYLEX( TOKEN_IDENTIFIER ); - } +[\r\n]* { if (prev_yylex != TOKEN_EOL) YYLEX(TOKEN_EOL); } +[ \t] { ; } + +[0-9]+ { + char* p = nullptr; + yylval.s.val.intValue = std::strtol(yytext, &p, 10); + YYLEX(TOKEN_INTEGER); + } +[0-9\.]+|[0-9\.]+("e+"|"e-")+[0-9\.] { + char* p = nullptr; + yylval.s.val.floatValue = std::strtof(yytext, &p); + YYLEX(TOKEN_FLOAT); + } + +{identifier}* { + BEGIN(INITIAL); + TextEscapeValue(yytext, yyleng); + YYLEX(TOKEN_IDENTIFIER); + } +[ \t\r\n] { + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + TextEscapeValue(yytext, yyleng - 1); + YYLEXOFF(TOKEN_IDENTIFIER, 1); + } +. { + BEGIN(INITIAL); + unput(yytext[yyleng - 1]); + yyreducepos(1); + TextEscapeValue(yytext, yyleng - 1); + YYLEXOFF(TOKEN_IDENTIFIER, 1); } -. { yylexerror( "bad token:\n" ); } +{identifier} { + BEGIN(IDENTIFIER); + yymore(); + } + +[a-zA-Z0-9]+ { + BEGIN(IDENTIFIER); + yymore(); + } + +<> { YYLEX(TOKEN_EOF); } + +. { YY_FATAL_ERROR("bad token:\n"); } %{ diff --git a/code/parser/parsetree.cpp b/code/parser/parsetree.cpp index 8f0f2c60..a139f2fc 100644 --- a/code/parser/parsetree.cpp +++ b/code/parser/parsetree.cpp @@ -233,7 +233,7 @@ sval_u node0(int type) { sval_u val; - if (type == sval_none) { + if (type == ENUM_NOP) { // memory optimization val.node = &node_none; } else { @@ -262,7 +262,7 @@ sval_u node2(int type, sval_u val1, sval_u val2) { sval_u val; - assert(type != sval_none); + assert(type != ENUM_NOP); val.node = (sval_u *)parsetree_malloc(sizeof(sval_t[3])); @@ -277,7 +277,7 @@ sval_u node3(int type, sval_u val1, sval_u val2, sval_u val3) { sval_u val; - assert(type != sval_none); + assert(type != ENUM_NOP); val.node = (sval_u *)parsetree_malloc(sizeof(sval_t[4])); @@ -293,7 +293,7 @@ sval_u node4(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4) { sval_u val; - assert(type != sval_none); + assert(type != ENUM_NOP); val.node = (sval_u *)parsetree_malloc(sizeof(sval_t[5])); @@ -310,7 +310,7 @@ sval_u node5(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_ { sval_u val; - assert(type != sval_none); + assert(type != ENUM_NOP); val.node = (sval_u *)parsetree_malloc(sizeof(sval_t[6])); @@ -328,7 +328,7 @@ sval_u node6(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_ { sval_u val; - assert(type != sval_none); + assert(type != ENUM_NOP); val.node = (sval_u *)parsetree_malloc(sizeof(sval_t[7])); diff --git a/code/parser/parsetree.h b/code/parser/parsetree.h index cf768b70..ce2b977a 100644 --- a/code/parser/parsetree.h +++ b/code/parser/parsetree.h @@ -35,48 +35,48 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #endif typedef enum { - sval_none, - sval_next, - sval_statement_list, - sval_label, - sval_case, - sval_negative, - sval_assignment, - sval_if, - sval_ifelse, - sval_while, - sval_and, - sval_or, - sval_cmd_method, - sval_cmd_method_ret, - sval_cmd, - sval_cmd_default_ret, - sval_field, - sval_store_method, - sval_store_string, - sval_store_integer, - sval_store_float, - sval_calc_vector, - sval_store_null, - sval_store_nil, - sval_func1, - sval_operation, - sval_not, - sval_array, - sval_constarray, - sval_makearray, - sval_catch, - sval_switch, - sval_break, - sval_continue, - sval_do, - sval_privatelabel, - sval_define + ENUM_NOP, + ENUM_ptr, + ENUM_statement_list, + ENUM_labeled_statement, + ENUM_int_labeled_statement, + ENUM_neg_int_labeled_statement, + ENUM_assignment_statement, + ENUM_if_statement, + ENUM_if_else_statement, + ENUM_while_statement, + ENUM_logical_and, + ENUM_logical_or, + ENUM_method_event_statement, + ENUM_method_event_expr, + ENUM_cmd_event_statement, + ENUM_cmd_event_expr, + ENUM_field, + ENUM_listener, + ENUM_string, + ENUM_integer, + ENUM_float, + ENUM_vector, + ENUM_NULL, + ENUM_NIL, + ENUM_func1_expr, + ENUM_func2_expr, + ENUM_bool_not, + ENUM_array_expr, + ENUM_const_array_expr, + ENUM_makearray, + ENUM_try, + ENUM_switch, + ENUM_break, + ENUM_continue, + ENUM_do, + ENUM_privatelabel, + ENUM_define } sval_type_e; typedef union sval_u { int type; - char *stringValue; + const char *stringValue; float floatValue; int intValue; char charValue; @@ -88,10 +88,16 @@ typedef union sval_u { unsigned int sourcePosValue; } sval_t; -typedef struct { +struct stype_t { sval_t val; unsigned int sourcePos; -} stype_t; +}; + +enum parseStage_e { + PS_TYPE, + PS_BODY, + PS_BODY_END +}; void parsetree_freeall(); void parsetree_init(); @@ -117,6 +123,14 @@ sval_u node4(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4); sval_u node5(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5); sval_u node6(int type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6); +typedef struct parse_pos_s { + int sourcePos; + int first_line; + int first_column; + int last_line; + int last_column; +} parse_pos_t; + struct yyexception { int yylineno; str yytext; diff --git a/code/script/scriptcompiler.cpp b/code/script/scriptcompiler.cpp index 594d51ad..6d512fa6 100644 --- a/code/script/scriptcompiler.cpp +++ b/code/script/scriptcompiler.cpp @@ -236,20 +236,19 @@ void ScriptCompiler::EmitAssignmentStatement(sval_t lhs, unsigned int sourcePos) { int eventnum; sval_t listener_val; - char *name = lhs.node[2].stringValue; + const char *name = lhs.node[2].stringValue; str name2 = name; name2.tolower(); - if (lhs.node[0].type != sval_field) { - if (lhs.node[0].type == sval_array) { + if (lhs.node[0].type != ENUM_field) { + if (lhs.node[0].type == ENUM_array_expr) { EmitRef(lhs.node[1], sourcePos); EmitValue(lhs.node[2]); EmitOpcode(OP_LOAD_ARRAY_VAR, lhs.node[3].sourcePosValue); - - return; } else { CompileError(sourcePos, "bad lvalue: %d (expecting field or array)", lhs.node[0].type); - } + } + return; } unsigned int index = Director.AddString(name); @@ -262,7 +261,7 @@ void ScriptCompiler::EmitAssignmentStatement(sval_t lhs, unsigned int sourcePos) listener_val = lhs.node[1]; - if (listener_val.node[0].type != sval_store_method + if (listener_val.node[0].type != ENUM_listener || (eventnum && BuiltinWriteVariable(sourcePos, listener_val.node[1].byteValue, eventnum))) { EmitValue(listener_val); EmitOpcode(OP_LOAD_FIELD_VAR, sourcePos); @@ -368,22 +367,15 @@ void ScriptCompiler::EmitCatch(sval_t val, unsigned char *try_begin_code_pos, un void ScriptCompiler::EmitConstArray(sval_t lhs, sval_t rhs, unsigned int sourcePos) { - int iCount = 1; + uint32_t iCount = 1; - while (1) { - iCount++; + EmitValue(lhs); - EmitValue(lhs); + for (const sval_t* node = rhs.node[0].node; node; node = node[1].node, iCount++) + { + EmitValue(*node); + } - if (rhs.node[0].type != sval_constarray) { - break; - } - - lhs = rhs.node[1]; - rhs = rhs.node[2]; - } - - EmitValue(rhs); EmitConstArrayOpcode(iCount); } @@ -491,7 +483,7 @@ void ScriptCompiler::EmitField(sval_t listener_val, sval_t field_val, unsigned i prev_index = GetOpcodeValue(sizeof(unsigned int), sizeof(unsigned int)); - if (listener_val.node[0].type != sval_store_method + if (listener_val.node[0].type != ENUM_listener || (eventnum && BuiltinReadVariable(sourcePos, listener_val.node[1].byteValue, eventnum))) { EmitValue(listener_val); EmitOpcode(OP_STORE_FIELD, sourcePos); @@ -534,9 +526,10 @@ void ScriptCompiler::EmitFunc1(int opcode, unsigned int sourcePos) EmitOpcode(opcode, sourcePos); } +/* void ScriptCompiler::EmitFunction(int iParamCount, sval_t val, unsigned int sourcePos) { - char *p = val.stringValue; + const char *p = val.stringValue; str filename; str label; @@ -573,6 +566,7 @@ void ScriptCompiler::EmitFunction(int iParamCount, sval_t val, unsigned int sour EmitOpcodeValue(iParamCount, sizeof(uint8_t)); } +*/ void ScriptCompiler::EmitIfElseJump(sval_t if_stmt, sval_t else_stmt, unsigned int sourcePos) { @@ -674,22 +668,16 @@ void ScriptCompiler::EmitLabel(str name, unsigned int sourcePos) void ScriptCompiler::EmitLabelParameterList(sval_t parameter_list, unsigned int sourcePos) { - sval_u param; + if (parameter_list.node) + { + EmitOpcode(OP_MARK_STACK_POS, sourcePos); - ClearPrevOpcode(); + for (const sval_t* param = parameter_list.node->node; param; param = param[1].node) { + EmitParameter(*param, sourcePos); + }; - param = parameter_list.node[0]; - - if (param.node && param.node[0].node[0].type != sval_none) { - EmitOpcode(OP_MARK_STACK_POS, sourcePos); - - while (param.node) { - EmitParameter(param.node[0], param.node[2].sourcePosValue); - param = param.node[1]; - } - - EmitOpcode(OP_RESTORE_STACK_POS, sourcePos); - } + EmitOpcode(OP_RESTORE_STACK_POS, sourcePos); + } } void ScriptCompiler::EmitLabelPrivate(str name, unsigned int sourcePos) @@ -867,60 +855,59 @@ void ScriptCompiler::EmitOpcode(int opcode, unsigned int sourcePos) void ScriptCompiler::EmitParameter(sval_t lhs, unsigned int sourcePos) { - if (lhs.node[0].type != sval_field) { + if (lhs.node[0].type != ENUM_field) { CompileError(sourcePos, "bad parameter lvalue: %d (expecting field)", lhs.node[0].type); } sval_u listener_val = lhs.node[1]; const char *name = lhs.node[2].stringValue; - unsigned int index = Director.AddString(name); int eventnum = Event::FindSetterEventNum(name); - if (listener_val.node[0].type != sval_store_method + if (listener_val.node[0].type != ENUM_listener || (eventnum && BuiltinWriteVariable(sourcePos, listener_val.node[1].byteValue, eventnum))) { CompileError(sourcePos, "built-in field '%s' not allowed", name); } else { EmitOpcode(OP_STORE_PARAM, sourcePos); EmitOpcode(OP_LOAD_GAME_VAR + listener_val.node[1].byteValue, sourcePos); + unsigned int index = Director.AddString(name); EmitOpcodeValue(index, sizeof(unsigned int)); } } int ScriptCompiler::EmitParameterList(sval_t event_parameter_list) { - sval_t *node; - int iParamCount = 0; + sval_t* node; + uint32_t iParamCount = 0; - for (node = event_parameter_list.node[1].node[0].node; node != NULL; node = node[1].node) { - if (node[0].node[0].type == sval_none) { - continue; - } + if (!event_parameter_list.node) { + return 0; + } - EmitValue(*node); + for (node = event_parameter_list.node->node; node; node = node[1].node) + { + EmitValue(*node); - iParamCount++; - } + iParamCount++; + } - return iParamCount; + return iParamCount; } void ScriptCompiler::EmitRef(sval_t val, unsigned int sourcePos) { unsigned int index; - if (val.node[0].type != sval_field) { - if (val.node[0].type == sval_array) { + if (val.node[0].type != ENUM_field) { + if (val.node[0].type == ENUM_array_expr) { EmitRef(val.node[1], sourcePos); EmitValue(val.node[2]); EmitOpcode(OP_STORE_ARRAY_REF, val.node[3].sourcePosValue); - - return; } else { CompileError(sourcePos, "bad lvalue: %d (expecting field or array)", val.node[0].type); - return; - } + } + return; } index = Director.AddString(val.node[2].stringValue); @@ -993,48 +980,48 @@ void ScriptCompiler::EmitValue(sval_t val) __emit: switch (val.node[0].type) { - case sval_none: + case ENUM_NOP: break; - case sval_and: - case sval_or: + case ENUM_logical_and: + case ENUM_logical_or: EmitValue(val.node[1]); EmitVarToBool(val.node[3].sourcePosValue); - EmitLogicJump(val.node[2], val.node[0].type == sval_or, val.node[3].sourcePosValue); + EmitLogicJump(val.node[2], val.node[0].type == ENUM_logical_or, val.node[3].sourcePosValue); break; - case sval_array: + case ENUM_array_expr: EmitValue(val.node[1]); EmitValue(val.node[2]); EmitOpcode(OP_STORE_ARRAY, val.node[3].sourcePosValue); break; - case sval_assignment: + case ENUM_assignment_statement: EmitValue(val.node[2]); EmitAssignmentStatement(val.node[1], val.node[3].sourcePosValue); break; - case sval_break: + case ENUM_break: return EmitBreak(val.node[1].sourcePosValue); - case sval_calc_vector: + case ENUM_vector: EmitValue(val.node[1]); EmitValue(val.node[2]); EmitValue(val.node[3]); EmitOpcode(OP_CALC_VECTOR, val.node[4].sourcePosValue); break; - case sval_negative: + case ENUM_neg_int_labeled_statement: val.node[1].intValue = -val.node[1].intValue; - case sval_case: + case ENUM_int_labeled_statement: { sval_u case_parm = val.node[1]; - if (case_parm.node[0].type == sval_store_integer) { + if (case_parm.node[0].type == ENUM_integer) { EmitLabel(case_parm.node[1].intValue, val.node[3].sourcePosValue); - } else if (case_parm.node[0].type == sval_store_string) { + } else if (case_parm.node[0].type == ENUM_string) { EmitLabel(case_parm.node[1].stringValue, val.node[3].sourcePosValue); - } else if (case_parm.node[0].type == sval_func1 && case_parm.node[1].byteValue == OP_UN_MINUS) { + } else if (case_parm.node[0].type == ENUM_func1_expr && case_parm.node[1].byteValue == OP_UN_MINUS) { EmitLabel(-case_parm.node[2].node[1].intValue, val.node[3].sourcePosValue); } else { CompileError( @@ -1049,7 +1036,7 @@ __emit: break; } - case sval_catch: + case ENUM_try: { unsigned char *old_code_pos = code_pos; @@ -1059,197 +1046,185 @@ __emit: break; } - case sval_cmd: + case ENUM_cmd_event_statement: + { + const int eventnum = Event::FindNormalEventNum(val.node[1].stringValue); + sval_t parameter_list = val.node[2]; + const uint32_t iParamCount = EmitParameterList(parameter_list); + + if (!eventnum) { + CompileError(val.node[3].sourcePosValue, "unknown command: %s", val.node[1].stringValue); + } + + if (iParamCount > 5) + { + SetOpcodeVarStackOffset(OP_EXEC_CMD_COUNT1, -(int32_t)iParamCount); + EmitOpcode(OP_EXEC_CMD_COUNT1, val.node[3].sourcePosValue); + + EmitOpcodeValue(iParamCount, sizeof(byte)); + } + else + { + EmitOpcode(OP_EXEC_CMD0 + iParamCount, val.node[3].sourcePosValue); + } + + EmitOpcodeValue((op_ev_t)eventnum, sizeof(unsigned int)); + break; + } + + case ENUM_cmd_event_expr: { - str cmd = val.node[1].stringValue; - cmd.tolower(); - int eventnum = Event::FindNormalEventNum(cmd); - int iParamCount = EmitParameterList(val.node[2]); + const int eventnum = Event::FindReturnEventNum(val.node[1].stringValue); + sval_t parameter_list = val.node[2]; + const uint32_t iParamCount = EmitParameterList(parameter_list); - if (!eventnum) { - CompileError(val.node[3].sourcePosValue, "unknown command: %s", val.node[1].stringValue); + EmitOpcode(OP_STORE_LOCAL, val.node[3].sourcePosValue); - /*EmitOpcode( OP_STORE_LOCAL, val.node[ 3 ].sourcePosValue ); - EmitFunction( iParamCount, val.node[ 1 ], val.node[ 3 ].sourcePosValue ); - EmitOpcode( OP_LOAD_LOCAL_VAR, val.node[ 3 ].sourcePosValue ); + if (!eventnum) { + CompileError(val.node[3].sourcePosValue, "unknown command: %s", val.node[1].stringValue); + } - *reinterpret_cast< unsigned int * >( code_pos ) = Director.AddString( "" ); - code_pos += sizeof( unsigned int );*/ - } else { - if (iParamCount > 5) { - SetOpcodeVarStackOffset(OP_EXEC_CMD_COUNT1, -iParamCount); - EmitOpcode(OP_EXEC_CMD_COUNT1, val.node[3].sourcePosValue); + EmitMethodExpression(iParamCount, eventnum, val.node[3].sourcePosValue); - EmitOpcodeValue(iParamCount, sizeof(byte)); - } else { - EmitOpcode(OP_EXEC_CMD0 + iParamCount, val.node[3].sourcePosValue); - } - - EmitOpcodeValue(eventnum, sizeof(unsigned int)); - } - break; + EmitOpcodeValue((op_ev_t)eventnum, sizeof(unsigned int)); + break; } - case sval_cmd_default_ret: + case ENUM_method_event_statement: { - str cmd = val.node[1].stringValue; - cmd.tolower(); - int eventnum = Event::FindReturnEventNum(cmd); - int iParamCount = EmitParameterList(val.node[2]); + const int eventnum = Event::FindNormalEventNum(val.node[2].stringValue); + sval_t parameter_list = val.node[3]; + const uint32_t iParamCount = EmitParameterList(parameter_list); - EmitOpcode(OP_STORE_LOCAL, val.node[3].sourcePosValue); + if (!eventnum) { + CompileError(val.node[3].sourcePosValue, "unknown command: %s", val.node[2].stringValue); + } - if (!eventnum) { - CompileError(val.node[3].sourcePosValue, "unknown return command: %s", val.node[1].stringValue); - //EmitFunction( iParamCount, val.node[ 1 ], val.node[ 3 ].sourcePosValue ); - } else { - EmitMethodExpression(iParamCount, eventnum, val.node[3].sourcePosValue); - } - break; + EmitValue(val.node[1]); + + if (iParamCount > 5) + { + SetOpcodeVarStackOffset(OP_EXEC_CMD_COUNT1, -(int32_t)iParamCount); + EmitOpcode(OP_EXEC_CMD_COUNT1, val.node[4].sourcePosValue); + + EmitOpcodeValue(iParamCount, sizeof(byte)); + } + else + { + EmitOpcode(OP_EXEC_CMD_METHOD0 + iParamCount, val.node[4].sourcePosValue); + } + + EmitOpcodeValue(eventnum, sizeof(unsigned int)); + break; } - case sval_cmd_method: - { - str cmd = val.node[2].stringValue; - cmd.tolower(); - int eventnum = Event::FindNormalEventNum(cmd); - int iParamCount = EmitParameterList(val.node[3]); + case ENUM_method_event_expr: + { + const int eventnum = Event::FindReturnEventNum(val.node[2].stringValue); + sval_t parameter_list = val.node[3]; + const uint32_t iParamCount = EmitParameterList(parameter_list); - EmitValue(val.node[1]); + if (!eventnum) { + CompileError(val.node[4].sourcePosValue, "unknown command: %s", val.node[2].stringValue); + } - if (!eventnum) { - CompileError(val.node[4].sourcePosValue, "unknown command: %s", val.node[2].stringValue); + EmitValue(val.node[1]); + EmitMethodExpression(iParamCount, eventnum, val.node[4].sourcePosValue); + break; + } - /*EmitFunction( iParamCount, val.node[ 2 ], val.node[ 4 ].sourcePosValue ); - EmitOpcode( OP_LOAD_LOCAL_VAR, val.node[ 3 ].sourcePosValue ); - - *reinterpret_cast< unsigned int * >( code_pos ) = Director.AddString( "" ); - code_pos += sizeof( unsigned int );*/ - } else { - if (iParamCount > 5) { - SetOpcodeVarStackOffset(OP_EXEC_CMD_METHOD_COUNT1, -iParamCount - 1); - EmitOpcode(OP_EXEC_CMD_METHOD_COUNT1, val.node[4].sourcePosValue); - - EmitOpcodeValue(iParamCount, sizeof(byte)); - } else { - EmitOpcode(OP_EXEC_CMD_METHOD0 + iParamCount, val.node[4].sourcePosValue); - } - - EmitOpcodeValue(eventnum, sizeof(unsigned int)); - } - break; - } - - case sval_cmd_method_ret: - { - str cmd = val.node[2].stringValue; - cmd.tolower(); - int eventnum = Event::FindReturnEventNum(cmd); - int iParamCount = EmitParameterList(val.node[3]); - - EmitValue(val.node[1]); - - if (!eventnum) { - CompileError(val.node[4].sourcePosValue, "unknown return command: %s", val.node[2].stringValue); - //EmitFunction( iParamCount ,val.node[ 2 ], val.node[ 4 ].sourcePosValue ); - } else { - EmitMethodExpression(iParamCount, eventnum, val.node[4].sourcePosValue); - } - break; - } - - case sval_constarray: + case ENUM_const_array_expr: return EmitConstArray(val.node[1], val.node[2], val.node[3].sourcePosValue); - case sval_continue: + case ENUM_continue: return EmitContinue(val.node[1].sourcePosValue); - case sval_do: + case ENUM_do: return EmitDoWhileJump(val.node[1], val.node[2], val.node[3].sourcePosValue); - case sval_field: + case ENUM_field: return EmitField(val.node[1], val.node[2], val.node[3].sourcePosValue); - case sval_func1: + case ENUM_func1_expr: EmitValue(val.node[2]); EmitFunc1(val.node[1].byteValue, val.node[3].sourcePosValue); break; - case sval_if: + case ENUM_if_statement: EmitValue(val.node[1]); EmitVarToBool(val.node[4].sourcePosValue); EmitIfJump(val.node[2], val.node[3].sourcePosValue); break; - case sval_ifelse: + case ENUM_if_else_statement: EmitValue(val.node[1]); EmitVarToBool(val.node[4].sourcePosValue); EmitIfElseJump(val.node[2], val.node[3], val.node[4].sourcePosValue); break; - case sval_label: + case ENUM_labeled_statement: EmitLabel(val.node[1].stringValue, val.node[3].sourcePosValue); EmitLabelParameterList(val.node[2], val.node[3].sourcePosValue); break; - case sval_privatelabel: + case ENUM_privatelabel: EmitLabelPrivate(val.node[1].stringValue, val.node[3].sourcePosValue); EmitLabelParameterList(val.node[2], val.node[3].sourcePosValue); break; - case sval_makearray: + case ENUM_makearray: return EmitMakeArray(val.node[1]); - case sval_not: + case ENUM_bool_not: EmitValue(val.node[1]); EmitVarToBool(val.node[2].sourcePosValue); EmitBoolNot(val.node[2].sourcePosValue); EmitBoolToVar(val.node[2].sourcePosValue); break; - case sval_operation: + case ENUM_func2_expr: EmitValue(val.node[2]); EmitValue(val.node[3]); EmitOpcode(val.node[1].byteValue, val.node[4].sourcePosValue); break; - case sval_statement_list: + case ENUM_statement_list: return EmitStatementList(val.node[1]); - case sval_store_float: + case ENUM_float: EmitFloat(val.node[1].floatValue, val.node[2].sourcePosValue); break; - case sval_store_integer: + case ENUM_integer: EmitInteger(val.node[1].intValue, val.node[2].sourcePosValue); break; - case sval_store_method: + case ENUM_listener: EmitOpcode(OP_STORE_GAME + val.node[1].byteValue, val.node[2].sourcePosValue); break; - case sval_store_nil: + case ENUM_NIL: EmitOpcode(OP_STORE_NIL, val.node[1].sourcePosValue); break; - case sval_store_null: + case ENUM_NULL: EmitOpcode(OP_STORE_NULL, val.node[1].sourcePosValue); break; - case sval_store_string: + case ENUM_string: EmitString(val.node[1].stringValue, val.node[2].sourcePosValue); break; - case sval_switch: + case ENUM_switch: EmitValue(val.node[1]); EmitSwitch(val.node[2], val.node[3].sourcePosValue); break; - case sval_next: + case ENUM_ptr: val = val.node[1]; goto __emit; // prevent stack overflow - case sval_while: + case ENUM_while_statement: return EmitWhileJump(val.node[1], val.node[2], val.node[3], val.node[4].sourcePosValue); default: @@ -1428,14 +1403,15 @@ int yyparse(); char *ScriptCompiler::Preprocess(char *sourceBuffer) { - // FIXME (ley0k): Preprocessor (#defines and #includes) - return sourceBuffer; } void ScriptCompiler::Preclean(char *processedBuffer) {} extern int prev_yylex; +extern int out_pos; +extern int success_pos; +extern parseStage_e parseStage; int yyerror(const char *msg) { @@ -1463,6 +1439,10 @@ size_t ScriptCompiler::Parse(GameScript *gameScript, char *sourceBuffer) parsedata.braces_count = 0; prev_yylex = 0; + out_pos = 0; + success_pos = 0; + parseStage = PS_TYPE; + script = gameScript; stateScript = &gameScript->m_State; yy_scan_string(sourceBuffer); diff --git a/code/script/scriptcompiler.h b/code/script/scriptcompiler.h index d08e7e4c..d10078fd 100644 --- a/code/script/scriptcompiler.h +++ b/code/script/scriptcompiler.h @@ -31,6 +31,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA class ScriptVariable; +typedef void (*ScriptDisplayTokenFunc)(const char* type, const char* name); + enum { method_game, method_level, @@ -118,7 +120,7 @@ public: void EmitField(sval_t listener_val, sval_t field_val, unsigned int sourcePos); void EmitFloat(float value, unsigned int sourcePos); void EmitFunc1(int opcode, unsigned int sourcePos); - void EmitFunction(int iParamCount, sval_t val, unsigned int sourcePos); + //void EmitFunction(int iParamCount, sval_t val, unsigned int sourcePos); void EmitIfElseJump(sval_t if_stmt, sval_t else_stmt, unsigned int sourcePos); void EmitIfJump(sval_t if_stmt, unsigned int sourcePos); void EmitInteger(unsigned int value, unsigned int sourcePos);