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

9
code/fgame/CMakeLists.txt
View file

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

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;

334
code/script/scriptcompiler.cpp
View file

@ -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<unsigned int>(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);

4
code/script/scriptcompiler.h
View file

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