?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dcomp: Add DCompositionCreateDevice() stub.
[wine.git] / dlls / jscript / parser.y
blobba81668dbb33fedcec5f7e876d249a09ec8f038c
1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 */
18
19 %{
20
21 #include "jscript.h"
22 #include "engine.h"
23 #include "parser.h"
24
25 #include "wine/debug.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
28
29 static int parser_error(unsigned*,parser_ctx_t*,const char*);
30 static void set_error(parser_ctx_t*,unsigned,HRESULT);
31 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR);
32 static BOOL allow_auto_semicolon(parser_ctx_t*);
33
34 typedef struct _statement_list_t {
35 statement_t *head;
36 statement_t *tail;
37 } statement_list_t;
38
39 static literal_t *new_string_literal(parser_ctx_t*,jsstr_t*);
40 static literal_t *new_null_literal(parser_ctx_t*);
41
42 typedef struct _property_list_t {
43 property_definition_t *head;
44 property_definition_t *tail;
45 } property_list_t;
46
47 static property_definition_t *new_property_definition(parser_ctx_t *ctx, property_definition_type_t,
48 literal_t *name, expression_t *value);
49 static property_list_t *new_property_list(parser_ctx_t*,property_definition_t*);
50 static property_list_t *property_list_add(parser_ctx_t*,property_list_t*,property_definition_t*);
51
52 typedef struct _element_list_t {
53 array_element_t *head;
54 array_element_t *tail;
55 } element_list_t;
56
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*);
59
60 typedef struct _argument_list_t {
61 argument_t *head;
62 argument_t *tail;
63 } argument_list_t;
64
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*);
67
68 typedef struct _case_list_t {
69 case_clausule_t *head;
70 case_clausule_t *tail;
71 } case_list_t;
72
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*,unsigned,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*);
78
79 typedef struct _variable_list_t {
80 variable_declaration_t *head;
81 variable_declaration_t *tail;
82 } variable_list_t;
83
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*);
87
88 static void *new_statement(parser_ctx_t*,statement_type_t,size_t,unsigned);
89 static statement_t *new_block_statement(parser_ctx_t*,unsigned,statement_list_t*);
90 static statement_t *new_var_statement(parser_ctx_t*,unsigned,variable_list_t*);
91 static statement_t *new_expression_statement(parser_ctx_t*,unsigned,expression_t*);
92 static statement_t *new_if_statement(parser_ctx_t*,unsigned,expression_t*,statement_t*,statement_t*);
93 static statement_t *new_while_statement(parser_ctx_t*,unsigned,BOOL,expression_t*,statement_t*);
94 static statement_t *new_for_statement(parser_ctx_t*,unsigned,variable_list_t*,expression_t*,expression_t*,unsigned,
95 expression_t*,unsigned,statement_t*);
96 static statement_t *new_forin_statement(parser_ctx_t*,unsigned,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
97 static statement_t *new_continue_statement(parser_ctx_t*,unsigned,const WCHAR*);
98 static statement_t *new_break_statement(parser_ctx_t*,unsigned,const WCHAR*);
99 static statement_t *new_return_statement(parser_ctx_t*,unsigned,expression_t*);
100 static statement_t *new_with_statement(parser_ctx_t*,unsigned,expression_t*,statement_t*);
101 static statement_t *new_labelled_statement(parser_ctx_t*,unsigned,const WCHAR*,statement_t*);
102 static statement_t *new_switch_statement(parser_ctx_t*,unsigned,expression_t*,case_clausule_t*);
103 static statement_t *new_throw_statement(parser_ctx_t*,unsigned,expression_t*);
104 static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*,unsigned);
105
106 struct statement_list_t {
107 statement_t *head;
108 statement_t *tail;
109 };
110
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*);
113
114 typedef struct _parameter_list_t {
115 parameter_t *head;
116 parameter_t *tail;
117 } parameter_list_t;
118
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*);
121
122 static void *new_expression(parser_ctx_t *ctx,expression_type_t,size_t);
123 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*,
124 source_elements_t*,const WCHAR*,const WCHAR*,DWORD);
125 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
126 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
127 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*);
128 static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
129 static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*);
130 static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*);
131 static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*);
132 static expression_t *new_literal_expression(parser_ctx_t*,literal_t*);
133 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int);
134 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*);
135
136 static source_elements_t *new_source_elements(parser_ctx_t*);
137 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*);
138
139 #define YYLTYPE unsigned
140 #define YYLLOC_DEFAULT(Cur, Rhs, N) Cur = YYRHSLOC((Rhs), (N) ? 1 : 0)
141
142 %}
143
144 %lex-param { parser_ctx_t *ctx }
145 %parse-param { parser_ctx_t *ctx }
146 %define api.pure
147 %start Program
148
149 %union {
150 int ival;
151 jsstr_t *str;
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 property_definition_t *property_definition;
163 source_elements_t *source_elements;
164 statement_t *statement;
165 struct _statement_list_t *statement_list;
166 struct _variable_list_t *variable_list;
167 variable_declaration_t *variable_declaration;
168 }
169
170 /* keywords */
171 %token <identifier> kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kFUNCTION kIF kFINALLY kFOR kGET kIN kSET
172 %token <identifier> kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH
173 %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ kDCOL
174
175 /* tokens */
176 %token <identifier> tIdentifier
177 %token <ival> tAssignOper tEqOper tShiftOper tRelOper
178 %token <literal> tNumericLiteral tBooleanLiteral
179 %token <str> tStringLiteral
180
181 %type <source_elements> SourceElements
182 %type <source_elements> FunctionBody
183 %type <statement> Statement
184 %type <statement> Block
185 %type <statement> VariableStatement
186 %type <statement> EmptyStatement
187 %type <statement> ExpressionStatement
188 %type <statement> IfStatement
189 %type <statement> IterationStatement
190 %type <statement> ContinueStatement
191 %type <statement> BreakStatement
192 %type <statement> ReturnStatement
193 %type <statement> WithStatement
194 %type <statement> LabelledStatement
195 %type <statement> SwitchStatement
196 %type <statement> ThrowStatement
197 %type <statement> TryStatement
198 %type <statement> Finally
199 %type <statement_list> StatementList StatementList_opt
200 %type <parameter_list> FormalParameterList FormalParameterList_opt
201 %type <expr> Expression Expression_opt Expression_err
202 %type <expr> ExpressionNoIn ExpressionNoIn_opt
203 %type <expr> FunctionExpression
204 %type <expr> AssignmentExpression AssignmentExpressionNoIn
205 %type <expr> ConditionalExpression ConditionalExpressionNoIn
206 %type <expr> LeftHandSideExpression
207 %type <expr> LogicalORExpression LogicalORExpressionNoIn
208 %type <expr> LogicalANDExpression LogicalANDExpressionNoIn
209 %type <expr> BitwiseORExpression BitwiseORExpressionNoIn
210 %type <expr> BitwiseXORExpression BitwiseXORExpressionNoIn
211 %type <expr> BitwiseANDExpression BitwiseANDExpressionNoIn
212 %type <expr> EqualityExpression EqualityExpressionNoIn
213 %type <expr> RelationalExpression RelationalExpressionNoIn
214 %type <expr> ShiftExpression
215 %type <expr> AdditiveExpression
216 %type <expr> MultiplicativeExpression
217 %type <expr> Initialiser_opt Initialiser
218 %type <expr> InitialiserNoIn_opt InitialiserNoIn
219 %type <expr> UnaryExpression
220 %type <expr> PostfixExpression
221 %type <expr> NewExpression
222 %type <expr> CallExpression
223 %type <expr> MemberExpression
224 %type <expr> PrimaryExpression
225 %type <expr> GetterSetterMethod
226 %type <identifier> Identifier_opt
227 %type <variable_list> VariableDeclarationList
228 %type <variable_list> VariableDeclarationListNoIn
229 %type <variable_declaration> VariableDeclaration
230 %type <variable_declaration> VariableDeclarationNoIn
231 %type <case_list> CaseClausules CaseClausules_opt
232 %type <case_clausule> CaseClausule DefaultClausule CaseBlock
233 %type <catch_block> Catch
234 %type <argument_list> Arguments
235 %type <argument_list> ArgumentList
236 %type <literal> Literal
237 %type <expr> ArrayLiteral
238 %type <expr> ObjectLiteral
239 %type <ival> Elision Elision_opt
240 %type <element_list> ElementList
241 %type <property_list> PropertyNameAndValueList
242 %type <property_definition> PropertyDefinition
243 %type <literal> PropertyName
244 %type <literal> BooleanLiteral
245 %type <ival> AssignOper
246 %type <identifier> IdentifierName ReservedAsIdentifier
247
248 %nonassoc LOWER_THAN_ELSE
249 %nonassoc kELSE
250
251 %%
252
253 /* ECMA-262 3rd Edition 14 */
254 Program
255 : SourceElements HtmlComment { ctx->source = $1; }
256
257 HtmlComment
258 : tHTMLCOMMENT
259 | /* empty */
260
261 /* ECMA-262 3rd Edition 14 */
262 SourceElements
263 : /* empty */ { $$ = new_source_elements(ctx); }
264 | SourceElements Statement
265 { $$ = source_elements_add_statement($1, $2); }
266
267 /* ECMA-262 3rd Edition 13 */
268 FunctionExpression
269 : kFUNCTION left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
270 { $$ = new_function_expression(ctx, NULL, $3, $6, NULL, ctx->begin + @1, @7 - @1 + 1); }
271 | kFUNCTION tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
272 { $$ = new_function_expression(ctx, $2, $4, $7, NULL, ctx->begin + @1, @8 - @1 + 1); }
273 | kFUNCTION tIdentifier kDCOL tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
274 { $$ = new_function_expression(ctx, $4, $6, $9, $2, ctx->begin + @1, @10 - @1 + 1); }
275
276 /* ECMA-262 3rd Edition 13 */
277 FunctionBody
278 : SourceElements { $$ = $1; }
279
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); }
285
286 /* ECMA-262 3rd Edition 13 */
287 FormalParameterList_opt
288 : /* empty */ { $$ = NULL; }
289 | FormalParameterList { $$ = $1; }
290
291 /* ECMA-262 3rd Edition 12 */
292 Statement
293 : Block { $$ = $1; }
294 | VariableStatement { $$ = $1; }
295 | EmptyStatement { $$ = $1; }
296 | FunctionExpression { $$ = new_expression_statement(ctx, @$, $1); }
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; }
308
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); }
314
315 /* ECMA-262 3rd Edition 12.2 */
316 StatementList_opt
317 : /* empty */ { $$ = NULL; }
318 | StatementList { $$ = $1; }
319
320 /* ECMA-262 3rd Edition 12.1 */
321 Block
322 : '{' StatementList '}' { $$ = new_block_statement(ctx, @2, $2); }
323 | '{' '}' { $$ = new_block_statement(ctx, @$, NULL); }
324
325 /* ECMA-262 3rd Edition 12.2 */
326 VariableStatement
327 : kVAR VariableDeclarationList semicolon_opt
328 { $$ = new_var_statement(ctx, @$, $2); }
329
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); }
335
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); }
342
343 /* ECMA-262 3rd Edition 12.2 */
344 VariableDeclaration
345 : tIdentifier Initialiser_opt
346 { $$ = new_variable_declaration(ctx, $1, $2); }
347
348 /* ECMA-262 3rd Edition 12.2 */
349 VariableDeclarationNoIn
350 : tIdentifier InitialiserNoIn_opt
351 { $$ = new_variable_declaration(ctx, $1, $2); }
352
353 /* ECMA-262 3rd Edition 12.2 */
354 Initialiser_opt
355 : /* empty */ { $$ = NULL; }
356 | Initialiser { $$ = $1; }
357
358 /* ECMA-262 3rd Edition 12.2 */
359 Initialiser
360 : '=' AssignmentExpression
361 { $$ = $2; }
362
363 /* ECMA-262 3rd Edition 12.2 */
364 InitialiserNoIn_opt
365 : /* empty */ { $$ = NULL; }
366 | InitialiserNoIn { $$ = $1; }
367
368 /* ECMA-262 3rd Edition 12.2 */
369 InitialiserNoIn
370 : '=' AssignmentExpressionNoIn
371 { $$ = $2; }
372
373 /* ECMA-262 3rd Edition 12.3 */
374 EmptyStatement
375 : ';' { $$ = new_statement(ctx, STAT_EMPTY, 0, @$); }
376
377 /* ECMA-262 3rd Edition 12.4 */
378 ExpressionStatement
379 : Expression semicolon_opt
380 { $$ = new_expression_statement(ctx, @$, $1); }
381
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); }
388
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, @3, 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, @3, NULL, $3, $6, @6, $9, @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, @3, $4, NULL, $7, @7, $10, @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); }
411
412 /* ECMA-262 3rd Edition 12.7 */
413 ContinueStatement
414 : kCONTINUE /* NONL */ Identifier_opt semicolon_opt
415 { $$ = new_continue_statement(ctx, @$, $2); }
416
417 /* ECMA-262 3rd Edition 12.8 */
418 BreakStatement
419 : kBREAK /* NONL */ Identifier_opt semicolon_opt
420 { $$ = new_break_statement(ctx, @$, $2); }
421
422 /* ECMA-262 3rd Edition 12.9 */
423 ReturnStatement
424 : kRETURN /* NONL */ Expression_opt semicolon_opt
425 { $$ = new_return_statement(ctx, @$, $2); }
426
427 /* ECMA-262 3rd Edition 12.10 */
428 WithStatement
429 : kWITH left_bracket Expression right_bracket Statement
430 { $$ = new_with_statement(ctx, @$, $3, $5); }
431
432 /* ECMA-262 3rd Edition 12.12 */
433 LabelledStatement
434 : tIdentifier ':' Statement
435 { $$ = new_labelled_statement(ctx, @$, $1, $3); }
436
437 /* ECMA-262 3rd Edition 12.11 */
438 SwitchStatement
439 : kSWITCH left_bracket Expression right_bracket CaseBlock
440 { $$ = new_switch_statement(ctx, @$, $3, $5); }
441
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); }
448
449 /* ECMA-262 3rd Edition 12.11 */
450 CaseClausules_opt
451 : /* empty */ { $$ = NULL; }
452 | CaseClausules { $$ = $1; }
453
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); }
459
460 /* ECMA-262 3rd Edition 12.11 */
461 CaseClausule
462 : kCASE Expression ':' StatementList_opt
463 { $$ = new_case_clausule(ctx, @$, $2, $4); }
464
465 /* ECMA-262 3rd Edition 12.11 */
466 DefaultClausule
467 : kDEFAULT ':' StatementList_opt
468 { $$ = new_case_clausule(ctx, @$, NULL, $3); }
469
470 /* ECMA-262 3rd Edition 12.13 */
471 ThrowStatement
472 : kTHROW /* NONL */ Expression semicolon_opt
473 { $$ = new_throw_statement(ctx, @$, $2); }
474
475 /* ECMA-262 3rd Edition 12.14 */
476 TryStatement
477 : kTRY Block Catch { $$ = new_try_statement(ctx, $2, $3, NULL, 0); }
478 | kTRY Block Finally { $$ = new_try_statement(ctx, $2, NULL, $3, @3); }
479 | kTRY Block Catch Finally
480 { $$ = new_try_statement(ctx, $2, $3, $4, @4); }
481
482 /* ECMA-262 3rd Edition 12.14 */
483 Catch
484 : kCATCH left_bracket tIdentifier right_bracket Block
485 { $$ = new_catch_block(ctx, $3, $5); }
486
487 /* ECMA-262 3rd Edition 12.14 */
488 Finally
489 : kFINALLY Block { @$ = @2; $$ = $2; }
490
491 /* ECMA-262 3rd Edition 11.14 */
492 Expression_opt
493 : /* empty */ { $$ = NULL; }
494 | Expression { $$ = $1; }
495
496 Expression_err
497 : Expression { $$ = $1; }
498 | error { set_error(ctx, @$, JS_E_SYNTAX); YYABORT; }
499
500 /* ECMA-262 3rd Edition 11.14 */
501 Expression
502 : AssignmentExpression { $$ = $1; }
503 | Expression ',' AssignmentExpression
504 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
505
506 /* ECMA-262 3rd Edition 11.14 */
507 ExpressionNoIn_opt
508 : /* empty */ { $$ = NULL; }
509 | ExpressionNoIn { $$ = $1; }
510
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); }
517
518 AssignOper
519 : tAssignOper { $$ = $1; }
520 | kDIVEQ { $$ = EXPR_ASSIGNDIV; }
521
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); }
529
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); }
538
539 /* ECMA-262 3rd Edition 11.12 */
540 ConditionalExpression
541 : LogicalORExpression { $$ = $1; }
542 | LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression
543 { $$ = new_conditional_expression(ctx, $1, $3, $5); }
544
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); }
551
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); }
557
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); }
564
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); }
570
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); }
577
578 /* ECMA-262 3rd Edition 11.10 */
579 BitwiseORExpression
580 : BitwiseXORExpression { $$ = $1; }
581 | BitwiseORExpression '|' BitwiseXORExpression
582 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
583
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); }
590
591 /* ECMA-262 3rd Edition 11.10 */
592 BitwiseXORExpression
593 : BitwiseANDExpression { $$ = $1; }
594 | BitwiseXORExpression '^' BitwiseANDExpression
595 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
596
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); }
603
604 /* ECMA-262 3rd Edition 11.10 */
605 BitwiseANDExpression
606 : EqualityExpression { $$ = $1; }
607 | BitwiseANDExpression '&' EqualityExpression
608 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
609
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); }
616
617 /* ECMA-262 3rd Edition 11.9 */
618 EqualityExpression
619 : RelationalExpression { $$ = $1; }
620 | EqualityExpression tEqOper RelationalExpression
621 { $$ = new_binary_expression(ctx, $2, $1, $3); }
622
623 /* ECMA-262 3rd Edition 11.9 */
624 EqualityExpressionNoIn
625 : RelationalExpressionNoIn { $$ = $1; }
626 | EqualityExpressionNoIn tEqOper RelationalExpressionNoIn
627 { $$ = new_binary_expression(ctx, $2, $1, $3); }
628
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); }
638
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); }
646
647 /* ECMA-262 3rd Edition 11.7 */
648 ShiftExpression
649 : AdditiveExpression { $$ = $1; }
650 | ShiftExpression tShiftOper AdditiveExpression
651 { $$ = new_binary_expression(ctx, $2, $1, $3); }
652
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); }
661
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); }
671
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); }
686
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); }
695
696
697 /* ECMA-262 3rd Edition 11.2 */
698 LeftHandSideExpression
699 : NewExpression { $$ = $1; }
700 | CallExpression { $$ = $1; }
701
702 /* ECMA-262 3rd Edition 11.2 */
703 NewExpression
704 : MemberExpression { $$ = $1; }
705 | kNEW NewExpression { $$ = new_new_expression(ctx, $2, NULL); }
706
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 '.' IdentifierName
714 { $$ = new_member_expression(ctx, $1, $3); }
715 | kNEW MemberExpression Arguments
716 { $$ = new_new_expression(ctx, $2, $3); }
717
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 '.' IdentifierName
727 { $$ = new_member_expression(ctx, $1, $3); }
728
729 /* ECMA-262 3rd Edition 11.2 */
730 Arguments
731 : '(' ')' { $$ = NULL; }
732 | '(' ArgumentList ')' { $$ = $2; }
733
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); }
739
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; }
748
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); }
756
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); }
763
764 /* ECMA-262 3rd Edition 11.1.4 */
765 Elision
766 : ',' { $$ = 1; }
767 | Elision ',' { $$ = $1 + 1; }
768
769 /* ECMA-262 3rd Edition 11.1.4 */
770 Elision_opt
771 : /* empty */ { $$ = 0; }
772 | Elision { $$ = $1; }
773
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); }
779 | '{' PropertyNameAndValueList ',' '}'
780 {
781 if(ctx->script->version < 2) {
782 WARN("Trailing comma in object literal is illegal in legacy mode.\n");
783 set_error(ctx, @3, JS_E_SYNTAX);
784 YYABORT;
785 }
786 $$ = new_prop_and_value_expression(ctx, $2);
787 }
788
789 /* ECMA-262 3rd Edition 11.1.5 */
790 PropertyNameAndValueList
791 : PropertyDefinition { $$ = new_property_list(ctx, $1); }
792 | PropertyNameAndValueList ',' PropertyDefinition
793 { $$ = property_list_add(ctx, $1, $3); }
794
795 /* ECMA-262 5.1 Edition 12.2.6 */
796 PropertyDefinition
797 : PropertyName ':' AssignmentExpression
798 { $$ = new_property_definition(ctx, PROPERTY_DEFINITION_VALUE, $1, $3); }
799 | kGET PropertyName GetterSetterMethod
800 { $$ = new_property_definition(ctx, PROPERTY_DEFINITION_GETTER, $2, $3); }
801 | kSET PropertyName GetterSetterMethod
802 { $$ = new_property_definition(ctx, PROPERTY_DEFINITION_SETTER, $2, $3); }
803
804 GetterSetterMethod
805 : left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}'
806 { $$ = new_function_expression(ctx, NULL, $2, $5, NULL, ctx->begin + @1, @6 - @1 + 1); }
807
808 /* Ecma-262 3rd Edition 11.1.5 */
809 PropertyName
810 : IdentifierName { $$ = new_string_literal(ctx, compiler_alloc_string_len(ctx->compiler, $1, lstrlenW($1))); }
811 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
812 | tNumericLiteral { $$ = $1; }
813
814 /* ECMA-262 3rd Edition 7.6 */
815 Identifier_opt
816 : /* empty*/ { $$ = NULL; }
817 | tIdentifier { $$ = $1; }
818
819 /* ECMA-262 5.1 Edition 7.6 */
820 IdentifierName
821 : tIdentifier { $$ = $1; }
822 | ReservedAsIdentifier
823 {
824 if(ctx->script->version < SCRIPTLANGUAGEVERSION_ES5) {
825 WARN("%s keyword used as an identifier in legacy mode.\n",
826 debugstr_w($1));
827 set_error(ctx, @$, JS_E_SYNTAX);
828 YYABORT;
829 }
830 $$ = $1;
831 }
832
833 ReservedAsIdentifier
834 : kBREAK { $$ = $1; }
835 | kCASE { $$ = $1; }
836 | kCATCH { $$ = $1; }
837 | kCONTINUE { $$ = $1; }
838 | kDEFAULT { $$ = $1; }
839 | kDELETE { $$ = $1; }
840 | kDO { $$ = $1; }
841 | kELSE { $$ = $1; }
842 | kFALSE { $$ = $1; }
843 | kFINALLY { $$ = $1; }
844 | kFOR { $$ = $1; }
845 | kFUNCTION { $$ = $1; }
846 | kGET { $$ = $1; }
847 | kIF { $$ = $1; }
848 | kIN { $$ = $1; }
849 | kINSTANCEOF { $$ = $1; }
850 | kNEW { $$ = $1; }
851 | kNULL { $$ = $1; }
852 | kRETURN { $$ = $1; }
853 | kSET { $$ = $1; }
854 | kSWITCH { $$ = $1; }
855 | kTHIS { $$ = $1; }
856 | kTHROW { $$ = $1; }
857 | kTRUE { $$ = $1; }
858 | kTRY { $$ = $1; }
859 | kTYPEOF { $$ = $1; }
860 | kVAR { $$ = $1; }
861 | kVOID { $$ = $1; }
862 | kWHILE { $$ = $1; }
863 | kWITH { $$ = $1; }
864
865 /* ECMA-262 3rd Edition 7.8 */
866 Literal
867 : kNULL { $$ = new_null_literal(ctx); }
868 | BooleanLiteral { $$ = $1; }
869 | tNumericLiteral { $$ = $1; }
870 | tStringLiteral { $$ = new_string_literal(ctx, $1); }
871 | '/' { $$ = parse_regexp(ctx);
872 if(!$$) YYABORT; }
873 | kDIVEQ { $$ = parse_regexp(ctx);
874 if(!$$) YYABORT; }
875
876 /* ECMA-262 3rd Edition 7.8.2 */
877 BooleanLiteral
878 : kTRUE { $$ = new_boolean_literal(ctx, VARIANT_TRUE); }
879 | kFALSE { $$ = new_boolean_literal(ctx, VARIANT_FALSE); }
880 | tBooleanLiteral { $$ = $1; }
881
882 semicolon_opt
883 : ';'
884 | error { if(!allow_auto_semicolon(ctx)) {YYABORT;} else { ctx->hres = S_OK; ctx->error_loc = -1; } }
885
886 left_bracket
887 : '('
888 | error { set_error(ctx, @$, JS_E_MISSING_LBRACKET); YYABORT; }
889
890 right_bracket
891 : ')'
892 | error { set_error(ctx, @$, JS_E_MISSING_RBRACKET); YYABORT; }
893
894 semicolon
895 : ';'
896 | error { set_error(ctx, @$, JS_E_MISSING_SEMICOLON); YYABORT; }
897
898 %%
899
900 static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
901 {
902 return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
903 }
904
905 static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size, unsigned loc)
906 {
907 statement_t *stat;
908
909 stat = parser_alloc(ctx, size ? size : sizeof(*stat));
910 if(!stat)
911 return NULL;
912
913 stat->type = type;
914 stat->loc = loc;
915 stat->next = NULL;
916
917 return stat;
918 }
919
920 static literal_t *new_string_literal(parser_ctx_t *ctx, jsstr_t *str)
921 {
922 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
923
924 ret->type = LT_STRING;
925 ret->u.str = str;
926
927 return ret;
928 }
929
930 static literal_t *new_null_literal(parser_ctx_t *ctx)
931 {
932 literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
933
934 ret->type = LT_NULL;
935
936 return ret;
937 }
938
939 static property_definition_t *new_property_definition(parser_ctx_t *ctx, property_definition_type_t type,
940 literal_t *name, expression_t *value)
941 {
942 property_definition_t *ret = parser_alloc(ctx, sizeof(property_definition_t));
943
944 ret->type = type;
945 ret->name = name;
946 ret->value = value;
947 ret->next = NULL;
948
949 return ret;
950 }
951
952 static property_list_t *new_property_list(parser_ctx_t *ctx, property_definition_t *prop)
953 {
954 property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t));
955 ret->head = ret->tail = prop;
956 return ret;
957 }
958
959 static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list, property_definition_t *prop)
960 {
961 list->tail = list->tail->next = prop;
962 return list;
963 }
964
965 static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr)
966 {
967 array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t));
968
969 ret->elision = elision;
970 ret->expr = expr;
971 ret->next = NULL;
972
973 return ret;
974 }
975
976 static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t *expr)
977 {
978 element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t));
979
980 ret->head = ret->tail = new_array_element(ctx, elision, expr);
981
982 return ret;
983 }
984
985 static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int elision, expression_t *expr)
986 {
987 list->tail = list->tail->next = new_array_element(ctx, elision, expr);
988
989 return list;
990 }
991
992 static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr)
993 {
994 argument_t *ret = parser_alloc(ctx, sizeof(argument_t));
995
996 ret->expr = expr;
997 ret->next = NULL;
998
999 return ret;
1000 }
1001
1002 static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr)
1003 {
1004 argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t));
1005
1006 ret->head = ret->tail = new_argument(ctx, expr);
1007
1008 return ret;
1009 }
1010
1011 static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list, expression_t *expr)
1012 {
1013 list->tail = list->tail->next = new_argument(ctx, expr);
1014
1015 return list;
1016 }
1017
1018 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement)
1019 {
1020 catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t));
1021
1022 ret->identifier = identifier;
1023 ret->statement = statement;
1024
1025 return ret;
1026 }
1027
1028 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, unsigned loc, expression_t *expr, statement_list_t *stat_list)
1029 {
1030 case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t));
1031
1032 ret->expr = expr;
1033 ret->stat = stat_list ? stat_list->head : NULL;
1034 ret->loc = loc;
1035 ret->next = NULL;
1036
1037 return ret;
1038 }
1039
1040 static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule)
1041 {
1042 case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t));
1043
1044 ret->head = ret->tail = case_clausule;
1045
1046 return ret;
1047 }
1048
1049 static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t *case_clausule)
1050 {
1051 list->tail = list->tail->next = case_clausule;
1052
1053 return list;
1054 }
1055
1056 static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1,
1057 case_clausule_t *default_clausule, case_list_t *case_list2)
1058 {
1059 case_clausule_t *ret = NULL, *iter = NULL, *iter2;
1060 statement_t *stat = NULL;
1061
1062 if(case_list1) {
1063 ret = case_list1->head;
1064 iter = case_list1->tail;
1065 }
1066
1067 if(default_clausule) {
1068 if(ret)
1069 iter = iter->next = default_clausule;
1070 else
1071 ret = iter = default_clausule;
1072 }
1073
1074 if(case_list2) {
1075 if(ret)
1076 iter->next = case_list2->head;
1077 else
1078 ret = case_list2->head;
1079 }
1080
1081 if(!ret)
1082 return NULL;
1083
1084 for(iter = ret; iter; iter = iter->next) {
1085 for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next);
1086 if(!iter2)
1087 break;
1088
1089 while(iter != iter2) {
1090 iter->stat = iter2->stat;
1091 iter = iter->next;
1092 }
1093
1094 if(stat) {
1095 while(stat->next)
1096 stat = stat->next;
1097 stat->next = iter->stat;
1098 }else {
1099 stat = iter->stat;
1100 }
1101 }
1102
1103 return ret;
1104 }
1105
1106 static statement_t *new_block_statement(parser_ctx_t *ctx, unsigned loc, statement_list_t *list)
1107 {
1108 block_statement_t *ret;
1109
1110 ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret), loc);
1111 if(!ret)
1112 return NULL;
1113
1114 ret->stat_list = list ? list->head : NULL;
1115
1116 return &ret->stat;
1117 }
1118
1119 static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *expr)
1120 {
1121 variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t));
1122
1123 ret->identifier = identifier;
1124 ret->expr = expr;
1125 ret->next = NULL;
1126 ret->global_next = NULL;
1127
1128 return ret;
1129 }
1130
1131 static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t *decl)
1132 {
1133 variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t));
1134
1135 ret->head = ret->tail = decl;
1136
1137 return ret;
1138 }
1139
1140 static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list, variable_declaration_t *decl)
1141 {
1142 list->tail = list->tail->next = decl;
1143
1144 return list;
1145 }
1146
1147 static statement_t *new_var_statement(parser_ctx_t *ctx, unsigned loc, variable_list_t *variable_list)
1148 {
1149 var_statement_t *ret;
1150
1151 ret = new_statement(ctx, STAT_VAR, sizeof(*ret), loc);
1152 if(!ret)
1153 return NULL;
1154
1155 ret->variable_list = variable_list->head;
1156
1157 return &ret->stat;
1158 }
1159
1160 static statement_t *new_expression_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
1161 {
1162 expression_statement_t *ret;
1163
1164 ret = new_statement(ctx, STAT_EXPR, sizeof(*ret), loc);
1165 if(!ret)
1166 return NULL;
1167
1168 ret->expr = expr;
1169
1170 return &ret->stat;
1171 }
1172
1173 static statement_t *new_if_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr,
1174 statement_t *if_stat, statement_t *else_stat)
1175 {
1176 if_statement_t *ret;
1177
1178 ret = new_statement(ctx, STAT_IF, sizeof(*ret), loc);
1179 if(!ret)
1180 return NULL;
1181
1182 ret->expr = expr;
1183 ret->if_stat = if_stat;
1184 ret->else_stat = else_stat;
1185
1186 return &ret->stat;
1187 }
1188
1189 static statement_t *new_while_statement(parser_ctx_t *ctx, unsigned loc, BOOL dowhile, expression_t *expr, statement_t *stat)
1190 {
1191 while_statement_t *ret;
1192
1193 ret = new_statement(ctx, STAT_WHILE, sizeof(*ret), loc);
1194 if(!ret)
1195 return NULL;
1196
1197 ret->do_while = dowhile;
1198 ret->expr = expr;
1199 ret->statement = stat;
1200
1201 return &ret->stat;
1202 }
1203
1204 static statement_t *new_for_statement(parser_ctx_t *ctx, unsigned loc, variable_list_t *variable_list, expression_t *begin_expr,
1205 expression_t *expr, unsigned expr_loc, expression_t *end_expr, unsigned end_loc, statement_t *statement)
1206 {
1207 for_statement_t *ret;
1208
1209 ret = new_statement(ctx, STAT_FOR, sizeof(*ret), loc);
1210 if(!ret)
1211 return NULL;
1212
1213 ret->variable_list = variable_list ? variable_list->head : NULL;
1214 ret->begin_expr = begin_expr;
1215 ret->expr = expr;
1216 ret->expr_loc = expr_loc;
1217 ret->end_expr = end_expr;
1218 ret->end_loc = end_loc;
1219 ret->statement = statement;
1220
1221 return &ret->stat;
1222 }
1223
1224 static statement_t *new_forin_statement(parser_ctx_t *ctx, unsigned loc, variable_declaration_t *variable, expression_t *expr,
1225 expression_t *in_expr, statement_t *statement)
1226 {
1227 forin_statement_t *ret;
1228
1229 ret = new_statement(ctx, STAT_FORIN, sizeof(*ret), loc);
1230 if(!ret)
1231 return NULL;
1232
1233 ret->variable = variable;
1234 ret->expr = expr;
1235 ret->in_expr = in_expr;
1236 ret->statement = statement;
1237
1238 return &ret->stat;
1239 }
1240
1241 static statement_t *new_continue_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier)
1242 {
1243 branch_statement_t *ret;
1244
1245 ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret), loc);
1246 if(!ret)
1247 return NULL;
1248
1249 ret->identifier = identifier;
1250
1251 return &ret->stat;
1252 }
1253
1254 static statement_t *new_break_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier)
1255 {
1256 branch_statement_t *ret;
1257
1258 ret = new_statement(ctx, STAT_BREAK, sizeof(*ret), loc);
1259 if(!ret)
1260 return NULL;
1261
1262 ret->identifier = identifier;
1263
1264 return &ret->stat;
1265 }
1266
1267 static statement_t *new_return_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
1268 {
1269 expression_statement_t *ret;
1270
1271 ret = new_statement(ctx, STAT_RETURN, sizeof(*ret), loc);
1272 if(!ret)
1273 return NULL;
1274
1275 ret->expr = expr;
1276
1277 return &ret->stat;
1278 }
1279
1280 static statement_t *new_with_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr, statement_t *statement)
1281 {
1282 with_statement_t *ret;
1283
1284 ret = new_statement(ctx, STAT_WITH, sizeof(*ret), loc);
1285 if(!ret)
1286 return NULL;
1287
1288 ret->expr = expr;
1289 ret->statement = statement;
1290
1291 return &ret->stat;
1292 }
1293
1294 static statement_t *new_labelled_statement(parser_ctx_t *ctx, unsigned loc, const WCHAR *identifier, statement_t *statement)
1295 {
1296 labelled_statement_t *ret;
1297
1298 ret = new_statement(ctx, STAT_LABEL, sizeof(*ret), loc);
1299 if(!ret)
1300 return NULL;
1301
1302 ret->identifier = identifier;
1303 ret->statement = statement;
1304
1305 return &ret->stat;
1306 }
1307
1308 static statement_t *new_switch_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr, case_clausule_t *case_list)
1309 {
1310 switch_statement_t *ret;
1311
1312 ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret), loc);
1313 if(!ret)
1314 return NULL;
1315
1316 ret->expr = expr;
1317 ret->case_list = case_list;
1318
1319 return &ret->stat;
1320 }
1321
1322 static statement_t *new_throw_statement(parser_ctx_t *ctx, unsigned loc, expression_t *expr)
1323 {
1324 expression_statement_t *ret;
1325
1326 ret = new_statement(ctx, STAT_THROW, sizeof(*ret), loc);
1327 if(!ret)
1328 return NULL;
1329
1330 ret->expr = expr;
1331
1332 return &ret->stat;
1333 }
1334
1335 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement,
1336 catch_block_t *catch_block, statement_t *finally_statement, unsigned finally_loc)
1337 {
1338 try_statement_t *ret;
1339
1340 ret = new_statement(ctx, STAT_TRY, sizeof(*ret), try_statement->loc);
1341 if(!ret)
1342 return NULL;
1343
1344 ret->try_statement = try_statement;
1345 ret->catch_block = catch_block;
1346 ret->finally_statement = finally_statement;
1347 ret->finally_loc = finally_loc;
1348
1349 return &ret->stat;
1350 }
1351
1352 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
1353 {
1354 parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t));
1355
1356 ret->identifier = identifier;
1357 ret->next = NULL;
1358
1359 return ret;
1360 }
1361
1362 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier)
1363 {
1364 parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t));
1365
1366 ret->head = ret->tail = new_parameter(ctx, identifier);
1367
1368 return ret;
1369 }
1370
1371 static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list, const WCHAR *identifier)
1372 {
1373 list->tail = list->tail->next = new_parameter(ctx, identifier);
1374
1375 return list;
1376 }
1377
1378 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier, parameter_list_t *parameter_list,
1379 source_elements_t *source_elements, const WCHAR *event_target, const WCHAR *src_str, DWORD src_len)
1380 {
1381 function_expression_t *ret = new_expression(ctx, EXPR_FUNC, sizeof(*ret));
1382
1383 ret->identifier = identifier;
1384 ret->parameter_list = parameter_list ? parameter_list->head : NULL;
1385 ret->source_elements = source_elements;
1386 ret->event_target = event_target;
1387 ret->src_str = src_str;
1388 ret->src_len = src_len;
1389 ret->next = NULL;
1390
1391 return &ret->expr;
1392 }
1393
1394 static void *new_expression(parser_ctx_t *ctx, expression_type_t type, size_t size)
1395 {
1396 expression_t *ret = parser_alloc(ctx, size ? size : sizeof(*ret));
1397
1398 ret->type = type;
1399
1400 return ret;
1401 }
1402
1403 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type,
1404 expression_t *expression1, expression_t *expression2)
1405 {
1406 binary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
1407
1408 ret->expression1 = expression1;
1409 ret->expression2 = expression2;
1410
1411 return &ret->expr;
1412 }
1413
1414 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *expression)
1415 {
1416 unary_expression_t *ret = new_expression(ctx, type, sizeof(*ret));
1417
1418 ret->expression = expression;
1419
1420 return &ret->expr;
1421 }
1422
1423 static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t *expression,
1424 expression_t *true_expression, expression_t *false_expression)
1425 {
1426 conditional_expression_t *ret = new_expression(ctx, EXPR_COND, sizeof(*ret));
1427
1428 ret->expression = expression;
1429 ret->true_expression = true_expression;
1430 ret->false_expression = false_expression;
1431
1432 return &ret->expr;
1433 }
1434
1435 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier)
1436 {
1437 member_expression_t *ret = new_expression(ctx, EXPR_MEMBER, sizeof(*ret));
1438
1439 ret->expression = expression;
1440 ret->identifier = identifier;
1441
1442 return &ret->expr;
1443 }
1444
1445 static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1446 {
1447 call_expression_t *ret = new_expression(ctx, EXPR_NEW, sizeof(*ret));
1448
1449 ret->expression = expression;
1450 ret->argument_list = argument_list ? argument_list->head : NULL;
1451
1452 return &ret->expr;
1453 }
1454
1455 static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list)
1456 {
1457 call_expression_t *ret = new_expression(ctx, EXPR_CALL, sizeof(*ret));
1458
1459 ret->expression = expression;
1460 ret->argument_list = argument_list ? argument_list->head : NULL;
1461
1462 return &ret->expr;
1463 }
1464
1465 static int parser_error(unsigned *loc, parser_ctx_t *ctx, const char *str)
1466 {
1467 if(ctx->error_loc == -1)
1468 ctx->error_loc = *loc;
1469 if(ctx->hres == S_OK)
1470 ctx->hres = JS_E_SYNTAX;
1471 WARN("%s: %s\n", debugstr_w(ctx->begin + *loc), str);
1472 return 0;
1473 }
1474
1475 static void set_error(parser_ctx_t *ctx, unsigned loc, HRESULT error)
1476 {
1477 ctx->hres = error;
1478 ctx->error_loc = loc;
1479 }
1480
1481 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next)
1482 {
1483 if(obj || *(ctx->ptr-1)==next) return TRUE;
1484
1485 set_error(ctx, ctx->ptr - ctx->begin /* FIXME */, JS_E_SYNTAX);
1486 return FALSE;
1487 }
1488
1489
1490 static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR *identifier)
1491 {
1492 identifier_expression_t *ret = new_expression(ctx, EXPR_IDENT, sizeof(*ret));
1493
1494 ret->identifier = identifier;
1495
1496 return &ret->expr;
1497 }
1498
1499 static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t *element_list, int length)
1500 {
1501 array_literal_expression_t *ret = new_expression(ctx, EXPR_ARRAYLIT, sizeof(*ret));
1502
1503 ret->element_list = element_list ? element_list->head : NULL;
1504 ret->length = length;
1505
1506 return &ret->expr;
1507 }
1508
1509 static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t *property_list)
1510 {
1511 property_value_expression_t *ret = new_expression(ctx, EXPR_PROPVAL, sizeof(*ret));
1512
1513 ret->property_list = property_list ? property_list->head : NULL;
1514
1515 return &ret->expr;
1516 }
1517
1518 static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal)
1519 {
1520 literal_expression_t *ret = new_expression(ctx, EXPR_LITERAL, sizeof(*ret));
1521
1522 ret->literal = literal;
1523
1524 return &ret->expr;
1525 }
1526
1527 static source_elements_t *new_source_elements(parser_ctx_t *ctx)
1528 {
1529 source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t));
1530
1531 memset(ret, 0, sizeof(*ret));
1532
1533 return ret;
1534 }
1535
1536 static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement)
1537 {
1538 if(source_elements->statement_tail)
1539 source_elements->statement_tail = source_elements->statement_tail->next = statement;
1540 else
1541 source_elements->statement = source_elements->statement_tail = statement;
1542
1543 return source_elements;
1544 }
1545
1546 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement)
1547 {
1548 statement_list_t *ret = parser_alloc_tmp(ctx, sizeof(statement_list_t));
1549
1550 ret->head = ret->tail = statement;
1551
1552 return ret;
1553 }
1554
1555 static statement_list_t *statement_list_add(statement_list_t *list, statement_t *statement)
1556 {
1557 list->tail = list->tail->next = statement;
1558
1559 return list;
1560 }
1561
1562 void parser_release(parser_ctx_t *ctx)
1563 {
1564 script_release(ctx->script);
1565 heap_pool_free(&ctx->heap);
1566 heap_free(ctx);
1567 }
1568
1569 HRESULT script_parse(script_ctx_t *ctx, struct _compiler_ctx_t *compiler, bytecode_t *code, const WCHAR *delimiter, BOOL from_eval,
1570 parser_ctx_t **ret)
1571 {
1572 parser_ctx_t *parser_ctx;
1573 heap_pool_t *mark;
1574 HRESULT hres;
1575
1576 parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
1577 if(!parser_ctx)
1578 return E_OUTOFMEMORY;
1579
1580 parser_ctx->error_loc = -1;
1581 parser_ctx->is_html = delimiter && !wcsicmp(delimiter, L"</script>");
1582
1583 parser_ctx->begin = parser_ctx->ptr = code->source;
1584 parser_ctx->end = parser_ctx->begin + lstrlenW(parser_ctx->begin);
1585
1586 script_addref(ctx);
1587 parser_ctx->script = ctx;
1588
1589 mark = heap_pool_mark(&ctx->tmp_heap);
1590 heap_pool_init(&parser_ctx->heap);
1591
1592 parser_ctx->compiler = compiler;
1593 parser_parse(parser_ctx);
1594 parser_ctx->compiler = NULL;
1595
1596 heap_pool_clear(mark);
1597 hres = parser_ctx->hres;
1598 if(FAILED(hres)) {
1599 const WCHAR *line_start = code->source + parser_ctx->error_loc, *line_end = line_start;
1600 jsstr_t *line_str;
1601
1602 while(line_start > code->source && line_start[-1] != '\n')
1603 line_start--;
1604 while(*line_end && *line_end != '\n')
1605 line_end++;
1606 line_str = jsstr_alloc_len(line_start, line_end - line_start);
1607
1608 WARN("parser failed around %s in line %s\n",
1609 debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20),
1610 debugstr_jsstr(line_str));
1611
1612 throw_error(ctx, hres, NULL);
1613 set_error_location(ctx->ei, code, parser_ctx->error_loc, IDS_COMPILATION_ERROR, line_str);
1614 parser_release(parser_ctx);
1615 if(line_str)
1616 jsstr_release(line_str);
1617 return DISP_E_EXCEPTION;
1618 }
1619
1620 *ret = parser_ctx;
1621 return S_OK;
1622 }
Windows API implementation