2 * Copyright 2008 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define YYLEX_PARAM ctx
25 #define YYPARSE_PARAM ctx
27 static int parser_error(const char*);
28 static void set_error(parser_ctx_t*,UINT);
29 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR);
30 static BOOL allow_auto_semicolon(parser_ctx_t*);
31 static void program_parsed(parser_ctx_t*,source_elements_t*);
32 static source_elements_t *function_body_parsed(parser_ctx_t*,source_elements_t*);
34 typedef struct _statement_list_t {
39 static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*);
40 static literal_t *new_null_literal(parser_ctx_t*);
41 static literal_t *new_undefined_literal(parser_ctx_t*);
42 static literal_t *new_boolean_literal(parser_ctx_t*,VARIANT_BOOL);
44 typedef struct _property_list_t {
49 static property_list_t *new_property_list(parser_ctx_t*,literal_t*,expression_t*);
50 static property_list_t *property_list_add(parser_ctx_t*,property_list_t*,literal_t*,expression_t*);
52 typedef struct _element_list_t {
53 array_element_t *head;
54 array_element_t *tail;
57 static element_list_t *new_element_list(parser_ctx_t*,int,expression_t*);
58 static element_list_t *element_list_add(parser_ctx_t*,element_list_t*,int,expression_t*);
60 typedef struct _argument_list_t {
65 static argument_list_t *new_argument_list(parser_ctx_t*,expression_t*);
66 static argument_list_t *argument_list_add(parser_ctx_t*,argument_list_t*,expression_t*);
68 typedef struct _case_list_t {
69 case_clausule_t *head;
70 case_clausule_t *tail;
73 static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*);
74 static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*);
75 static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*);
76 static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*);
77 static case_clausule_t *new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*);
79 typedef struct _variable_list_t {
80 variable_declaration_t *head;
81 variable_declaration_t *tail;
84 static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const WCHAR*,expression_t*);
85 static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*);
86 static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*);
88 static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*);
89 static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*);
90 static statement_t *new_empty_statement(parser_ctx_t*);
91 static statement_t *new_expression_statement(parser_ctx_t*,expression_t*);
92 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*);
93 static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*);
94 static statement_t *new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*,
95 expression_t*,statement_t*);
96 static statement_t *new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
97 static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*);
98 static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*);
99 static statement_t *new_return_statement(parser_ctx_t*,expression_t*);
100 static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*);
101 static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*);
102 static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
103 static statement_t *new_throw_statement(parser_ctx_t*,expression_t*);
104 static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*);
106 struct statement_list_t {
111 static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*);
112 static statement_list_t *statement_list_add(statement_list_t*,statement_t*);
114 typedef struct _parameter_list_t {
119 static parameter_list_t *new_parameter_list(parser_ctx_t*,const WCHAR*);
120 static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,const WCHAR*);
122 static void push_func(parser_ctx_t*);
123 static inline void pop_func(parser_ctx_t *ctx)
125 ctx->func_stack = ctx->func_stack->next;
128 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*,
129 source_elements_t*,const WCHAR*,DWORD);
130 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
131 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
132 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*);
133 static expression_t *new_array_expression(parser_ctx_t*,expression_t*,expression_t*);
134 static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
135 static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*);
136 static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*);
137 static expression_t *new_this_expression(parser_ctx_t*);
138 static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*);
139 static expression_t *new_literal_expression(parser_ctx_t*,literal_t*);
140 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int);
141 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*);
143 static source_elements_t *new_source_elements(parser_ctx_t*);
144 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*);
156 struct _argument_list_t *argument_list;
157 case_clausule_t *case_clausule;
158 struct _case_list_t *case_list;
159 catch_block_t *catch_block;
160 struct _element_list_t *element_list;
162 const WCHAR *identifier;
163 struct _parameter_list_t *parameter_list;
164 struct _property_list_t *property_list;
165 source_elements_t *source_elements;
166 statement_t *statement;
167 struct _statement_list_t *statement_list;
168 struct _variable_list_t *variable_list;
169 variable_declaration_t *variable_declaration;
173 %token kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kIF kFINALLY kFOR kIN
174 %token kINSTANCEOF kNEW kNULL kUNDEFINED kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH
175 %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ
177 %token <srcptr> kFUNCTION '}'
180 %token <identifier> tIdentifier
181 %token <ival> tAssignOper tEqOper tShiftOper tRelOper
182 %token <literal> tNumericLiteral
183 %token <wstr> tStringLiteral
185 %type <source_elements> SourceElements
186 %type <source_elements> FunctionBody
187 %type <statement> Statement
188 %type <statement> Block
189 %type <statement> VariableStatement
190 %type <statement> EmptyStatement
191 %type <statement> ExpressionStatement
192 %type <statement> IfStatement
193 %type <statement> IterationStatement
194 %type <statement> ContinueStatement
195 %type <statement> BreakStatement
196 %type <statement> ReturnStatement
197 %type <statement> WithStatement
198 %type <statement> LabelledStatement
199 %type <statement> SwitchStatement
200 %type <statement> ThrowStatement
201 %type <statement> TryStatement
202 %type <statement> Finally
203 %type <statement_list> StatementList StatementList_opt
204 %type <parameter_list> FormalParameterList FormalParameterList_opt
205 %type <expr> Expression Expression_opt Expression_err
206 %type <expr> ExpressionNoIn ExpressionNoIn_opt
207 %type <expr> FunctionExpression
208 %type <expr> AssignmentExpression AssignmentExpressionNoIn
209 %type <expr> ConditionalExpression ConditionalExpressionNoIn
210 %type <expr> LeftHandSideExpression
211 %type <expr> LogicalORExpression LogicalORExpressionNoIn
212 %type <expr> LogicalANDExpression LogicalANDExpressionNoIn
213 %type <expr> BitwiseORExpression BitwiseORExpressionNoIn
214 %type <expr> BitwiseXORExpression BitwiseXORExpressionNoIn
215 %type <expr> BitwiseANDExpression BitwiseANDExpressionNoIn
216 %type <expr> EqualityExpression EqualityExpressionNoIn
217 %type <expr> RelationalExpression RelationalExpressionNoIn
218 %type <expr> ShiftExpression
219 %type <expr> AdditiveExpression
220 %type <expr> MultiplicativeExpression
221 %type <expr> Initialiser_opt Initialiser
222 %type <expr> InitialiserNoIn_opt InitialiserNoIn
223 %type <expr> UnaryExpression
224 %type <expr> PostfixExpression
225 %type <expr> NewExpression
226 %type <expr> CallExpression
227 %type <expr> MemberExpression
228 %type <expr> PrimaryExpression
229 %type <identifier> Identifier_opt
230 %type <variable_list> VariableDeclarationList
231 %type <variable_list> VariableDeclarationListNoIn
232 %type <variable_declaration> VariableDeclaration
233 %type <variable_declaration> VariableDeclarationNoIn
234 %type <case_list> CaseClausules CaseClausules_opt
235 %type <case_clausule> CaseClausule DefaultClausule CaseBlock
236 %type <catch_block> Catch
237 %type <argument_list> Arguments
238 %type <argument_list> ArgumentList
239 %type <literal> Literal
240 %type <expr> ArrayLiteral
241 %type <expr> ObjectLiteral
242 %type <ival> Elision Elision_opt
243 %type <element_list> ElementList
244 %type <property_list> PropertyNameAndValueList
245 %type <literal> PropertyName
246 %type <literal> BooleanLiteral
247 %type <srcptr> KFunction
248 %type <ival> AssignOper
250 %nonassoc LOWER_THAN_ELSE
255 /* ECMA-262 3rd Edition 14 */
257 : SourceElements HtmlComment
258 { program_parsed(ctx, $1); }
264 /* ECMA-262 3rd Edition 14 */
266 : /* empty */ { $$ = new_source_elements(ctx); }
267 | SourceElements FunctionExpression
269 | SourceElements Statement
270 { $$ = source_elements_add_statement($1, $2); }
272 /* ECMA-262 3rd Edition 13 */
274 : KFunction Identifier_opt left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
275 { $$ = new_function_expression(ctx, $2, $4, $7, $1, $8-$1+1); }
278 : kFUNCTION { push_func(ctx); $$ = $1; }
280 /* ECMA-262 3rd Edition 13 */
282 : SourceElements { $$ = function_body_parsed(ctx, $1); }
284 /* ECMA-262 3rd Edition 13 */
286 : tIdentifier { $$ = new_parameter_list(ctx, $1); }
287 | FormalParameterList ',' tIdentifier
288 { $$ = parameter_list_add(ctx, $1, $3); }
290 /* ECMA-262 3rd Edition 13 */
291 FormalParameterList_opt
292 : /* empty */ { $$ = NULL; }
293 | FormalParameterList { $$ = $1; }
295 /* ECMA-262 3rd Edition 12 */
298 | VariableStatement { $$ = $1; }
299 | EmptyStatement { $$ = $1; }
300 | ExpressionStatement { $$ = $1; }
301 | IfStatement { $$ = $1; }
302 | IterationStatement { $$ = $1; }
303 | ContinueStatement { $$ = $1; }
304 | BreakStatement { $$ = $1; }
305 | ReturnStatement { $$ = $1; }
306 | WithStatement { $$ = $1; }
307 | LabelledStatement { $$ = $1; }
308 | SwitchStatement { $$ = $1; }
309 | ThrowStatement { $$ = $1; }
310 | TryStatement { $$ = $1; }
312 /* ECMA-262 3rd Edition 12.2 */
314 : Statement { $$ = new_statement_list(ctx, $1); }
315 | StatementList Statement
316 { $$ = statement_list_add($1, $2); }
318 /* ECMA-262 3rd Edition 12.2 */
320 : /* empty */ { $$ = NULL; }
321 | StatementList { $$ = $1; }
323 /* ECMA-262 3rd Edition 12.1 */
325 : '{' StatementList '}' { $$ = new_block_statement(ctx, $2); }
326 | '{' '}' { $$ = new_block_statement(ctx, NULL); }
328 /* ECMA-262 3rd Edition 12.2 */
330 : kVAR VariableDeclarationList semicolon_opt
331 { $$ = new_var_statement(ctx, $2); }
333 /* ECMA-262 3rd Edition 12.2 */
334 VariableDeclarationList
335 : VariableDeclaration { $$ = new_variable_list(ctx, $1); }
336 | VariableDeclarationList ',' VariableDeclaration
337 { $$ = variable_list_add(ctx, $1, $3); }
339 /* ECMA-262 3rd Edition 12.2 */
340 VariableDeclarationListNoIn
341 : VariableDeclarationNoIn
342 { $$ = new_variable_list(ctx, $1); }
343 | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
344 { $$ = variable_list_add(ctx, $1, $3); }
346 /* ECMA-262 3rd Edition 12.2 */
348 : tIdentifier Initialiser_opt
349 { $$ = new_variable_declaration(ctx, $1, $2); }
351 /* ECMA-262 3rd Edition 12.2 */
352 VariableDeclarationNoIn
353 : tIdentifier InitialiserNoIn_opt
354 { $$ = new_variable_declaration(ctx, $1, $2); }
356 /* ECMA-262 3rd Edition 12.2 */
358 : /* empty */ { $$ = NULL; }
359 | Initialiser { $$ = $1; }
361 /* ECMA-262 3rd Edition 12.2 */
363 : '=' AssignmentExpression
366 /* ECMA-262 3rd Edition 12.2 */
368 : /* empty */ { $$ = NULL; }
369 | InitialiserNoIn { $$ = $1; }
371 /* ECMA-262 3rd Edition 12.2 */
373 : '=' AssignmentExpressionNoIn
376 /* ECMA-262 3rd Edition 12.3 */
378 : ';' { $$ = new_empty_statement(ctx); }
380 /* ECMA-262 3rd Edition 12.4 */
382 : Expression semicolon_opt
383 { $$ = new_expression_statement(ctx, $1); }
385 /* ECMA-262 3rd Edition 12.5 */
387 : kIF left_bracket Expression_err right_bracket Statement kELSE Statement
388 { $$ = new_if_statement(ctx, $3, $5, $7); }
389 | kIF left_bracket Expression_err right_bracket Statement %prec LOWER_THAN_ELSE
390 { $$ = new_if_statement(ctx, $3, $5, NULL); }
392 /* ECMA-262 3rd Edition 12.6 */
394 : kDO Statement kWHILE left_bracket Expression_err right_bracket semicolon_opt
395 { $$ = new_while_statement(ctx, TRUE, $5, $2); }
396 | kWHILE left_bracket Expression_err right_bracket Statement
397 { $$ = new_while_statement(ctx, FALSE, $3, $5); }
398 | kFOR left_bracket ExpressionNoIn_opt
399 { if(!explicit_error(ctx, $3, ';')) YYABORT; }
400 semicolon Expression_opt
401 { if(!explicit_error(ctx, $6, ';')) YYABORT; }
402 semicolon Expression_opt right_bracket Statement
403 { $$ = new_for_statement(ctx, NULL, $3, $6, $9, $11); }
404 | kFOR left_bracket kVAR VariableDeclarationListNoIn
405 { if(!explicit_error(ctx, $4, ';')) YYABORT; }
406 semicolon Expression_opt
407 { if(!explicit_error(ctx, $7, ';')) YYABORT; }
408 semicolon Expression_opt right_bracket Statement
409 { $$ = new_for_statement(ctx, $4, NULL, $7, $10, $12); }
410 | kFOR left_bracket LeftHandSideExpression kIN Expression_err right_bracket Statement
411 { $$ = new_forin_statement(ctx, NULL, $3, $5, $7); }
412 | kFOR left_bracket kVAR VariableDeclarationNoIn kIN Expression_err right_bracket Statement
413 { $$ = new_forin_statement(ctx, $4, NULL, $6, $8); }
415 /* ECMA-262 3rd Edition 12.7 */
417 : kCONTINUE /* NONL */ Identifier_opt semicolon_opt
418 { $$ = new_continue_statement(ctx, $2); }
420 /* ECMA-262 3rd Edition 12.8 */
422 : kBREAK /* NONL */ Identifier_opt semicolon_opt
423 { $$ = new_break_statement(ctx, $2); }
425 /* ECMA-262 3rd Edition 12.9 */
427 : kRETURN /* NONL */ Expression_opt semicolon_opt
428 { $$ = new_return_statement(ctx, $2); }
430 /* ECMA-262 3rd Edition 12.10 */
432 : kWITH left_bracket Expression right_bracket Statement
433 { $$ = new_with_statement(ctx, $3, $5); }
435 /* ECMA-262 3rd Edition 12.12 */
437 : tIdentifier ':' Statement
438 { $$ = new_labelled_statement(ctx, $1, $3); }
440 /* ECMA-262 3rd Edition 12.11 */
442 : kSWITCH left_bracket Expression right_bracket CaseBlock
443 { $$ = new_switch_statement(ctx, $3, $5); }
445 /* ECMA-262 3rd Edition 12.11 */
447 : '{' CaseClausules_opt '}'
448 { $$ = new_case_block(ctx, $2, NULL, NULL); }
449 | '{' CaseClausules_opt DefaultClausule CaseClausules_opt '}'
450 { $$ = new_case_block(ctx, $2, $3, $4); }
452 /* ECMA-262 3rd Edition 12.11 */
454 : /* empty */ { $$ = NULL; }
455 | CaseClausules { $$ = $1; }
457 /* ECMA-262 3rd Edition 12.11 */
459 : CaseClausule { $$ = new_case_list(ctx, $1); }
460 | CaseClausules CaseClausule
461 { $$ = case_list_add(ctx, $1, $2); }
463 /* ECMA-262 3rd Edition 12.11 */
465 : kCASE Expression ':' StatementList_opt
466 { $$ = new_case_clausule(ctx, $2, $4); }
468 /* ECMA-262 3rd Edition 12.11 */
470 : kDEFAULT ':' StatementList_opt
471 { $$ = new_case_clausule(ctx, NULL, $3); }
473 /* ECMA-262 3rd Edition 12.13 */
475 : kTHROW /* NONL */ Expression semicolon_opt
476 { $$ = new_throw_statement(ctx, $2); }
478 /* ECMA-262 3rd Edition 12.14 */
480 : kTRY Block Catch { $$ = new_try_statement(ctx, $2, $3, NULL); }
481 | kTRY Block Finally { $$ = new_try_statement(ctx, $2, NULL, $3); }
482 | kTRY Block Catch Finally
483 { $$ = new_try_statement(ctx, $2, $3, $4); }
485 /* ECMA-262 3rd Edition 12.14 */
487 : kCATCH left_bracket tIdentifier right_bracket Block
488 { $$ = new_catch_block(ctx, $3, $5); }
490 /* ECMA-262 3rd Edition 12.14 */
492 : kFINALLY Block { $$ = $2; }
494 /* ECMA-262 3rd Edition 11.14 */
496 : /* empty */ { $$ = NULL; }
497 | Expression { $$ = $1; }
500 : Expression { $$ = $1; }
501 | error { set_error(ctx, IDS_SYNTAX_ERROR); YYABORT; }
503 /* ECMA-262 3rd Edition 11.14 */
505 : AssignmentExpression { $$ = $1; }
506 | Expression ',' AssignmentExpression
507 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
509 /* ECMA-262 3rd Edition 11.14 */
511 : /* empty */ { $$ = NULL; }
512 | ExpressionNoIn { $$ = $1; }
514 /* ECMA-262 3rd Edition 11.14 */
516 : AssignmentExpressionNoIn
518 | ExpressionNoIn ',' AssignmentExpressionNoIn
519 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
522 : tAssignOper { $$ = $1; }
523 | kDIVEQ { $$ = EXPR_ASSIGNDIV; }
525 /* ECMA-262 3rd Edition 11.13 */
527 : ConditionalExpression { $$ = $1; }
528 | LeftHandSideExpression '=' AssignmentExpression
529 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); }
530 | LeftHandSideExpression AssignOper AssignmentExpression
531 { $$ = new_binary_expression(ctx, $2, $1, $3); }
533 /* ECMA-262 3rd Edition 11.13 */
534 AssignmentExpressionNoIn
535 : ConditionalExpressionNoIn
537 | LeftHandSideExpression '=' AssignmentExpressionNoIn
538 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); }
539 | LeftHandSideExpression AssignOper AssignmentExpressionNoIn
540 { $$ = new_binary_expression(ctx, $2, $1, $3); }
542 /* ECMA-262 3rd Edition 11.12 */
543 ConditionalExpression
544 : LogicalORExpression { $$ = $1; }
545 | LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression
546 { $$ = new_conditional_expression(ctx, $1, $3, $5); }
548 /* ECMA-262 3rd Edition 11.12 */
549 ConditionalExpressionNoIn
550 : LogicalORExpressionNoIn
552 | LogicalORExpressionNoIn '?' AssignmentExpressionNoIn ':' AssignmentExpressionNoIn
553 { $$ = new_conditional_expression(ctx, $1, $3, $5); }
555 /* ECMA-262 3rd Edition 11.11 */
557 : LogicalANDExpression { $$ = $1; }
558 | LogicalORExpression tOROR LogicalANDExpression
559 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
561 /* ECMA-262 3rd Edition 11.11 */
562 LogicalORExpressionNoIn
563 : LogicalANDExpressionNoIn
565 | LogicalORExpressionNoIn tOROR LogicalANDExpressionNoIn
566 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
568 /* ECMA-262 3rd Edition 11.11 */
570 : BitwiseORExpression { $$ = $1; }
571 | LogicalANDExpression tANDAND BitwiseORExpression
572 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
574 /* ECMA-262 3rd Edition 11.11 */
575 LogicalANDExpressionNoIn
576 : BitwiseORExpressionNoIn
578 | LogicalANDExpressionNoIn tANDAND BitwiseORExpressionNoIn
579 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
581 /* ECMA-262 3rd Edition 11.10 */
583 : BitwiseXORExpression { $$ = $1; }
584 | BitwiseORExpression '|' BitwiseXORExpression
585 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
587 /* ECMA-262 3rd Edition 11.10 */
588 BitwiseORExpressionNoIn
589 : BitwiseXORExpressionNoIn
591 | BitwiseORExpressionNoIn '|' BitwiseXORExpressionNoIn
592 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
594 /* ECMA-262 3rd Edition 11.10 */
596 : BitwiseANDExpression { $$ = $1; }
597 | BitwiseXORExpression '^' BitwiseANDExpression
598 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
600 /* ECMA-262 3rd Edition 11.10 */
601 BitwiseXORExpressionNoIn
602 : BitwiseANDExpressionNoIn
604 | BitwiseXORExpressionNoIn '^' BitwiseANDExpressionNoIn
605 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
607 /* ECMA-262 3rd Edition 11.10 */
609 : EqualityExpression { $$ = $1; }
610 | BitwiseANDExpression '&' EqualityExpression
611 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
613 /* ECMA-262 3rd Edition 11.10 */
614 BitwiseANDExpressionNoIn
615 : EqualityExpressionNoIn
617 | BitwiseANDExpressionNoIn '&' EqualityExpressionNoIn
618 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
620 /* ECMA-262 3rd Edition 11.9 */
622 : RelationalExpression { $$ = $1; }
623 | EqualityExpression tEqOper RelationalExpression
624 { $$ = new_binary_expression(ctx, $2, $1, $3); }
626 /* ECMA-262 3rd Edition 11.9 */
627 EqualityExpressionNoIn
628 : RelationalExpressionNoIn { $$ = $1; }
629 | EqualityExpressionNoIn tEqOper RelationalExpressionNoIn
630 { $$ = new_binary_expression(ctx, $2, $1, $3); }
632 /* ECMA-262 3rd Edition 11.8 */
634 : ShiftExpression { $$ = $1; }
635 | RelationalExpression tRelOper ShiftExpression
636 { $$ = new_binary_expression(ctx, $2, $1, $3); }
637 | RelationalExpression kINSTANCEOF ShiftExpression
638 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); }
639 | RelationalExpression kIN ShiftExpression
640 { $$ = new_binary_expression(ctx, EXPR_IN, $1, $3); }
642 /* ECMA-262 3rd Edition 11.8 */
643 RelationalExpressionNoIn
644 : ShiftExpression { $$ = $1; }
645 | RelationalExpressionNoIn tRelOper ShiftExpression
646 { $$ = new_binary_expression(ctx, $2, $1, $3); }
647 | RelationalExpressionNoIn kINSTANCEOF ShiftExpression
648 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); }
650 /* ECMA-262 3rd Edition 11.7 */
652 : AdditiveExpression { $$ = $1; }
653 | ShiftExpression tShiftOper AdditiveExpression
654 { $$ = new_binary_expression(ctx, $2, $1, $3); }
656 /* ECMA-262 3rd Edition 11.6 */
658 : MultiplicativeExpression
660 | AdditiveExpression '+' MultiplicativeExpression
661 { $$ = new_binary_expression(ctx, EXPR_ADD, $1, $3); }
662 | AdditiveExpression '-' MultiplicativeExpression
663 { $$ = new_binary_expression(ctx, EXPR_SUB, $1, $3); }
665 /* ECMA-262 3rd Edition 11.5 */
666 MultiplicativeExpression
667 : UnaryExpression { $$ = $1; }
668 | MultiplicativeExpression '*' UnaryExpression
669 { $$ = new_binary_expression(ctx, EXPR_MUL, $1, $3); }
670 | MultiplicativeExpression '/' UnaryExpression
671 { $$ = new_binary_expression(ctx, EXPR_DIV, $1, $3); }
672 | MultiplicativeExpression '%' UnaryExpression
673 { $$ = new_binary_expression(ctx, EXPR_MOD, $1, $3); }
675 /* ECMA-262 3rd Edition 11.4 */
677 : PostfixExpression { $$ = $1; }
678 | kDELETE UnaryExpression
679 { $$ = new_unary_expression(ctx, EXPR_DELETE, $2); }
680 | kVOID UnaryExpression { $$ = new_unary_expression(ctx, EXPR_VOID, $2); }
681 | kTYPEOF UnaryExpression
682 { $$ = new_unary_expression(ctx, EXPR_TYPEOF, $2); }
683 | tINC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREINC, $2); }
684 | tDEC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREDEC, $2); }
685 | '+' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PLUS, $2); }
686 | '-' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_MINUS, $2); }
687 | '~' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_BITNEG, $2); }
688 | '!' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_LOGNEG, $2); }
690 /* ECMA-262 3rd Edition 11.2 */
692 : LeftHandSideExpression
694 | LeftHandSideExpression /* NONL */ tINC
695 { $$ = new_unary_expression(ctx, EXPR_POSTINC, $1); }
696 | LeftHandSideExpression /* NONL */ tDEC
697 { $$ = new_unary_expression(ctx, EXPR_POSTDEC, $1); }
700 /* ECMA-262 3rd Edition 11.2 */
701 LeftHandSideExpression
702 : NewExpression { $$ = $1; }
703 | CallExpression { $$ = $1; }
705 /* ECMA-262 3rd Edition 11.2 */
707 : MemberExpression { $$ = $1; }
708 | kNEW NewExpression { $$ = new_new_expression(ctx, $2, NULL); }
710 /* ECMA-262 3rd Edition 11.2 */
712 : PrimaryExpression { $$ = $1; }
713 | FunctionExpression { $$ = $1; }
714 | MemberExpression '[' Expression ']'
715 { $$ = new_array_expression(ctx, $1, $3); }
716 | MemberExpression '.' tIdentifier
717 { $$ = new_member_expression(ctx, $1, $3); }
718 | kNEW MemberExpression Arguments
719 { $$ = new_new_expression(ctx, $2, $3); }
721 /* ECMA-262 3rd Edition 11.2 */
723 : MemberExpression Arguments
724 { $$ = new_call_expression(ctx, $1, $2); }
725 | CallExpression Arguments
726 { $$ = new_call_expression(ctx, $1, $2); }
727 | CallExpression '[' Expression ']'
728 { $$ = new_array_expression(ctx, $1, $3); }
729 | CallExpression '.' tIdentifier
730 { $$ = new_member_expression(ctx, $1, $3); }
732 /* ECMA-262 3rd Edition 11.2 */
734 : '(' ')' { $$ = NULL; }
735 | '(' ArgumentList ')' { $$ = $2; }
737 /* ECMA-262 3rd Edition 11.2 */
739 : AssignmentExpression { $$ = new_argument_list(ctx, $1); }
740 | ArgumentList ',' AssignmentExpression
741 { $$ = argument_list_add(ctx, $1, $3); }
743 /* ECMA-262 3rd Edition 11.1 */
745 : kTHIS { $$ = new_this_expression(ctx); }
746 | tIdentifier { $$ = new_identifier_expression(ctx, $1); }
747 | Literal { $$ = new_literal_expression(ctx, $1); }
748 | ArrayLiteral { $$ = $1; }
749 | ObjectLiteral { $$ = $1; }
750 | '(' Expression ')' { $$ = $2; }
752 /* ECMA-262 3rd Edition 11.1.4 */
754 : '[' ']' { $$ = new_array_literal_expression(ctx, NULL, 0); }
755 | '[' Elision ']' { $$ = new_array_literal_expression(ctx, NULL, $2+1); }
756 | '[' ElementList ']' { $$ = new_array_literal_expression(ctx, $2, 0); }
757 | '[' ElementList ',' Elision_opt ']'
758 { $$ = new_array_literal_expression(ctx, $2, $4+1); }
760 /* ECMA-262 3rd Edition 11.1.4 */
762 : Elision_opt AssignmentExpression
763 { $$ = new_element_list(ctx, $1, $2); }
764 | ElementList ',' Elision_opt AssignmentExpression
765 { $$ = element_list_add(ctx, $1, $3, $4); }
767 /* ECMA-262 3rd Edition 11.1.4 */
770 | Elision ',' { $$ = $1 + 1; }
772 /* ECMA-262 3rd Edition 11.1.4 */
774 : /* empty */ { $$ = 0; }
775 | Elision { $$ = $1; }
777 /* ECMA-262 3rd Edition 11.1.5 */
779 : '{' '}' { $$ = new_prop_and_value_expression(ctx, NULL); }
780 | '{' PropertyNameAndValueList '}'
781 { $$ = new_prop_and_value_expression(ctx, $2); }
783 /* ECMA-262 3rd Edition 11.1.5 */
784 PropertyNameAndValueList
785 : PropertyName ':' AssignmentExpression
786 { $$ = new_property_list(ctx, $1, $3); }
787 | PropertyNameAndValueList ',' PropertyName ':' AssignmentExpression
788 { $$ = property_list_add(ctx, $1, $3, $5); }
790 /* ECMA-262 3rd Edition 11.1.5 */
792 : tIdentifier { $$ = new_string_literal(ctx, $1); }
793 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
794 | tNumericLiteral { $$ = $1; }
796 /* ECMA-262 3rd Edition 7.6 */
798 : /* empty*/ { $$ = NULL; }
799 | tIdentifier { $$ = $1; }
801 /* ECMA-262 3rd Edition 7.8 */
803 : kNULL { $$ = new_null_literal(ctx); }
804 | kUNDEFINED { $$ = new_undefined_literal(ctx); }
805 | BooleanLiteral { $$ = $1; }
806 | tNumericLiteral { $$ = $1; }
807 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
808 | '/' { $$ = parse_regexp(ctx);
810 | kDIVEQ { $$ = parse_regexp(ctx);
813 /* ECMA-262 3rd Edition 7.8.2 */
815 : kTRUE { $$ = new_boolean_literal(ctx, VARIANT_TRUE); }
816 | kFALSE { $$ = new_boolean_literal(ctx, VARIANT_FALSE); }
820 | error { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
824 | error { set_error(ctx, IDS_LBRACKET); YYABORT; }
828 | error { set_error(ctx, IDS_RBRACKET); YYABORT; }
832 | error { set_error(ctx, IDS_SEMICOLON); YYABORT; }
836 static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
838 return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
841 static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str)
843 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
851 static literal_t *new_null_literal(parser_ctx_t *ctx)
853 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
860 static literal_t *new_undefined_literal(parser_ctx_t *ctx)
862 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
869 static literal_t *new_boolean_literal(parser_ctx_t *ctx, VARIANT_BOOL bval)
871 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
879 static prop_val_t *new_prop_val(parser_ctx_t *ctx, literal_t *name, expression_t *value)
881 prop_val_t *ret = parser_alloc(ctx, sizeof(prop_val_t));
890 static property_list_t *new_property_list(parser_ctx_t *ctx, literal_t *name, expression_t *value)
892 property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t));
894 ret->head = ret->tail = new_prop_val(ctx, name, value);
899 static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list, literal_t *name, expression_t *value)
901 list->tail = list->tail->next = new_prop_val(ctx, name, value);
906 static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr)
908 array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t));
910 ret->elision = elision;
917 static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t *expr)
919 element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t));
921 ret->head = ret->tail = new_array_element(ctx, elision, expr);
926 static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int elision, expression_t *expr)
928 list->tail = list->tail->next = new_array_element(ctx, elision, expr);
933 static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr)
935 argument_t *ret = parser_alloc(ctx, sizeof(argument_t));
943 static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr)
945 argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t));
947 ret->head = ret->tail = new_argument(ctx, expr);
952 static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list, expression_t *expr)
954 list->tail = list->tail->next = new_argument(ctx, expr);
959 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
961 catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t));
963 ret->identifier = identifier;
964 ret->statement = statement;
969 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_list_t *stat_list)
971 case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t));
974 ret->stat = stat_list ? stat_list->head : NULL;
980 static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule)
982 case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t));
984 ret->head = ret->tail = case_clausule;
989 static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t *case_clausule)
991 list->tail = list->tail->next = case_clausule;
996 static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1,
997 case_clausule_t *default_clausule, case_list_t *case_list2)
999 case_clausule_t *ret = NULL, *iter = NULL, *iter2;
1000 statement_t *stat = NULL;
1003 ret = case_list1->head;
1004 iter = case_list1->tail;
1007 if(default_clausule) {
1009 iter = iter->next = default_clausule;
1011 ret = iter = default_clausule;
1016 iter->next = case_list2->head;
1018 ret = case_list2->head;
1024 for(iter = ret; iter; iter = iter->next) {
1025 for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next);
1029 while(iter != iter2) {
1030 iter->stat = iter2->stat;
1037 stat->next = iter->stat;
1046 static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list)
1048 block_statement_t *ret = parser_alloc(ctx, sizeof(block_statement_t));
1050 ret->stat.eval = block_statement_eval;
1051 ret->stat.next = NULL;
1052 ret->stat_list = list ? list->head : NULL;
1057 static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *expr)
1059 variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t));
1060 var_list_t *var_list = parser_alloc(ctx, sizeof(var_list_t));
1062 ret->identifier = identifier;
1066 var_list->identifier = identifier;
1067 var_list->next = NULL;
1069 if(ctx->func_stack->var_tail)
1070 ctx->func_stack->var_tail = ctx->func_stack->var_tail->next = var_list;
1072 ctx->func_stack->var_head = ctx->func_stack->var_tail = var_list;
1077 static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t *decl)
1079 variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t));
1081 ret->head = ret->tail = decl;
1086 static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list, variable_declaration_t *decl)
1088 list->tail = list->tail->next = decl;
1093 static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list)
1095 var_statement_t *ret = parser_alloc(ctx, sizeof(var_statement_t));
1097 ret->stat.eval = var_statement_eval;
1098 ret->stat.next = NULL;
1099 ret->variable_list = variable_list->head;
1104 static statement_t *new_empty_statement(parser_ctx_t *ctx)
1106 statement_t *ret = parser_alloc(ctx, sizeof(statement_t));
1108 ret->eval = empty_statement_eval;
1114 static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr)
1116 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
1118 ret->stat.eval = expression_statement_eval;
1119 ret->stat.next = NULL;
1125 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, statement_t *else_stat)
1127 if_statement_t *ret = parser_alloc(ctx, sizeof(if_statement_t));
1129 ret->stat.eval = if_statement_eval;
1130 ret->stat.next = NULL;
1132 ret->if_stat = if_stat;
1133 ret->else_stat = else_stat;
1138 static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t *expr, statement_t *stat)
1140 while_statement_t *ret = parser_alloc(ctx, sizeof(while_statement_t));
1142 ret->stat.eval = while_statement_eval;
1143 ret->stat.next = NULL;
1144 ret->do_while = dowhile;
1146 ret->statement = stat;
1151 static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr,
1152 expression_t *expr, expression_t *end_expr, statement_t *statement)
1154 for_statement_t *ret = parser_alloc(ctx, sizeof(for_statement_t));
1156 ret->stat.eval = for_statement_eval;
1157 ret->stat.next = NULL;
1158 ret->variable_list = variable_list ? variable_list->head : NULL;
1159 ret->begin_expr = begin_expr;
1161 ret->end_expr = end_expr;
1162 ret->statement = statement;
1167 static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t *variable, expression_t *expr,
1168 expression_t *in_expr, statement_t *statement)
1170 forin_statement_t *ret = parser_alloc(ctx, sizeof(forin_statement_t));
1172 ret->stat.eval = forin_statement_eval;
1173 ret->stat.next = NULL;
1174 ret->variable = variable;
1176 ret->in_expr = in_expr;
1177 ret->statement = statement;
1182 static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier)
1184 branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t));
1186 ret->stat.eval = continue_statement_eval;
1187 ret->stat.next = NULL;
1188 ret->identifier = identifier;
1193 static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier)
1195 branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t));
1197 ret->stat.eval = break_statement_eval;
1198 ret->stat.next = NULL;
1199 ret->identifier = identifier;
1204 static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr)
1206 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
1208 ret->stat.eval = return_statement_eval;
1209 ret->stat.next = NULL;
1215 static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *statement)
1217 with_statement_t *ret = parser_alloc(ctx, sizeof(with_statement_t));
1219 ret->stat.eval = with_statement_eval;
1220 ret->stat.next = NULL;
1222 ret->statement = statement;
1227 static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
1229 labelled_statement_t *ret = parser_alloc(ctx, sizeof(labelled_statement_t));
1231 ret->stat.eval = labelled_statement_eval;
1232 ret->stat.next = NULL;
1233 ret->identifier = identifier;
1234 ret->statement = statement;
1239 static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_list)
1241 switch_statement_t *ret = parser_alloc(ctx, sizeof(switch_statement_t));
1243 ret->stat.eval = switch_statement_eval;
1244 ret->stat.next = NULL;
1246 ret->case_list = case_list;
1251 static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr)
1253 expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
1255 ret->stat.eval = throw_statement_eval;
1256 ret->stat.next = NULL;
1262 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement,
1263 catch_block_t *catch_block, statement_t *finally_statement)
1265 try_statement_t *ret = parser_alloc(ctx, sizeof(try_statement_t));
1267 ret->stat.eval = try_statement_eval;
1268 ret->stat.next = NULL;
1269 ret->try_statement = try_statement;
1270 ret->catch_block = catch_block;
1271 ret->finally_statement = finally_statement;
1276 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
1278 parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t));
1280 ret->identifier = identifier;
1286 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier)
1288 parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t));
1290 ret->head = ret->tail = new_parameter(ctx, identifier);
1295 static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list, const WCHAR *identifier)
1297 list->tail = list->tail->next = new_parameter(ctx, identifier);
1302 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier,
1303 parameter_list_t *parameter_list, source_elements_t *source_elements, const WCHAR *src_str, DWORD src_len)
1305 function_expression_t *ret = parser_alloc(ctx, sizeof(function_expression_t));
1307 ret->expr.eval = function_expression_eval;
1308 ret->identifier = identifier;
1309 ret->parameter_list = parameter_list ? parameter_list->head : NULL;
1310 ret->source_elements = source_elements;
1311 ret->src_str = src_str;
1312 ret->src_len = src_len;
1314 if(ret->identifier) {
1315 function_declaration_t *decl = parser_alloc(ctx, sizeof(function_declaration_t));
1320 if(ctx->func_stack->func_tail)
1321 ctx->func_stack->func_tail = ctx->func_stack->func_tail->next = decl;
1323 ctx->func_stack->func_head = ctx->func_stack->func_tail = decl;
1329 static const expression_eval_t expression_eval_table[] = {
1330 comma_expression_eval,
1331 logical_or_expression_eval,
1332 logical_and_expression_eval,
1333 binary_or_expression_eval,
1334 binary_xor_expression_eval,
1335 binary_and_expression_eval,
1336 instanceof_expression_eval,
1338 add_expression_eval,
1339 sub_expression_eval,
1340 mul_expression_eval,
1341 div_expression_eval,
1342 mod_expression_eval,
1343 delete_expression_eval,
1344 void_expression_eval,
1345 typeof_expression_eval,
1346 minus_expression_eval,
1347 plus_expression_eval,
1348 post_increment_expression_eval,
1349 post_decrement_expression_eval,
1350 pre_increment_expression_eval,
1351 pre_decrement_expression_eval,
1352 equal_expression_eval,
1353 equal2_expression_eval,
1354 not_equal_expression_eval,
1355 not_equal2_expression_eval,
1356 less_expression_eval,
1357 lesseq_expression_eval,
1358 greater_expression_eval,
1359 greatereq_expression_eval,
1360 binary_negation_expression_eval,
1361 logical_negation_expression_eval,
1362 left_shift_expression_eval,
1363 right_shift_expression_eval,
1364 right2_shift_expression_eval,
1365 assign_expression_eval,
1366 assign_lshift_expression_eval,
1367 assign_rshift_expression_eval,
1368 assign_rrshift_expression_eval,
1369 assign_add_expression_eval,
1370 assign_sub_expression_eval,
1371 assign_mul_expression_eval,
1372 assign_div_expression_eval,
1373 assign_mod_expression_eval,
1374 assign_and_expression_eval,
1375 assign_or_expression_eval,
1376 assign_xor_expression_eval,
1379 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type,
1380 expression_t *expression1, expression_t *expression2)
1382 binary_expression_t *ret = parser_alloc(ctx, sizeof(binary_expression_t));
1384 ret->expr.eval = expression_eval_table[type];
1385 ret->expression1 = expression1;
1386 ret->expression2 = expression2;
1391 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *expression)
1393 unary_expression_t *ret = parser_alloc(ctx, sizeof(unary_expression_t));
1395 ret->expr.eval = expression_eval_table[type];
1396 ret->expression = expression;
1401 static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t *expression,
1402 expression_t *true_expression, expression_t *false_expression)
1404 conditional_expression_t *ret = parser_alloc(ctx, sizeof(conditional_expression_t));
1406 ret->expr.eval = conditional_expression_eval;
1407 ret->expression = expression;
1408 ret->true_expression = true_expression;
1409 ret->false_expression = false_expression;
1414 static expression_t *new_array_expression(parser_ctx_t *ctx, expression_t *member_expr, expression_t *expression)
1416 array_expression_t *ret = parser_alloc(ctx, sizeof(array_expression_t));
1418 ret->expr.eval = array_expression_eval;
1419 ret->member_expr = member_expr;
1420 ret->expression = expression;
1425 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier)
1427 member_expression_t *ret = parser_alloc(ctx, sizeof(member_expression_t));
1429 ret->expr.eval = member_expression_eval;
1430 ret->expression = expression;
1431 ret->identifier = identifier;
1436 static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1438 call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t));
1440 ret->expr.eval = new_expression_eval;
1441 ret->expression = expression;
1442 ret->argument_list = argument_list ? argument_list->head : NULL;
1447 static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1449 call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t));
1451 ret->expr.eval = call_expression_eval;
1452 ret->expression = expression;
1453 ret->argument_list = argument_list ? argument_list->head : NULL;
1458 static expression_t *new_this_expression(parser_ctx_t *ctx)
1460 expression_t *ret = parser_alloc(ctx, sizeof(expression_t));
1462 ret->eval = this_expression_eval;
1467 static int parser_error(const char *str)
1472 static void set_error(parser_ctx_t *ctx, UINT error)
1474 ctx->hres = JSCRIPT_ERROR|error;
1477 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next)
1479 if(obj || *(ctx->ptr-1)==next) return TRUE;
1481 set_error(ctx, IDS_SYNTAX_ERROR);
1486 static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR *identifier)
1488 identifier_expression_t *ret = parser_alloc(ctx, sizeof(identifier_expression_t));
1490 ret->expr.eval = identifier_expression_eval;
1491 ret->identifier = identifier;
1496 static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t *element_list, int length)
1498 array_literal_expression_t *ret = parser_alloc(ctx, sizeof(array_literal_expression_t));
1500 ret->expr.eval = array_literal_expression_eval;
1501 ret->element_list = element_list ? element_list->head : NULL;
1502 ret->length = length;
1507 static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t *property_list)
1509 property_value_expression_t *ret = parser_alloc(ctx, sizeof(property_value_expression_t));
1511 ret->expr.eval = property_value_expression_eval;
1512 ret->property_list = property_list ? property_list->head : NULL;
1517 static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal)
1519 literal_expression_t *ret = parser_alloc(ctx, sizeof(literal_expression_t));
1521 ret->expr.eval = literal_expression_eval;
1522 ret->literal = literal;
1527 static source_elements_t *new_source_elements(parser_ctx_t *ctx)
1529 source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t));
1531 memset(ret, 0, sizeof(*ret));
1536 static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement)
1538 if(source_elements->statement_tail)
1539 source_elements->statement_tail = source_elements->statement_tail->next = statement;
1541 source_elements->statement = source_elements->statement_tail = statement;
1543 return source_elements;
1546 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement)
1548 statement_list_t *ret = parser_alloc_tmp(ctx, sizeof(statement_list_t));
1550 ret->head = ret->tail = statement;
1555 static statement_list_t *statement_list_add(statement_list_t *list, statement_t *statement)
1557 list->tail = list->tail->next = statement;
1562 static void push_func(parser_ctx_t *ctx)
1564 func_stack_t *new_func = parser_alloc_tmp(ctx, sizeof(func_stack_t));
1566 new_func->func_head = new_func->func_tail = NULL;
1567 new_func->var_head = new_func->var_tail = NULL;
1569 new_func->next = ctx->func_stack;
1570 ctx->func_stack = new_func;
1573 static source_elements_t *function_body_parsed(parser_ctx_t *ctx, source_elements_t *source)
1575 source->functions = ctx->func_stack->func_head;
1576 source->variables = ctx->func_stack->var_head;
1582 static void program_parsed(parser_ctx_t *ctx, source_elements_t *source)
1584 source->functions = ctx->func_stack->func_head;
1585 source->variables = ctx->func_stack->var_head;
1588 ctx->source = source;
1589 if(!ctx->lexer_error)
1593 void parser_release(parser_ctx_t *ctx)
1595 obj_literal_t *iter;
1600 for(iter = ctx->obj_literals; iter; iter = iter->next)
1601 jsdisp_release(iter->obj);
1603 jsheap_free(&ctx->heap);
1607 HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter,
1610 parser_ctx_t *parser_ctx;
1614 const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0};
1616 parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
1618 return E_OUTOFMEMORY;
1620 parser_ctx->ref = 1;
1621 parser_ctx->hres = JSCRIPT_ERROR|IDS_SYNTAX_ERROR;
1622 parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
1624 parser_ctx->begin = parser_ctx->ptr = code;
1625 parser_ctx->end = code + strlenW(code);
1628 parser_ctx->script = ctx;
1630 mark = jsheap_mark(&ctx->tmp_heap);
1631 jsheap_init(&parser_ctx->heap);
1633 push_func(parser_ctx);
1635 parser_parse(parser_ctx);
1637 if(FAILED(parser_ctx->hres)) {
1638 hres = parser_ctx->hres;
1639 parser_release(parser_ctx);