Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 13:47:58 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Major script engine fixes

Browse source
This commit is contained in:
smallmodel 2023-08-12 19:59:40 +02:00
parent 0da1ed8764
commit f5af33b181
No known key found for this signature in database
GPG key ID: A96F163ED4891440
11 changed files with 2148 additions and 1936 deletions
Download patch file Download diff file Expand all files Collapse all files

329
code/parser/bison_source.txt
View file

@ -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 <s.val> 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 <s> TOKEN_LISTENER
%right TOKEN_NEG TOKEN_NOT TOKEN_COMPLEMENT
%token <s> TOKEN_FLOAT TOKEN_INTEGER TOKEN_IDENTIFIER TOKEN_STRING TOKEN_NIL TOKEN_NULL
%precedence <s.val> TOKEN_STRING
%precedence <s.val> TOKEN_INTEGER
%precedence <s.val> TOKEN_FLOAT
%token TOKEN_LBRACKET TOKEN_RBRACKET
%precedence <s.val> 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 <s> 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 <s.val> event_parameter_list event_parameter_list_need
%type <s.val> statement_list statement makearray_statement_list makearray_statement
%type <s.val> compound_statement
%type <s.val> event_parameter_list event_parameter_list_need event_parameter
%type <s.val> statement_list statement statement_declaration makearray_statement_list makearray_statement
%type <s.val> compound_statement selection_statement iteration_statement
%type <s.val> expr
%type <s.val> func_prim_expr
%type <s.val> prim_expr
%type <s.val> nonident_prim_expr
%type <s.val> number
%type <s> identifier_prim
%type <s.val> const_array_list
%type <s.val> const_array
%type <s.val> 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
;

1211
code/parser/generated/yyLexer.cpp
View file

File diff suppressed because it is too large Load diff

2
code/parser/generated/yyLexer.h
View file

@ -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"

1751
code/parser/generated/yyParser.cpp
View file

File diff suppressed because it is too large Load diff

149
code/parser/generated/yyParser.hpp
View file

@ -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);

189
code/parser/lex_source.txt
View file

@ -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_\"]+
<C_COMMENT>. { ; }
"*/" { Compiler.CompileError( parsedata.pos - yyleng, "'*/' found outside of comment" ); }
\\[\r\n]+ { ; }
"//"[^\r\n]* { if( prev_yylex != TOKEN_EOL ) YYLEX( TOKEN_EOL ); }
<VARIABLES>[\r\n]* { BEGIN( INITIAL ); YYLEX( TOKEN_EOL ); }
<VARIABLES>"size" { YYLEX( TOKEN_SIZE ); }
<VARIABLES>"." { YYLEX( TOKEN_PERIOD ); }
<VARIABLES>\"([^\\\"]|\\.)*\" { YYLLOCSET; TextEscapeValue( yytext + 1, strlen( yytext ) - 2 ); YYLEX( TOKEN_STRING ); }
<VARIABLES>[a-zA-Z0-9_\"]+ { YYLLOCSET; TextValue( yytext, strlen( yytext ) ); YYLEX( TOKEN_IDENTIFIER ); }
<VARIABLES>"size" { BEGIN(INITIAL); YYLEX(TOKEN_SIZE); }
<VARIABLES>"." { YYLEX(TOKEN_PERIOD); }
<VARIABLES>\"{string}\" { BEGIN(INITIAL); TextEscapeValue(yytext + 1, strlen( yytext ) - 2 ); YYLEX(TOKEN_STRING); }
<VARIABLES>{varname} {
TextValue(yytext, strlen(yytext));
YYLEX(TOKEN_IDENTIFIER);
}
<VARIABLES>[ \t\r\n] {
BEGIN(INITIAL);
unput(yytext[yyleng - 1]);
yyreducepos(1);
}
<VARIABLES>. {
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>{identifier}* {
BEGIN(INITIAL);
TextEscapeValue(yytext, yyleng);
YYLEX(TOKEN_IDENTIFIER);
}
<IDENTIFIER>[ \t\r\n] {
BEGIN(INITIAL);
unput(yytext[yyleng - 1]);
yyreducepos(1);
TextEscapeValue(yytext, yyleng - 1);
YYLEXOFF(TOKEN_IDENTIFIER, 1);
}
<IDENTIFIER>. {
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();
}
<<EOF>> { YYLEX(TOKEN_EOF); }
. { YY_FATAL_ERROR("bad token:\n"); }
%{

12
code/parser/parsetree.cpp
View file

@ -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]));

94
code/parser/parsetree.h
View file

@ -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;