jscript: No longer support per-statement compilation.
[wine/multimedia.git] / dlls / jscript / parser.y
bloba3fe42a885f109c3bffc980563489ec138921283
1 /*
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
21 #include "jscript.h"
22 #include "engine.h"
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 {
35 statement_t *head;
36 statement_t *tail;
37 } 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*);
42 typedef struct _property_list_t {
43 prop_val_t *head;
44 prop_val_t *tail;
45 } property_list_t;
47 static property_list_t *new_property_list(parser_ctx_t*,literal_t*,expression_t*);
48 static property_list_t *property_list_add(parser_ctx_t*,property_list_t*,literal_t*,expression_t*);
50 typedef struct _element_list_t {
51 array_element_t *head;
52 array_element_t *tail;
53 } element_list_t;
55 static element_list_t *new_element_list(parser_ctx_t*,int,expression_t*);
56 static element_list_t *element_list_add(parser_ctx_t*,element_list_t*,int,expression_t*);
58 typedef struct _argument_list_t {
59 argument_t *head;
60 argument_t *tail;
61 } argument_list_t;
63 static argument_list_t *new_argument_list(parser_ctx_t*,expression_t*);
64 static argument_list_t *argument_list_add(parser_ctx_t*,argument_list_t*,expression_t*);
66 typedef struct _case_list_t {
67 case_clausule_t *head;
68 case_clausule_t *tail;
69 } case_list_t;
71 static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*);
72 static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*);
73 static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*);
74 static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*);
75 static case_clausule_t *new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*);
77 typedef struct _variable_list_t {
78 variable_declaration_t *head;
79 variable_declaration_t *tail;
80 } variable_list_t;
82 static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const WCHAR*,expression_t*);
83 static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*);
84 static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*);
86 static void *new_statement(parser_ctx_t*,statement_type_t,size_t);
87 static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*);
88 static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*);
89 static statement_t *new_expression_statement(parser_ctx_t*,expression_t*);
90 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*);
91 static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*);
92 static statement_t *new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*,
93 expression_t*,statement_t*);
94 static statement_t *new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
95 static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*);
96 static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*);
97 static statement_t *new_return_statement(parser_ctx_t*,expression_t*);
98 static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*);
99 static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*);
100 static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
101 static statement_t *new_throw_statement(parser_ctx_t*,expression_t*);
102 static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*);
104 struct statement_list_t {
105 statement_t *head;
106 statement_t *tail;
109 static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*);
110 static statement_list_t *statement_list_add(statement_list_t*,statement_t*);
112 typedef struct _parameter_list_t {
113 parameter_t *head;
114 parameter_t *tail;
115 } parameter_list_t;
117 static parameter_list_t *new_parameter_list(parser_ctx_t*,const WCHAR*);
118 static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,const WCHAR*);
120 static void push_func(parser_ctx_t*);
121 static inline void pop_func(parser_ctx_t *ctx)
123 ctx->func_stack = ctx->func_stack->next;
126 static void *new_expression(parser_ctx_t *ctx,expression_type_t,size_t);
127 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*,
128 source_elements_t*,const WCHAR*,DWORD);
129 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
130 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
131 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*);
132 static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
133 static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*);
134 static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*);
135 static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*);
136 static expression_t *new_literal_expression(parser_ctx_t*,literal_t*);
137 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int);
138 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*);
140 static source_elements_t *new_source_elements(parser_ctx_t*);
141 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*);
145 %pure_parser
146 %start Program
148 %union {
149 int ival;
150 const WCHAR *srcptr;
151 LPCWSTR wstr;
152 literal_t *literal;
153 struct _argument_list_t *argument_list;
154 case_clausule_t *case_clausule;
155 struct _case_list_t *case_list;
156 catch_block_t *catch_block;
157 struct _element_list_t *element_list;
158 expression_t *expr;
159 const WCHAR *identifier;
160 struct _parameter_list_t *parameter_list;
161 struct _property_list_t *property_list;
162 source_elements_t *source_elements;
163 statement_t *statement;
164 struct _statement_list_t *statement_list;
165 struct _variable_list_t *variable_list;
166 variable_declaration_t *variable_declaration;
169 /* keywords */
170 %token kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kIF kFINALLY kFOR kIN
171 %token kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH
172 %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ
174 %token <srcptr> kFUNCTION '}'
176 /* tokens */
177 %token <identifier> tIdentifier
178 %token <ival> tAssignOper tEqOper tShiftOper tRelOper
179 %token <literal> tNumericLiteral tBooleanLiteral
180 %token <wstr> tStringLiteral
181 %token tEOF
183 %type <source_elements> SourceElements
184 %type <source_elements> FunctionBody
185 %type <statement> Statement
186 %type <statement> Block
187 %type <statement> VariableStatement
188 %type <statement> EmptyStatement
189 %type <statement> ExpressionStatement
190 %type <statement> IfStatement
191 %type <statement> IterationStatement
192 %type <statement> ContinueStatement
193 %type <statement> BreakStatement
194 %type <statement> ReturnStatement
195 %type <statement> WithStatement
196 %type <statement> LabelledStatement
197 %type <statement> SwitchStatement
198 %type <statement> ThrowStatement
199 %type <statement> TryStatement
200 %type <statement> Finally
201 %type <statement_list> StatementList StatementList_opt
202 %type <parameter_list> FormalParameterList FormalParameterList_opt
203 %type <expr> Expression Expression_opt Expression_err
204 %type <expr> ExpressionNoIn ExpressionNoIn_opt
205 %type <expr> FunctionExpression
206 %type <expr> AssignmentExpression AssignmentExpressionNoIn
207 %type <expr> ConditionalExpression ConditionalExpressionNoIn
208 %type <expr> LeftHandSideExpression
209 %type <expr> LogicalORExpression LogicalORExpressionNoIn
210 %type <expr> LogicalANDExpression LogicalANDExpressionNoIn
211 %type <expr> BitwiseORExpression BitwiseORExpressionNoIn
212 %type <expr> BitwiseXORExpression BitwiseXORExpressionNoIn
213 %type <expr> BitwiseANDExpression BitwiseANDExpressionNoIn
214 %type <expr> EqualityExpression EqualityExpressionNoIn
215 %type <expr> RelationalExpression RelationalExpressionNoIn
216 %type <expr> ShiftExpression
217 %type <expr> AdditiveExpression
218 %type <expr> MultiplicativeExpression
219 %type <expr> Initialiser_opt Initialiser
220 %type <expr> InitialiserNoIn_opt InitialiserNoIn
221 %type <expr> UnaryExpression
222 %type <expr> PostfixExpression
223 %type <expr> NewExpression
224 %type <expr> CallExpression
225 %type <expr> MemberExpression
226 %type <expr> PrimaryExpression
227 %type <identifier> Identifier_opt
228 %type <variable_list> VariableDeclarationList
229 %type <variable_list> VariableDeclarationListNoIn
230 %type <variable_declaration> VariableDeclaration
231 %type <variable_declaration> VariableDeclarationNoIn
232 %type <case_list> CaseClausules CaseClausules_opt
233 %type <case_clausule> CaseClausule DefaultClausule CaseBlock
234 %type <catch_block> Catch
235 %type <argument_list> Arguments
236 %type <argument_list> ArgumentList
237 %type <literal> Literal
238 %type <expr> ArrayLiteral
239 %type <expr> ObjectLiteral
240 %type <ival> Elision Elision_opt
241 %type <element_list> ElementList
242 %type <property_list> PropertyNameAndValueList
243 %type <literal> PropertyName
244 %type <literal> BooleanLiteral
245 %type <srcptr> KFunction
246 %type <ival> AssignOper
248 %nonassoc LOWER_THAN_ELSE
249 %nonassoc kELSE
253 /* ECMA-262 3rd Edition 14 */
254 Program
255 : SourceElements HtmlComment tEOF
256 { program_parsed(ctx, $1); }
258 HtmlComment
259 : tHTMLCOMMENT {}
260 | /* empty */ {}
262 /* ECMA-262 3rd Edition 14 */
263 SourceElements
264 : /* empty */ { $$ = new_source_elements(ctx); }
265 | SourceElements Statement
266 { $$ = source_elements_add_statement($1, $2); }
268 /* ECMA-262 3rd Edition 13 */
269 FunctionExpression
270 : KFunction Identifier_opt left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
271 { $$ = new_function_expression(ctx, $2, $4, $7, $1, $8-$1+1); }
273 KFunction
274 : kFUNCTION { push_func(ctx); $$ = $1; }
276 /* ECMA-262 3rd Edition 13 */
277 FunctionBody
278 : SourceElements { $$ = function_body_parsed(ctx, $1); }
280 /* ECMA-262 3rd Edition 13 */
281 FormalParameterList
282 : tIdentifier { $$ = new_parameter_list(ctx, $1); }
283 | FormalParameterList ',' tIdentifier
284 { $$ = parameter_list_add(ctx, $1, $3); }
286 /* ECMA-262 3rd Edition 13 */
287 FormalParameterList_opt
288 : /* empty */ { $$ = NULL; }
289 | FormalParameterList { $$ = $1; }
291 /* ECMA-262 3rd Edition 12 */
292 Statement
293 : Block { $$ = $1; }
294 | VariableStatement { $$ = $1; }
295 | EmptyStatement { $$ = $1; }
296 | FunctionExpression { $$ = new_statement(ctx, STAT_EMPTY, 0); }
297 | ExpressionStatement { $$ = $1; }
298 | IfStatement { $$ = $1; }
299 | IterationStatement { $$ = $1; }
300 | ContinueStatement { $$ = $1; }
301 | BreakStatement { $$ = $1; }
302 | ReturnStatement { $$ = $1; }
303 | WithStatement { $$ = $1; }
304 | LabelledStatement { $$ = $1; }
305 | SwitchStatement { $$ = $1; }
306 | ThrowStatement { $$ = $1; }
307 | TryStatement { $$ = $1; }
309 /* ECMA-262 3rd Edition 12.2 */
310 StatementList
311 : Statement { $$ = new_statement_list(ctx, $1); }
312 | StatementList Statement
313 { $$ = statement_list_add($1, $2); }
315 /* ECMA-262 3rd Edition 12.2 */
316 StatementList_opt
317 : /* empty */ { $$ = NULL; }
318 | StatementList { $$ = $1; }
320 /* ECMA-262 3rd Edition 12.1 */
321 Block
322 : '{' StatementList '}' { $$ = new_block_statement(ctx, $2); }
323 | '{' '}' { $$ = new_block_statement(ctx, NULL); }
325 /* ECMA-262 3rd Edition 12.2 */
326 VariableStatement
327 : kVAR VariableDeclarationList semicolon_opt
328 { $$ = new_var_statement(ctx, $2); }
330 /* ECMA-262 3rd Edition 12.2 */
331 VariableDeclarationList
332 : VariableDeclaration { $$ = new_variable_list(ctx, $1); }
333 | VariableDeclarationList ',' VariableDeclaration
334 { $$ = variable_list_add(ctx, $1, $3); }
336 /* ECMA-262 3rd Edition 12.2 */
337 VariableDeclarationListNoIn
338 : VariableDeclarationNoIn
339 { $$ = new_variable_list(ctx, $1); }
340 | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
341 { $$ = variable_list_add(ctx, $1, $3); }
343 /* ECMA-262 3rd Edition 12.2 */
344 VariableDeclaration
345 : tIdentifier Initialiser_opt
346 { $$ = new_variable_declaration(ctx, $1, $2); }
348 /* ECMA-262 3rd Edition 12.2 */
349 VariableDeclarationNoIn
350 : tIdentifier InitialiserNoIn_opt
351 { $$ = new_variable_declaration(ctx, $1, $2); }
353 /* ECMA-262 3rd Edition 12.2 */
354 Initialiser_opt
355 : /* empty */ { $$ = NULL; }
356 | Initialiser { $$ = $1; }
358 /* ECMA-262 3rd Edition 12.2 */
359 Initialiser
360 : '=' AssignmentExpression
361 { $$ = $2; }
363 /* ECMA-262 3rd Edition 12.2 */
364 InitialiserNoIn_opt
365 : /* empty */ { $$ = NULL; }
366 | InitialiserNoIn { $$ = $1; }
368 /* ECMA-262 3rd Edition 12.2 */
369 InitialiserNoIn
370 : '=' AssignmentExpressionNoIn
371 { $$ = $2; }
373 /* ECMA-262 3rd Edition 12.3 */
374 EmptyStatement
375 : ';' { $$ = new_statement(ctx, STAT_EMPTY, 0); }
377 /* ECMA-262 3rd Edition 12.4 */
378 ExpressionStatement
379 : Expression semicolon_opt
380 { $$ = new_expression_statement(ctx, $1); }
382 /* ECMA-262 3rd Edition 12.5 */
383 IfStatement
384 : kIF left_bracket Expression_err right_bracket Statement kELSE Statement
385 { $$ = new_if_statement(ctx, $3, $5, $7); }
386 | kIF left_bracket Expression_err right_bracket Statement %prec LOWER_THAN_ELSE
387 { $$ = new_if_statement(ctx, $3, $5, NULL); }
389 /* ECMA-262 3rd Edition 12.6 */
390 IterationStatement
391 : kDO Statement kWHILE left_bracket Expression_err right_bracket semicolon_opt
392 { $$ = new_while_statement(ctx, TRUE, $5, $2); }
393 | kWHILE left_bracket Expression_err right_bracket Statement
394 { $$ = new_while_statement(ctx, FALSE, $3, $5); }
395 | kFOR left_bracket ExpressionNoIn_opt
396 { if(!explicit_error(ctx, $3, ';')) YYABORT; }
397 semicolon Expression_opt
398 { if(!explicit_error(ctx, $6, ';')) YYABORT; }
399 semicolon Expression_opt right_bracket Statement
400 { $$ = new_for_statement(ctx, NULL, $3, $6, $9, $11); }
401 | kFOR left_bracket kVAR VariableDeclarationListNoIn
402 { if(!explicit_error(ctx, $4, ';')) YYABORT; }
403 semicolon Expression_opt
404 { if(!explicit_error(ctx, $7, ';')) YYABORT; }
405 semicolon Expression_opt right_bracket Statement
406 { $$ = new_for_statement(ctx, $4, NULL, $7, $10, $12); }
407 | kFOR left_bracket LeftHandSideExpression kIN Expression_err right_bracket Statement
408 { $$ = new_forin_statement(ctx, NULL, $3, $5, $7); }
409 | kFOR left_bracket kVAR VariableDeclarationNoIn kIN Expression_err right_bracket Statement
410 { $$ = new_forin_statement(ctx, $4, NULL, $6, $8); }
412 /* ECMA-262 3rd Edition 12.7 */
413 ContinueStatement
414 : kCONTINUE /* NONL */ Identifier_opt semicolon_opt
415 { $$ = new_continue_statement(ctx, $2); }
417 /* ECMA-262 3rd Edition 12.8 */
418 BreakStatement
419 : kBREAK /* NONL */ Identifier_opt semicolon_opt
420 { $$ = new_break_statement(ctx, $2); }
422 /* ECMA-262 3rd Edition 12.9 */
423 ReturnStatement
424 : kRETURN /* NONL */ Expression_opt semicolon_opt
425 { $$ = new_return_statement(ctx, $2); }
427 /* ECMA-262 3rd Edition 12.10 */
428 WithStatement
429 : kWITH left_bracket Expression right_bracket Statement
430 { $$ = new_with_statement(ctx, $3, $5); }
432 /* ECMA-262 3rd Edition 12.12 */
433 LabelledStatement
434 : tIdentifier ':' Statement
435 { $$ = new_labelled_statement(ctx, $1, $3); }
437 /* ECMA-262 3rd Edition 12.11 */
438 SwitchStatement
439 : kSWITCH left_bracket Expression right_bracket CaseBlock
440 { $$ = new_switch_statement(ctx, $3, $5); }
442 /* ECMA-262 3rd Edition 12.11 */
443 CaseBlock
444 : '{' CaseClausules_opt '}'
445 { $$ = new_case_block(ctx, $2, NULL, NULL); }
446 | '{' CaseClausules_opt DefaultClausule CaseClausules_opt '}'
447 { $$ = new_case_block(ctx, $2, $3, $4); }
449 /* ECMA-262 3rd Edition 12.11 */
450 CaseClausules_opt
451 : /* empty */ { $$ = NULL; }
452 | CaseClausules { $$ = $1; }
454 /* ECMA-262 3rd Edition 12.11 */
455 CaseClausules
456 : CaseClausule { $$ = new_case_list(ctx, $1); }
457 | CaseClausules CaseClausule
458 { $$ = case_list_add(ctx, $1, $2); }
460 /* ECMA-262 3rd Edition 12.11 */
461 CaseClausule
462 : kCASE Expression ':' StatementList_opt
463 { $$ = new_case_clausule(ctx, $2, $4); }
465 /* ECMA-262 3rd Edition 12.11 */
466 DefaultClausule
467 : kDEFAULT ':' StatementList_opt
468 { $$ = new_case_clausule(ctx, NULL, $3); }
470 /* ECMA-262 3rd Edition 12.13 */
471 ThrowStatement
472 : kTHROW /* NONL */ Expression semicolon_opt
473 { $$ = new_throw_statement(ctx, $2); }
475 /* ECMA-262 3rd Edition 12.14 */
476 TryStatement
477 : kTRY Block Catch { $$ = new_try_statement(ctx, $2, $3, NULL); }
478 | kTRY Block Finally { $$ = new_try_statement(ctx, $2, NULL, $3); }
479 | kTRY Block Catch Finally
480 { $$ = new_try_statement(ctx, $2, $3, $4); }
482 /* ECMA-262 3rd Edition 12.14 */
483 Catch
484 : kCATCH left_bracket tIdentifier right_bracket Block
485 { $$ = new_catch_block(ctx, $3, $5); }
487 /* ECMA-262 3rd Edition 12.14 */
488 Finally
489 : kFINALLY Block { $$ = $2; }
491 /* ECMA-262 3rd Edition 11.14 */
492 Expression_opt
493 : /* empty */ { $$ = NULL; }
494 | Expression { $$ = $1; }
496 Expression_err
497 : Expression { $$ = $1; }
498 | error { set_error(ctx, JS_E_SYNTAX); YYABORT; }
500 /* ECMA-262 3rd Edition 11.14 */
501 Expression
502 : AssignmentExpression { $$ = $1; }
503 | Expression ',' AssignmentExpression
504 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
506 /* ECMA-262 3rd Edition 11.14 */
507 ExpressionNoIn_opt
508 : /* empty */ { $$ = NULL; }
509 | ExpressionNoIn { $$ = $1; }
511 /* ECMA-262 3rd Edition 11.14 */
512 ExpressionNoIn
513 : AssignmentExpressionNoIn
514 { $$ = $1; }
515 | ExpressionNoIn ',' AssignmentExpressionNoIn
516 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
518 AssignOper
519 : tAssignOper { $$ = $1; }
520 | kDIVEQ { $$ = EXPR_ASSIGNDIV; }
522 /* ECMA-262 3rd Edition 11.13 */
523 AssignmentExpression
524 : ConditionalExpression { $$ = $1; }
525 | LeftHandSideExpression '=' AssignmentExpression
526 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); }
527 | LeftHandSideExpression AssignOper AssignmentExpression
528 { $$ = new_binary_expression(ctx, $2, $1, $3); }
530 /* ECMA-262 3rd Edition 11.13 */
531 AssignmentExpressionNoIn
532 : ConditionalExpressionNoIn
533 { $$ = $1; }
534 | LeftHandSideExpression '=' AssignmentExpressionNoIn
535 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); }
536 | LeftHandSideExpression AssignOper AssignmentExpressionNoIn
537 { $$ = new_binary_expression(ctx, $2, $1, $3); }
539 /* ECMA-262 3rd Edition 11.12 */
540 ConditionalExpression
541 : LogicalORExpression { $$ = $1; }
542 | LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression
543 { $$ = new_conditional_expression(ctx, $1, $3, $5); }
545 /* ECMA-262 3rd Edition 11.12 */
546 ConditionalExpressionNoIn
547 : LogicalORExpressionNoIn
548 { $$ = $1; }
549 | LogicalORExpressionNoIn '?' AssignmentExpressionNoIn ':' AssignmentExpressionNoIn
550 { $$ = new_conditional_expression(ctx, $1, $3, $5); }
552 /* ECMA-262 3rd Edition 11.11 */
553 LogicalORExpression
554 : LogicalANDExpression { $$ = $1; }
555 | LogicalORExpression tOROR LogicalANDExpression
556 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
558 /* ECMA-262 3rd Edition 11.11 */
559 LogicalORExpressionNoIn
560 : LogicalANDExpressionNoIn
561 { $$ = $1; }
562 | LogicalORExpressionNoIn tOROR LogicalANDExpressionNoIn
563 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
565 /* ECMA-262 3rd Edition 11.11 */
566 LogicalANDExpression
567 : BitwiseORExpression { $$ = $1; }
568 | LogicalANDExpression tANDAND BitwiseORExpression
569 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
571 /* ECMA-262 3rd Edition 11.11 */
572 LogicalANDExpressionNoIn
573 : BitwiseORExpressionNoIn
574 { $$ = $1; }
575 | LogicalANDExpressionNoIn tANDAND BitwiseORExpressionNoIn
576 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
578 /* ECMA-262 3rd Edition 11.10 */
579 BitwiseORExpression
580 : BitwiseXORExpression { $$ = $1; }
581 | BitwiseORExpression '|' BitwiseXORExpression
582 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
584 /* ECMA-262 3rd Edition 11.10 */
585 BitwiseORExpressionNoIn
586 : BitwiseXORExpressionNoIn
587 { $$ = $1; }
588 | BitwiseORExpressionNoIn '|' BitwiseXORExpressionNoIn
589 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
591 /* ECMA-262 3rd Edition 11.10 */
592 BitwiseXORExpression
593 : BitwiseANDExpression { $$ = $1; }
594 | BitwiseXORExpression '^' BitwiseANDExpression
595 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
597 /* ECMA-262 3rd Edition 11.10 */
598 BitwiseXORExpressionNoIn
599 : BitwiseANDExpressionNoIn
600 { $$ = $1; }
601 | BitwiseXORExpressionNoIn '^' BitwiseANDExpressionNoIn
602 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
604 /* ECMA-262 3rd Edition 11.10 */
605 BitwiseANDExpression
606 : EqualityExpression { $$ = $1; }
607 | BitwiseANDExpression '&' EqualityExpression
608 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
610 /* ECMA-262 3rd Edition 11.10 */
611 BitwiseANDExpressionNoIn
612 : EqualityExpressionNoIn
613 { $$ = $1; }
614 | BitwiseANDExpressionNoIn '&' EqualityExpressionNoIn
615 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
617 /* ECMA-262 3rd Edition 11.9 */
618 EqualityExpression
619 : RelationalExpression { $$ = $1; }
620 | EqualityExpression tEqOper RelationalExpression
621 { $$ = new_binary_expression(ctx, $2, $1, $3); }
623 /* ECMA-262 3rd Edition 11.9 */
624 EqualityExpressionNoIn
625 : RelationalExpressionNoIn { $$ = $1; }
626 | EqualityExpressionNoIn tEqOper RelationalExpressionNoIn
627 { $$ = new_binary_expression(ctx, $2, $1, $3); }
629 /* ECMA-262 3rd Edition 11.8 */
630 RelationalExpression
631 : ShiftExpression { $$ = $1; }
632 | RelationalExpression tRelOper ShiftExpression
633 { $$ = new_binary_expression(ctx, $2, $1, $3); }
634 | RelationalExpression kINSTANCEOF ShiftExpression
635 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); }
636 | RelationalExpression kIN ShiftExpression
637 { $$ = new_binary_expression(ctx, EXPR_IN, $1, $3); }
639 /* ECMA-262 3rd Edition 11.8 */
640 RelationalExpressionNoIn
641 : ShiftExpression { $$ = $1; }
642 | RelationalExpressionNoIn tRelOper ShiftExpression
643 { $$ = new_binary_expression(ctx, $2, $1, $3); }
644 | RelationalExpressionNoIn kINSTANCEOF ShiftExpression
645 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); }
647 /* ECMA-262 3rd Edition 11.7 */
648 ShiftExpression
649 : AdditiveExpression { $$ = $1; }
650 | ShiftExpression tShiftOper AdditiveExpression
651 { $$ = new_binary_expression(ctx, $2, $1, $3); }
653 /* ECMA-262 3rd Edition 11.6 */
654 AdditiveExpression
655 : MultiplicativeExpression
656 { $$ = $1; }
657 | AdditiveExpression '+' MultiplicativeExpression
658 { $$ = new_binary_expression(ctx, EXPR_ADD, $1, $3); }
659 | AdditiveExpression '-' MultiplicativeExpression
660 { $$ = new_binary_expression(ctx, EXPR_SUB, $1, $3); }
662 /* ECMA-262 3rd Edition 11.5 */
663 MultiplicativeExpression
664 : UnaryExpression { $$ = $1; }
665 | MultiplicativeExpression '*' UnaryExpression
666 { $$ = new_binary_expression(ctx, EXPR_MUL, $1, $3); }
667 | MultiplicativeExpression '/' UnaryExpression
668 { $$ = new_binary_expression(ctx, EXPR_DIV, $1, $3); }
669 | MultiplicativeExpression '%' UnaryExpression
670 { $$ = new_binary_expression(ctx, EXPR_MOD, $1, $3); }
672 /* ECMA-262 3rd Edition 11.4 */
673 UnaryExpression
674 : PostfixExpression { $$ = $1; }
675 | kDELETE UnaryExpression
676 { $$ = new_unary_expression(ctx, EXPR_DELETE, $2); }
677 | kVOID UnaryExpression { $$ = new_unary_expression(ctx, EXPR_VOID, $2); }
678 | kTYPEOF UnaryExpression
679 { $$ = new_unary_expression(ctx, EXPR_TYPEOF, $2); }
680 | tINC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREINC, $2); }
681 | tDEC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREDEC, $2); }
682 | '+' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PLUS, $2); }
683 | '-' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_MINUS, $2); }
684 | '~' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_BITNEG, $2); }
685 | '!' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_LOGNEG, $2); }
687 /* ECMA-262 3rd Edition 11.2 */
688 PostfixExpression
689 : LeftHandSideExpression
690 { $$ = $1; }
691 | LeftHandSideExpression /* NONL */ tINC
692 { $$ = new_unary_expression(ctx, EXPR_POSTINC, $1); }
693 | LeftHandSideExpression /* NONL */ tDEC
694 { $$ = new_unary_expression(ctx, EXPR_POSTDEC, $1); }
697 /* ECMA-262 3rd Edition 11.2 */
698 LeftHandSideExpression
699 : NewExpression { $$ = $1; }
700 | CallExpression { $$ = $1; }
702 /* ECMA-262 3rd Edition 11.2 */
703 NewExpression
704 : MemberExpression { $$ = $1; }
705 | kNEW NewExpression { $$ = new_new_expression(ctx, $2, NULL); }
707 /* ECMA-262 3rd Edition 11.2 */
708 MemberExpression
709 : PrimaryExpression { $$ = $1; }
710 | FunctionExpression { $$ = $1; }
711 | MemberExpression '[' Expression ']'
712 { $$ = new_binary_expression(ctx, EXPR_ARRAY, $1, $3); }
713 | MemberExpression '.' tIdentifier
714 { $$ = new_member_expression(ctx, $1, $3); }
715 | kNEW MemberExpression Arguments
716 { $$ = new_new_expression(ctx, $2, $3); }
718 /* ECMA-262 3rd Edition 11.2 */
719 CallExpression
720 : MemberExpression Arguments
721 { $$ = new_call_expression(ctx, $1, $2); }
722 | CallExpression Arguments
723 { $$ = new_call_expression(ctx, $1, $2); }
724 | CallExpression '[' Expression ']'
725 { $$ = new_binary_expression(ctx, EXPR_ARRAY, $1, $3); }
726 | CallExpression '.' tIdentifier
727 { $$ = new_member_expression(ctx, $1, $3); }
729 /* ECMA-262 3rd Edition 11.2 */
730 Arguments
731 : '(' ')' { $$ = NULL; }
732 | '(' ArgumentList ')' { $$ = $2; }
734 /* ECMA-262 3rd Edition 11.2 */
735 ArgumentList
736 : AssignmentExpression { $$ = new_argument_list(ctx, $1); }
737 | ArgumentList ',' AssignmentExpression
738 { $$ = argument_list_add(ctx, $1, $3); }
740 /* ECMA-262 3rd Edition 11.1 */
741 PrimaryExpression
742 : kTHIS { $$ = new_expression(ctx, EXPR_THIS, 0); }
743 | tIdentifier { $$ = new_identifier_expression(ctx, $1); }
744 | Literal { $$ = new_literal_expression(ctx, $1); }
745 | ArrayLiteral { $$ = $1; }
746 | ObjectLiteral { $$ = $1; }
747 | '(' Expression ')' { $$ = $2; }
749 /* ECMA-262 3rd Edition 11.1.4 */
750 ArrayLiteral
751 : '[' ']' { $$ = new_array_literal_expression(ctx, NULL, 0); }
752 | '[' Elision ']' { $$ = new_array_literal_expression(ctx, NULL, $2+1); }
753 | '[' ElementList ']' { $$ = new_array_literal_expression(ctx, $2, 0); }
754 | '[' ElementList ',' Elision_opt ']'
755 { $$ = new_array_literal_expression(ctx, $2, $4+1); }
757 /* ECMA-262 3rd Edition 11.1.4 */
758 ElementList
759 : Elision_opt AssignmentExpression
760 { $$ = new_element_list(ctx, $1, $2); }
761 | ElementList ',' Elision_opt AssignmentExpression
762 { $$ = element_list_add(ctx, $1, $3, $4); }
764 /* ECMA-262 3rd Edition 11.1.4 */
765 Elision
766 : ',' { $$ = 1; }
767 | Elision ',' { $$ = $1 + 1; }
769 /* ECMA-262 3rd Edition 11.1.4 */
770 Elision_opt
771 : /* empty */ { $$ = 0; }
772 | Elision { $$ = $1; }
774 /* ECMA-262 3rd Edition 11.1.5 */
775 ObjectLiteral
776 : '{' '}' { $$ = new_prop_and_value_expression(ctx, NULL); }
777 | '{' PropertyNameAndValueList '}'
778 { $$ = new_prop_and_value_expression(ctx, $2); }
780 /* ECMA-262 3rd Edition 11.1.5 */
781 PropertyNameAndValueList
782 : PropertyName ':' AssignmentExpression
783 { $$ = new_property_list(ctx, $1, $3); }
784 | PropertyNameAndValueList ',' PropertyName ':' AssignmentExpression
785 { $$ = property_list_add(ctx, $1, $3, $5); }
787 /* ECMA-262 3rd Edition 11.1.5 */
788 PropertyName
789 : tIdentifier { $$ = new_string_literal(ctx, $1); }
790 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
791 | tNumericLiteral { $$ = $1; }
793 /* ECMA-262 3rd Edition 7.6 */
794 Identifier_opt
795 : /* empty*/ { $$ = NULL; }
796 | tIdentifier { $$ = $1; }
798 /* ECMA-262 3rd Edition 7.8 */
799 Literal
800 : kNULL { $$ = new_null_literal(ctx); }
801 | BooleanLiteral { $$ = $1; }
802 | tNumericLiteral { $$ = $1; }
803 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
804 | '/' { $$ = parse_regexp(ctx);
805 if(!$$) YYABORT; }
806 | kDIVEQ { $$ = parse_regexp(ctx);
807 if(!$$) YYABORT; }
809 /* ECMA-262 3rd Edition 7.8.2 */
810 BooleanLiteral
811 : kTRUE { $$ = new_boolean_literal(ctx, VARIANT_TRUE); }
812 | kFALSE { $$ = new_boolean_literal(ctx, VARIANT_FALSE); }
813 | tBooleanLiteral { $$ = $1; }
815 semicolon_opt
816 : ';'
817 | error { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
819 left_bracket
820 : '('
821 | error { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; }
823 right_bracket
824 : ')'
825 | error { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; }
827 semicolon
828 : ';'
829 | error { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; }
833 static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
835 return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
838 static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size)
840 statement_t *stat;
842 stat = parser_alloc(ctx, size ? size : sizeof(*stat));
843 if(!stat)
844 return NULL;
846 stat->type = type;
847 stat->eval = NULL;
848 stat->instr_off = -1;
849 stat->next = NULL;
851 return stat;
854 static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str)
856 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
858 ret->type = LT_STRING;
859 ret->u.wstr = str;
861 return ret;
864 static literal_t *new_null_literal(parser_ctx_t *ctx)
866 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
868 ret->type = LT_NULL;
870 return ret;
873 static prop_val_t *new_prop_val(parser_ctx_t *ctx, literal_t *name, expression_t *value)
875 prop_val_t *ret = parser_alloc(ctx, sizeof(prop_val_t));
877 ret->name = name;
878 ret->value = value;
879 ret->next = NULL;
881 return ret;
884 static property_list_t *new_property_list(parser_ctx_t *ctx, literal_t *name, expression_t *value)
886 property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t));
888 ret->head = ret->tail = new_prop_val(ctx, name, value);
890 return ret;
893 static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list, literal_t *name, expression_t *value)
895 list->tail = list->tail->next = new_prop_val(ctx, name, value);
897 return list;
900 static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr)
902 array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t));
904 ret->elision = elision;
905 ret->expr = expr;
906 ret->next = NULL;
908 return ret;
911 static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t *expr)
913 element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t));
915 ret->head = ret->tail = new_array_element(ctx, elision, expr);
917 return ret;
920 static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int elision, expression_t *expr)
922 list->tail = list->tail->next = new_array_element(ctx, elision, expr);
924 return list;
927 static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr)
929 argument_t *ret = parser_alloc(ctx, sizeof(argument_t));
931 ret->expr = expr;
932 ret->next = NULL;
934 return ret;
937 static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr)
939 argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t));
941 ret->head = ret->tail = new_argument(ctx, expr);
943 return ret;
946 static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list, expression_t *expr)
948 list->tail = list->tail->next = new_argument(ctx, expr);
950 return list;
953 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
955 catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t));
957 ret->identifier = identifier;
958 ret->statement = statement;
960 return ret;
963 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_list_t *stat_list)
965 case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t));
967 ret->expr = expr;
968 ret->stat = stat_list ? stat_list->head : NULL;
969 ret->next = NULL;
971 return ret;
974 static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule)
976 case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t));
978 ret->head = ret->tail = case_clausule;
980 return ret;
983 static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t *case_clausule)
985 list->tail = list->tail->next = case_clausule;
987 return list;
990 static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1,
991 case_clausule_t *default_clausule, case_list_t *case_list2)
993 case_clausule_t *ret = NULL, *iter = NULL, *iter2;
994 statement_t *stat = NULL;
996 if(case_list1) {
997 ret = case_list1->head;
998 iter = case_list1->tail;
1001 if(default_clausule) {
1002 if(ret)
1003 iter = iter->next = default_clausule;
1004 else
1005 ret = iter = default_clausule;
1008 if(case_list2) {
1009 if(ret)
1010 iter->next = case_list2->head;
1011 else
1012 ret = case_list2->head;
1015 if(!ret)
1016 return NULL;
1018 for(iter = ret; iter; iter = iter->next) {
1019 for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next);
1020 if(!iter2)
1021 break;
1023 while(iter != iter2) {
1024 iter->stat = iter2->stat;
1025 iter = iter->next;
1028 if(stat) {
1029 while(stat->next)
1030 stat = stat->next;
1031 stat->next = iter->stat;
1032 }else {
1033 stat = iter->stat;
1037 return ret;
1040 static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list)
1042 block_statement_t *ret;
1044 ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret));
1045 if(!ret)
1046 return NULL;
1048 ret->stat_list = list ? list->head : NULL;
1050 return &ret->stat;
1053 static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *expr)
1055 variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t));
1056 var_list_t *var_list = parser_alloc(ctx, sizeof(var_list_t));
1058 ret->identifier = identifier;
1059 ret->expr = expr;
1060 ret->next = NULL;
1062 var_list->identifier = identifier;
1063 var_list->next = NULL;
1065 if(ctx->func_stack->var_tail)
1066 ctx->func_stack->var_tail = ctx->func_stack->var_tail->next = var_list;
1067 else
1068 ctx->func_stack->var_head = ctx->func_stack->var_tail = var_list;
1070 return ret;
1073 static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t *decl)
1075 variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t));
1077 ret->head = ret->tail = decl;
1079 return ret;
1082 static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list, variable_declaration_t *decl)
1084 list->tail = list->tail->next = decl;
1086 return list;
1089 static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list)
1091 var_statement_t *ret;
1093 ret = new_statement(ctx, STAT_VAR, sizeof(*ret));
1094 if(!ret)
1095 return NULL;
1097 ret->variable_list = variable_list->head;
1099 return &ret->stat;
1102 static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr)
1104 expression_statement_t *ret;
1106 ret = new_statement(ctx, STAT_EXPR, sizeof(*ret));
1107 if(!ret)
1108 return NULL;
1110 ret->expr = expr;
1112 return &ret->stat;
1115 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, statement_t *else_stat)
1117 if_statement_t *ret;
1119 ret = new_statement(ctx, STAT_IF, sizeof(*ret));
1120 if(!ret)
1121 return NULL;
1123 ret->expr = expr;
1124 ret->if_stat = if_stat;
1125 ret->else_stat = else_stat;
1127 return &ret->stat;
1130 static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t *expr, statement_t *stat)
1132 while_statement_t *ret;
1134 ret = new_statement(ctx, STAT_WHILE, sizeof(*ret));
1135 if(!ret)
1136 return NULL;
1138 ret->do_while = dowhile;
1139 ret->expr = expr;
1140 ret->statement = stat;
1142 return &ret->stat;
1145 static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr,
1146 expression_t *expr, expression_t *end_expr, statement_t *statement)
1148 for_statement_t *ret;
1150 ret = new_statement(ctx, STAT_FOR, sizeof(*ret));
1151 if(!ret)
1152 return NULL;
1154 ret->variable_list = variable_list ? variable_list->head : NULL;
1155 ret->begin_expr = begin_expr;
1156 ret->expr = expr;
1157 ret->end_expr = end_expr;
1158 ret->statement = statement;
1160 return &ret->stat;
1163 static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t *variable, expression_t *expr,
1164 expression_t *in_expr, statement_t *statement)
1166 forin_statement_t *ret;
1168 ret = new_statement(ctx, STAT_FORIN, sizeof(*ret));
1169 if(!ret)
1170 return NULL;
1172 ret->variable = variable;
1173 ret->expr = expr;
1174 ret->in_expr = in_expr;
1175 ret->statement = statement;
1177 return &ret->stat;
1180 static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier)
1182 branch_statement_t *ret;
1184 ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret));
1185 if(!ret)
1186 return NULL;
1188 ret->identifier = identifier;
1190 return &ret->stat;
1193 static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier)
1195 branch_statement_t *ret;
1197 ret = new_statement(ctx, STAT_BREAK, sizeof(*ret));
1198 if(!ret)
1199 return NULL;
1201 ret->identifier = identifier;
1203 return &ret->stat;
1206 static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr)
1208 expression_statement_t *ret;
1210 ret = new_statement(ctx, STAT_RETURN, sizeof(*ret));
1211 if(!ret)
1212 return NULL;
1214 ret->expr = expr;
1216 return &ret->stat;
1219 static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *statement)
1221 with_statement_t *ret;
1223 ret = new_statement(ctx, STAT_WITH, sizeof(*ret));
1224 if(!ret)
1225 return NULL;
1227 ret->expr = expr;
1228 ret->statement = statement;
1230 return &ret->stat;
1233 static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
1235 labelled_statement_t *ret;
1237 ret = new_statement(ctx, STAT_LABEL, sizeof(*ret));
1238 if(!ret)
1239 return NULL;
1241 ret->identifier = identifier;
1242 ret->statement = statement;
1244 return &ret->stat;
1247 static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_list)
1249 switch_statement_t *ret;
1251 ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret));
1252 if(!ret)
1253 return NULL;
1255 ret->expr = expr;
1256 ret->case_list = case_list;
1258 return &ret->stat;
1261 static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr)
1263 expression_statement_t *ret;
1265 ret = new_statement(ctx, STAT_THROW, sizeof(*ret));
1266 if(!ret)
1267 return NULL;
1269 ret->expr = expr;
1271 return &ret->stat;
1274 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement,
1275 catch_block_t *catch_block, statement_t *finally_statement)
1277 try_statement_t *ret;
1279 ret = new_statement(ctx, STAT_TRY, sizeof(*ret));
1280 if(!ret)
1281 return NULL;
1283 ret->try_statement = try_statement;
1284 ret->catch_block = catch_block;
1285 ret->finally_statement = finally_statement;
1287 return &ret->stat;
1290 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
1292 parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t));
1294 ret->identifier = identifier;
1295 ret->next = NULL;
1297 return ret;
1300 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier)
1302 parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t));
1304 ret->head = ret->tail = new_parameter(ctx, identifier);
1306 return ret;
1309 static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list, const WCHAR *identifier)
1311 list->tail = list->tail->next = new_parameter(ctx, identifier);
1313 return list;
1316 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier,
1317 parameter_list_t *parameter_list, source_elements_t *source_elements, const WCHAR *src_str, DWORD src_len)
1319 function_expression_t *ret = new_expression(ctx, EXPR_FUNC, sizeof(*ret));
1321 ret->identifier = identifier;
1322 ret->parameter_list = parameter_list ? parameter_list->head : NULL;
1323 ret->source_elements = source_elements;
1324 ret->src_str = src_str;
1325 ret->src_len = src_len;
1327 if(ret->identifier) {
1328 function_declaration_t *decl = parser_alloc(ctx, sizeof(function_declaration_t));
1330 decl->expr = ret;
1331 decl->next = NULL;
1333 if(ctx->func_stack->func_tail)
1334 ctx->func_stack->func_tail = ctx->func_stack->func_tail->next = decl;
1335 else
1336 ctx->func_stack->func_head = ctx->func_stack->func_tail = decl;
1339 return &ret->expr;
1342 static void *new_expression(parser_ctx_t *ctx, expression_type_t type, size_t size)
1344 expression_t *ret = parser_alloc(ctx, size ? size : sizeof(*ret));
1346 ret->type = type;
1347 ret->instr_off = -1;
1349 return ret;
1352 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type,
1353 expression_t *expression1, expression_t *expression2)
1355 binary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
1357 ret->expression1 = expression1;
1358 ret->expression2 = expression2;
1360 return &ret->expr;
1363 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *expression)
1365 unary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
1367 ret->expression = expression;
1369 return &ret->expr;
1372 static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t *expression,
1373 expression_t *true_expression, expression_t *false_expression)
1375 conditional_expression_t *ret = new_expression(ctx, EXPR_COND, sizeof(*ret));
1377 ret->expression = expression;
1378 ret->true_expression = true_expression;
1379 ret->false_expression = false_expression;
1381 return &ret->expr;
1384 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier)
1386 member_expression_t *ret = new_expression(ctx, EXPR_MEMBER, sizeof(*ret));
1388 ret->expression = expression;
1389 ret->identifier = identifier;
1391 return &ret->expr;
1394 static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1396 call_expression_t *ret = new_expression(ctx, EXPR_NEW, sizeof(*ret));
1398 ret->expression = expression;
1399 ret->argument_list = argument_list ? argument_list->head : NULL;
1401 return &ret->expr;
1404 static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1406 call_expression_t *ret = new_expression(ctx, EXPR_CALL, sizeof(*ret));
1408 ret->expression = expression;
1409 ret->argument_list = argument_list ? argument_list->head : NULL;
1411 return &ret->expr;
1414 static int parser_error(const char *str)
1416 return 0;
1419 static void set_error(parser_ctx_t *ctx, UINT error)
1421 ctx->hres = error;
1424 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next)
1426 if(obj || *(ctx->ptr-1)==next) return TRUE;
1428 set_error(ctx, JS_E_SYNTAX);
1429 return FALSE;
1433 static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR *identifier)
1435 identifier_expression_t *ret = new_expression(ctx, EXPR_IDENT, sizeof(*ret));
1437 ret->identifier = identifier;
1439 return &ret->expr;
1442 static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t *element_list, int length)
1444 array_literal_expression_t *ret = new_expression(ctx, EXPR_ARRAYLIT, sizeof(*ret));
1446 ret->element_list = element_list ? element_list->head : NULL;
1447 ret->length = length;
1449 return &ret->expr;
1452 static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t *property_list)
1454 property_value_expression_t *ret = new_expression(ctx, EXPR_PROPVAL, sizeof(*ret));
1456 ret->property_list = property_list ? property_list->head : NULL;
1458 return &ret->expr;
1461 static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal)
1463 literal_expression_t *ret = new_expression(ctx, EXPR_LITERAL, sizeof(*ret));
1465 ret->literal = literal;
1467 return &ret->expr;
1470 static source_elements_t *new_source_elements(parser_ctx_t *ctx)
1472 source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t));
1474 memset(ret, 0, sizeof(*ret));
1476 return ret;
1479 static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement)
1481 if(source_elements->statement_tail)
1482 source_elements->statement_tail = source_elements->statement_tail->next = statement;
1483 else
1484 source_elements->statement = source_elements->statement_tail = statement;
1486 return source_elements;
1489 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement)
1491 statement_list_t *ret = parser_alloc_tmp(ctx, sizeof(statement_list_t));
1493 ret->head = ret->tail = statement;
1495 return ret;
1498 static statement_list_t *statement_list_add(statement_list_t *list, statement_t *statement)
1500 list->tail = list->tail->next = statement;
1502 return list;
1505 static void push_func(parser_ctx_t *ctx)
1507 func_stack_t *new_func = parser_alloc_tmp(ctx, sizeof(func_stack_t));
1509 new_func->func_head = new_func->func_tail = NULL;
1510 new_func->var_head = new_func->var_tail = NULL;
1512 new_func->next = ctx->func_stack;
1513 ctx->func_stack = new_func;
1516 static source_elements_t *function_body_parsed(parser_ctx_t *ctx, source_elements_t *source)
1518 source->functions = ctx->func_stack->func_head;
1519 source->variables = ctx->func_stack->var_head;
1520 pop_func(ctx);
1522 return source;
1525 static void program_parsed(parser_ctx_t *ctx, source_elements_t *source)
1527 source->functions = ctx->func_stack->func_head;
1528 source->variables = ctx->func_stack->var_head;
1529 pop_func(ctx);
1531 ctx->source = source;
1532 if(!ctx->lexer_error)
1533 ctx->hres = S_OK;
1536 void parser_release(parser_ctx_t *ctx)
1538 if(--ctx->ref)
1539 return;
1541 if(ctx->code)
1542 release_bytecode(ctx->code);
1543 if(ctx->compiler)
1544 release_compiler(ctx->compiler);
1545 script_release(ctx->script);
1546 heap_free(ctx->begin);
1547 jsheap_free(&ctx->heap);
1548 heap_free(ctx);
1551 HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter,
1552 parser_ctx_t **ret)
1554 parser_ctx_t *parser_ctx;
1555 jsheap_t *mark;
1556 HRESULT hres;
1558 const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0};
1560 parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
1561 if(!parser_ctx)
1562 return E_OUTOFMEMORY;
1564 parser_ctx->ref = 1;
1565 parser_ctx->hres = JS_E_SYNTAX;
1566 parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
1568 parser_ctx->begin = heap_strdupW(code);
1569 if(!parser_ctx->begin) {
1570 heap_free(parser_ctx);
1571 return E_OUTOFMEMORY;
1574 parser_ctx->ptr = parser_ctx->begin;
1575 parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin);
1577 script_addref(ctx);
1578 parser_ctx->script = ctx;
1580 mark = jsheap_mark(&ctx->tmp_heap);
1581 jsheap_init(&parser_ctx->heap);
1583 push_func(parser_ctx);
1585 parser_parse(parser_ctx);
1586 jsheap_clear(mark);
1587 if(FAILED(parser_ctx->hres)) {
1588 hres = parser_ctx->hres;
1589 parser_release(parser_ctx);
1590 return hres;
1593 *ret = parser_ctx;
1594 return S_OK;