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 23 static int parser_error(parser_ctx_t*,const char*); 24 static void set_error(parser_ctx_t*,UINT); 25 static BOOL explicit_error(parser_ctx_t*,void*,WCHAR); 26 static BOOL allow_auto_semicolon(parser_ctx_t*); 27 static void program_parsed(parser_ctx_t*,source_elements_t*); 28 29 typedef struct _statement_list_t { 30 statement_t *head; 31 statement_t *tail; 32 } statement_list_t; 33 34 static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*); 35 static literal_t *new_null_literal(parser_ctx_t*); 36 37 typedef struct _property_list_t { 38 prop_val_t *head; 39 prop_val_t *tail; 40 } property_list_t; 41 42 static property_list_t *new_property_list(parser_ctx_t*,literal_t*,expression_t*); 43 static property_list_t *property_list_add(parser_ctx_t*,property_list_t*,literal_t*,expression_t*); 44 45 typedef struct _element_list_t { 46 array_element_t *head; 47 array_element_t *tail; 48 } element_list_t; 49 50 static element_list_t *new_element_list(parser_ctx_t*,int,expression_t*); 51 static element_list_t *element_list_add(parser_ctx_t*,element_list_t*,int,expression_t*); 52 53 typedef struct _argument_list_t { 54 argument_t *head; 55 argument_t *tail; 56 } argument_list_t; 57 58 static argument_list_t *new_argument_list(parser_ctx_t*,expression_t*); 59 static argument_list_t *argument_list_add(parser_ctx_t*,argument_list_t*,expression_t*); 60 61 typedef struct _case_list_t { 62 case_clausule_t *head; 63 case_clausule_t *tail; 64 } case_list_t; 65 66 static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*); 67 static case_clausule_t *new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*); 68 static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*); 69 static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*); 70 static case_clausule_t *new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*); 71 72 typedef struct _variable_list_t { 73 variable_declaration_t *head; 74 variable_declaration_t *tail; 75 } variable_list_t; 76 77 static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const WCHAR*,expression_t*); 78 static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*); 79 static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*); 80 81 static void *new_statement(parser_ctx_t*,statement_type_t,size_t); 82 static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*); 83 static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*); 84 static statement_t *new_expression_statement(parser_ctx_t*,expression_t*); 85 static statement_t *new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*); 86 static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*); 87 static statement_t *new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*, 88 expression_t*,statement_t*); 89 static statement_t *new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*); 90 static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*); 91 static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*); 92 static statement_t *new_return_statement(parser_ctx_t*,expression_t*); 93 static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*); 94 static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*); 95 static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*); 96 static statement_t *new_throw_statement(parser_ctx_t*,expression_t*); 97 static statement_t *new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*); 98 99 struct statement_list_t { 100 statement_t *head; 101 statement_t *tail; 102 }; 103 104 static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*); 105 static statement_list_t *statement_list_add(statement_list_t*,statement_t*); 106 107 typedef struct _parameter_list_t { 108 parameter_t *head; 109 parameter_t *tail; 110 } parameter_list_t; 111 112 static parameter_list_t *new_parameter_list(parser_ctx_t*,const WCHAR*); 113 static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,const WCHAR*); 114 115 static void *new_expression(parser_ctx_t *ctx,expression_type_t,size_t); 116 static expression_t *new_function_expression(parser_ctx_t*,const WCHAR*,parameter_list_t*, 117 source_elements_t*,const WCHAR*,const WCHAR*,DWORD); 118 static expression_t *new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*); 119 static expression_t *new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*); 120 static expression_t *new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*); 121 static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*); 122 static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*); 123 static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*); 124 static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*); 125 static expression_t *new_literal_expression(parser_ctx_t*,literal_t*); 126 static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int); 127 static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*); 128 129 static source_elements_t *new_source_elements(parser_ctx_t*); 130 static source_elements_t *source_elements_add_statement(source_elements_t*,statement_t*); 131 132 %} 133 134 %lex-param { parser_ctx_t *ctx } 135 %parse-param { parser_ctx_t *ctx } 136 %pure-parser 137 %start Program 138 139 %union { 140 int ival; 141 const WCHAR *srcptr; 142 LPCWSTR wstr; 143 literal_t *literal; 144 struct _argument_list_t *argument_list; 145 case_clausule_t *case_clausule; 146 struct _case_list_t *case_list; 147 catch_block_t *catch_block; 148 struct _element_list_t *element_list; 149 expression_t *expr; 150 const WCHAR *identifier; 151 struct _parameter_list_t *parameter_list; 152 struct _property_list_t *property_list; 153 source_elements_t *source_elements; 154 statement_t *statement; 155 struct _statement_list_t *statement_list; 156 struct _variable_list_t *variable_list; 157 variable_declaration_t *variable_declaration; 158 } 159 160 /* keywords */ 161 %token kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kIF kFINALLY kFOR kIN 162 %token kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH 163 %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ kDCOL 164 165 %token <srcptr> kFUNCTION '}' 166 167 /* tokens */ 168 %token <identifier> tIdentifier 169 %token <ival> tAssignOper tEqOper tShiftOper tRelOper 170 %token <literal> tNumericLiteral tBooleanLiteral 171 %token <wstr> tStringLiteral 172 %token tEOF 173 174 %type <source_elements> SourceElements 175 %type <source_elements> FunctionBody 176 %type <statement> Statement 177 %type <statement> Block 178 %type <statement> VariableStatement 179 %type <statement> EmptyStatement 180 %type <statement> ExpressionStatement 181 %type <statement> IfStatement 182 %type <statement> IterationStatement 183 %type <statement> ContinueStatement 184 %type <statement> BreakStatement 185 %type <statement> ReturnStatement 186 %type <statement> WithStatement 187 %type <statement> LabelledStatement 188 %type <statement> SwitchStatement 189 %type <statement> ThrowStatement 190 %type <statement> TryStatement 191 %type <statement> Finally 192 %type <statement_list> StatementList StatementList_opt 193 %type <parameter_list> FormalParameterList FormalParameterList_opt 194 %type <expr> Expression Expression_opt Expression_err 195 %type <expr> ExpressionNoIn ExpressionNoIn_opt 196 %type <expr> FunctionExpression 197 %type <expr> AssignmentExpression AssignmentExpressionNoIn 198 %type <expr> ConditionalExpression ConditionalExpressionNoIn 199 %type <expr> LeftHandSideExpression 200 %type <expr> LogicalORExpression LogicalORExpressionNoIn 201 %type <expr> LogicalANDExpression LogicalANDExpressionNoIn 202 %type <expr> BitwiseORExpression BitwiseORExpressionNoIn 203 %type <expr> BitwiseXORExpression BitwiseXORExpressionNoIn 204 %type <expr> BitwiseANDExpression BitwiseANDExpressionNoIn 205 %type <expr> EqualityExpression EqualityExpressionNoIn 206 %type <expr> RelationalExpression RelationalExpressionNoIn 207 %type <expr> ShiftExpression 208 %type <expr> AdditiveExpression 209 %type <expr> MultiplicativeExpression 210 %type <expr> Initialiser_opt Initialiser 211 %type <expr> InitialiserNoIn_opt InitialiserNoIn 212 %type <expr> UnaryExpression 213 %type <expr> PostfixExpression 214 %type <expr> NewExpression 215 %type <expr> CallExpression 216 %type <expr> MemberExpression 217 %type <expr> PrimaryExpression 218 %type <identifier> Identifier_opt 219 %type <variable_list> VariableDeclarationList 220 %type <variable_list> VariableDeclarationListNoIn 221 %type <variable_declaration> VariableDeclaration 222 %type <variable_declaration> VariableDeclarationNoIn 223 %type <case_list> CaseClausules CaseClausules_opt 224 %type <case_clausule> CaseClausule DefaultClausule CaseBlock 225 %type <catch_block> Catch 226 %type <argument_list> Arguments 227 %type <argument_list> ArgumentList 228 %type <literal> Literal 229 %type <expr> ArrayLiteral 230 %type <expr> ObjectLiteral 231 %type <ival> Elision Elision_opt 232 %type <element_list> ElementList 233 %type <property_list> PropertyNameAndValueList 234 %type <literal> PropertyName 235 %type <literal> BooleanLiteral 236 %type <srcptr> KFunction 237 %type <ival> AssignOper 238 239 %nonassoc LOWER_THAN_ELSE 240 %nonassoc kELSE 241 242 %% 243 244 /* ECMA-262 3rd Edition 14 */ 245 Program 246 : SourceElements HtmlComment tEOF 247 { program_parsed(ctx, $1); } 248 249 HtmlComment 250 : tHTMLCOMMENT {} 251 | /* empty */ {} 252 253 /* ECMA-262 3rd Edition 14 */ 254 SourceElements 255 : /* empty */ { $$ = new_source_elements(ctx); } 256 | SourceElements Statement 257 { $$ = source_elements_add_statement($1, $2); } 258 259 /* ECMA-262 3rd Edition 13 */ 260 FunctionExpression 261 : KFunction left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}' 262 { $$ = new_function_expression(ctx, NULL, $3, $6, NULL, $1, $7-$1+1); } 263 | KFunction tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}' 264 { $$ = new_function_expression(ctx, $2, $4, $7, NULL, $1, $8-$1+1); } 265 | KFunction tIdentifier kDCOL tIdentifier left_bracket FormalParameterList_opt right_bracket '{' FunctionBody '}' 266 { $$ = new_function_expression(ctx, $4, $6, $9, $2, $1, $10-$1+1); } 267 268 KFunction 269 : kFUNCTION { $$ = $1; } 270 271 /* ECMA-262 3rd Edition 13 */ 272 FunctionBody 273 : SourceElements { $$ = $1; } 274 275 /* ECMA-262 3rd Edition 13 */ 276 FormalParameterList 277 : tIdentifier { $$ = new_parameter_list(ctx, $1); } 278 | FormalParameterList ',' tIdentifier 279 { $$ = parameter_list_add(ctx, $1, $3); } 280 281 /* ECMA-262 3rd Edition 13 */ 282 FormalParameterList_opt 283 : /* empty */ { $$ = NULL; } 284 | FormalParameterList { $$ = $1; } 285 286 /* ECMA-262 3rd Edition 12 */ 287 Statement 288 : Block { $$ = $1; } 289 | VariableStatement { $$ = $1; } 290 | EmptyStatement { $$ = $1; } 291 | FunctionExpression { $$ = new_expression_statement(ctx, $1); } 292 | ExpressionStatement { $$ = $1; } 293 | IfStatement { $$ = $1; } 294 | IterationStatement { $$ = $1; } 295 | ContinueStatement { $$ = $1; } 296 | BreakStatement { $$ = $1; } 297 | ReturnStatement { $$ = $1; } 298 | WithStatement { $$ = $1; } 299 | LabelledStatement { $$ = $1; } 300 | SwitchStatement { $$ = $1; } 301 | ThrowStatement { $$ = $1; } 302 | TryStatement { $$ = $1; } 303 304 /* ECMA-262 3rd Edition 12.2 */ 305 StatementList 306 : Statement { $$ = new_statement_list(ctx, $1); } 307 | StatementList Statement 308 { $$ = statement_list_add($1, $2); } 309 310 /* ECMA-262 3rd Edition 12.2 */ 311 StatementList_opt 312 : /* empty */ { $$ = NULL; } 313 | StatementList { $$ = $1; } 314 315 /* ECMA-262 3rd Edition 12.1 */ 316 Block 317 : '{' StatementList '}' { $$ = new_block_statement(ctx, $2); } 318 | '{' '}' { $$ = new_block_statement(ctx, NULL); } 319 320 /* ECMA-262 3rd Edition 12.2 */ 321 VariableStatement 322 : kVAR VariableDeclarationList semicolon_opt 323 { $$ = new_var_statement(ctx, $2); } 324 325 /* ECMA-262 3rd Edition 12.2 */ 326 VariableDeclarationList 327 : VariableDeclaration { $$ = new_variable_list(ctx, $1); } 328 | VariableDeclarationList ',' VariableDeclaration 329 { $$ = variable_list_add(ctx, $1, $3); } 330 331 /* ECMA-262 3rd Edition 12.2 */ 332 VariableDeclarationListNoIn 333 : VariableDeclarationNoIn 334 { $$ = new_variable_list(ctx, $1); } 335 | VariableDeclarationListNoIn ',' VariableDeclarationNoIn 336 { $$ = variable_list_add(ctx, $1, $3); } 337 338 /* ECMA-262 3rd Edition 12.2 */ 339 VariableDeclaration 340 : tIdentifier Initialiser_opt 341 { $$ = new_variable_declaration(ctx, $1, $2); } 342 343 /* ECMA-262 3rd Edition 12.2 */ 344 VariableDeclarationNoIn 345 : tIdentifier InitialiserNoIn_opt 346 { $$ = new_variable_declaration(ctx, $1, $2); } 347 348 /* ECMA-262 3rd Edition 12.2 */ 349 Initialiser_opt 350 : /* empty */ { $$ = NULL; } 351 | Initialiser { $$ = $1; } 352 353 /* ECMA-262 3rd Edition 12.2 */ 354 Initialiser 355 : '=' AssignmentExpression 356 { $$ = $2; } 357 358 /* ECMA-262 3rd Edition 12.2 */ 359 InitialiserNoIn_opt 360 : /* empty */ { $$ = NULL; } 361 | InitialiserNoIn { $$ = $1; } 362 363 /* ECMA-262 3rd Edition 12.2 */ 364 InitialiserNoIn 365 : '=' AssignmentExpressionNoIn 366 { $$ = $2; } 367 368 /* ECMA-262 3rd Edition 12.3 */ 369 EmptyStatement 370 : ';' { $$ = new_statement(ctx, STAT_EMPTY, 0); } 371 372 /* ECMA-262 3rd Edition 12.4 */ 373 ExpressionStatement 374 : Expression semicolon_opt 375 { $$ = new_expression_statement(ctx, $1); } 376 377 /* ECMA-262 3rd Edition 12.5 */ 378 IfStatement 379 : kIF left_bracket Expression_err right_bracket Statement kELSE Statement 380 { $$ = new_if_statement(ctx, $3, $5, $7); } 381 | kIF left_bracket Expression_err right_bracket Statement %prec LOWER_THAN_ELSE 382 { $$ = new_if_statement(ctx, $3, $5, NULL); } 383 384 /* ECMA-262 3rd Edition 12.6 */ 385 IterationStatement 386 : kDO Statement kWHILE left_bracket Expression_err right_bracket semicolon_opt 387 { $$ = new_while_statement(ctx, TRUE, $5, $2); } 388 | kWHILE left_bracket Expression_err right_bracket Statement 389 { $$ = new_while_statement(ctx, FALSE, $3, $5); } 390 | kFOR left_bracket ExpressionNoIn_opt 391 { if(!explicit_error(ctx, $3, ';')) YYABORT; } 392 semicolon Expression_opt 393 { if(!explicit_error(ctx, $6, ';')) YYABORT; } 394 semicolon Expression_opt right_bracket Statement 395 { $$ = new_for_statement(ctx, NULL, $3, $6, $9, $11); } 396 | kFOR left_bracket kVAR VariableDeclarationListNoIn 397 { if(!explicit_error(ctx, $4, ';')) YYABORT; } 398 semicolon Expression_opt 399 { if(!explicit_error(ctx, $7, ';')) YYABORT; } 400 semicolon Expression_opt right_bracket Statement 401 { $$ = new_for_statement(ctx, $4, NULL, $7, $10, $12); } 402 | kFOR left_bracket LeftHandSideExpression kIN Expression_err right_bracket Statement 403 { $$ = new_forin_statement(ctx, NULL, $3, $5, $7); } 404 | kFOR left_bracket kVAR VariableDeclarationNoIn kIN Expression_err right_bracket Statement 405 { $$ = new_forin_statement(ctx, $4, NULL, $6, $8); } 406 407 /* ECMA-262 3rd Edition 12.7 */ 408 ContinueStatement 409 : kCONTINUE /* NONL */ Identifier_opt semicolon_opt 410 { $$ = new_continue_statement(ctx, $2); } 411 412 /* ECMA-262 3rd Edition 12.8 */ 413 BreakStatement 414 : kBREAK /* NONL */ Identifier_opt semicolon_opt 415 { $$ = new_break_statement(ctx, $2); } 416 417 /* ECMA-262 3rd Edition 12.9 */ 418 ReturnStatement 419 : kRETURN /* NONL */ Expression_opt semicolon_opt 420 { $$ = new_return_statement(ctx, $2); } 421 422 /* ECMA-262 3rd Edition 12.10 */ 423 WithStatement 424 : kWITH left_bracket Expression right_bracket Statement 425 { $$ = new_with_statement(ctx, $3, $5); } 426 427 /* ECMA-262 3rd Edition 12.12 */ 428 LabelledStatement 429 : tIdentifier ':' Statement 430 { $$ = new_labelled_statement(ctx, $1, $3); } 431 432 /* ECMA-262 3rd Edition 12.11 */ 433 SwitchStatement 434 : kSWITCH left_bracket Expression right_bracket CaseBlock 435 { $$ = new_switch_statement(ctx, $3, $5); } 436 437 /* ECMA-262 3rd Edition 12.11 */ 438 CaseBlock 439 : '{' CaseClausules_opt '}' 440 { $$ = new_case_block(ctx, $2, NULL, NULL); } 441 | '{' CaseClausules_opt DefaultClausule CaseClausules_opt '}' 442 { $$ = new_case_block(ctx, $2, $3, $4); } 443 444 /* ECMA-262 3rd Edition 12.11 */ 445 CaseClausules_opt 446 : /* empty */ { $$ = NULL; } 447 | CaseClausules { $$ = $1; } 448 449 /* ECMA-262 3rd Edition 12.11 */ 450 CaseClausules 451 : CaseClausule { $$ = new_case_list(ctx, $1); } 452 | CaseClausules CaseClausule 453 { $$ = case_list_add(ctx, $1, $2); } 454 455 /* ECMA-262 3rd Edition 12.11 */ 456 CaseClausule 457 : kCASE Expression ':' StatementList_opt 458 { $$ = new_case_clausule(ctx, $2, $4); } 459 460 /* ECMA-262 3rd Edition 12.11 */ 461 DefaultClausule 462 : kDEFAULT ':' StatementList_opt 463 { $$ = new_case_clausule(ctx, NULL, $3); } 464 465 /* ECMA-262 3rd Edition 12.13 */ 466 ThrowStatement 467 : kTHROW /* NONL */ Expression semicolon_opt 468 { $$ = new_throw_statement(ctx, $2); } 469 470 /* ECMA-262 3rd Edition 12.14 */ 471 TryStatement 472 : kTRY Block Catch { $$ = new_try_statement(ctx, $2, $3, NULL); } 473 | kTRY Block Finally { $$ = new_try_statement(ctx, $2, NULL, $3); } 474 | kTRY Block Catch Finally 475 { $$ = new_try_statement(ctx, $2, $3, $4); } 476 477 /* ECMA-262 3rd Edition 12.14 */ 478 Catch 479 : kCATCH left_bracket tIdentifier right_bracket Block 480 { $$ = new_catch_block(ctx, $3, $5); } 481 482 /* ECMA-262 3rd Edition 12.14 */ 483 Finally 484 : kFINALLY Block { $$ = $2; } 485 486 /* ECMA-262 3rd Edition 11.14 */ 487 Expression_opt 488 : /* empty */ { $$ = NULL; } 489 | Expression { $$ = $1; } 490 491 Expression_err 492 : Expression { $$ = $1; } 493 | error { set_error(ctx, JS_E_SYNTAX); YYABORT; } 494 495 /* ECMA-262 3rd Edition 11.14 */ 496 Expression 497 : AssignmentExpression { $$ = $1; } 498 | Expression ',' AssignmentExpression 499 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); } 500 501 /* ECMA-262 3rd Edition 11.14 */ 502 ExpressionNoIn_opt 503 : /* empty */ { $$ = NULL; } 504 | ExpressionNoIn { $$ = $1; } 505 506 /* ECMA-262 3rd Edition 11.14 */ 507 ExpressionNoIn 508 : AssignmentExpressionNoIn 509 { $$ = $1; } 510 | ExpressionNoIn ',' AssignmentExpressionNoIn 511 { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); } 512 513 AssignOper 514 : tAssignOper { $$ = $1; } 515 | kDIVEQ { $$ = EXPR_ASSIGNDIV; } 516 517 /* ECMA-262 3rd Edition 11.13 */ 518 AssignmentExpression 519 : ConditionalExpression { $$ = $1; } 520 | LeftHandSideExpression '=' AssignmentExpression 521 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); } 522 | LeftHandSideExpression AssignOper AssignmentExpression 523 { $$ = new_binary_expression(ctx, $2, $1, $3); } 524 525 /* ECMA-262 3rd Edition 11.13 */ 526 AssignmentExpressionNoIn 527 : ConditionalExpressionNoIn 528 { $$ = $1; } 529 | LeftHandSideExpression '=' AssignmentExpressionNoIn 530 { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3); } 531 | LeftHandSideExpression AssignOper AssignmentExpressionNoIn 532 { $$ = new_binary_expression(ctx, $2, $1, $3); } 533 534 /* ECMA-262 3rd Edition 11.12 */ 535 ConditionalExpression 536 : LogicalORExpression { $$ = $1; } 537 | LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression 538 { $$ = new_conditional_expression(ctx, $1, $3, $5); } 539 540 /* ECMA-262 3rd Edition 11.12 */ 541 ConditionalExpressionNoIn 542 : LogicalORExpressionNoIn 543 { $$ = $1; } 544 | LogicalORExpressionNoIn '?' AssignmentExpressionNoIn ':' AssignmentExpressionNoIn 545 { $$ = new_conditional_expression(ctx, $1, $3, $5); } 546 547 /* ECMA-262 3rd Edition 11.11 */ 548 LogicalORExpression 549 : LogicalANDExpression { $$ = $1; } 550 | LogicalORExpression tOROR LogicalANDExpression 551 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); } 552 553 /* ECMA-262 3rd Edition 11.11 */ 554 LogicalORExpressionNoIn 555 : LogicalANDExpressionNoIn 556 { $$ = $1; } 557 | LogicalORExpressionNoIn tOROR LogicalANDExpressionNoIn 558 { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); } 559 560 /* ECMA-262 3rd Edition 11.11 */ 561 LogicalANDExpression 562 : BitwiseORExpression { $$ = $1; } 563 | LogicalANDExpression tANDAND BitwiseORExpression 564 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); } 565 566 /* ECMA-262 3rd Edition 11.11 */ 567 LogicalANDExpressionNoIn 568 : BitwiseORExpressionNoIn 569 { $$ = $1; } 570 | LogicalANDExpressionNoIn tANDAND BitwiseORExpressionNoIn 571 { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); } 572 573 /* ECMA-262 3rd Edition 11.10 */ 574 BitwiseORExpression 575 : BitwiseXORExpression { $$ = $1; } 576 | BitwiseORExpression '|' BitwiseXORExpression 577 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); } 578 579 /* ECMA-262 3rd Edition 11.10 */ 580 BitwiseORExpressionNoIn 581 : BitwiseXORExpressionNoIn 582 { $$ = $1; } 583 | BitwiseORExpressionNoIn '|' BitwiseXORExpressionNoIn 584 { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); } 585 586 /* ECMA-262 3rd Edition 11.10 */ 587 BitwiseXORExpression 588 : BitwiseANDExpression { $$ = $1; } 589 | BitwiseXORExpression '^' BitwiseANDExpression 590 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); } 591 592 /* ECMA-262 3rd Edition 11.10 */ 593 BitwiseXORExpressionNoIn 594 : BitwiseANDExpressionNoIn 595 { $$ = $1; } 596 | BitwiseXORExpressionNoIn '^' BitwiseANDExpressionNoIn 597 { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); } 598 599 /* ECMA-262 3rd Edition 11.10 */ 600 BitwiseANDExpression 601 : EqualityExpression { $$ = $1; } 602 | BitwiseANDExpression '&' EqualityExpression 603 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); } 604 605 /* ECMA-262 3rd Edition 11.10 */ 606 BitwiseANDExpressionNoIn 607 : EqualityExpressionNoIn 608 { $$ = $1; } 609 | BitwiseANDExpressionNoIn '&' EqualityExpressionNoIn 610 { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); } 611 612 /* ECMA-262 3rd Edition 11.9 */ 613 EqualityExpression 614 : RelationalExpression { $$ = $1; } 615 | EqualityExpression tEqOper RelationalExpression 616 { $$ = new_binary_expression(ctx, $2, $1, $3); } 617 618 /* ECMA-262 3rd Edition 11.9 */ 619 EqualityExpressionNoIn 620 : RelationalExpressionNoIn { $$ = $1; } 621 | EqualityExpressionNoIn tEqOper RelationalExpressionNoIn 622 { $$ = new_binary_expression(ctx, $2, $1, $3); } 623 624 /* ECMA-262 3rd Edition 11.8 */ 625 RelationalExpression 626 : ShiftExpression { $$ = $1; } 627 | RelationalExpression tRelOper ShiftExpression 628 { $$ = new_binary_expression(ctx, $2, $1, $3); } 629 | RelationalExpression kINSTANCEOF ShiftExpression 630 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); } 631 | RelationalExpression kIN ShiftExpression 632 { $$ = new_binary_expression(ctx, EXPR_IN, $1, $3); } 633 634 /* ECMA-262 3rd Edition 11.8 */ 635 RelationalExpressionNoIn 636 : ShiftExpression { $$ = $1; } 637 | RelationalExpressionNoIn tRelOper ShiftExpression 638 { $$ = new_binary_expression(ctx, $2, $1, $3); } 639 | RelationalExpressionNoIn kINSTANCEOF ShiftExpression 640 { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1, $3); } 641 642 /* ECMA-262 3rd Edition 11.7 */ 643 ShiftExpression 644 : AdditiveExpression { $$ = $1; } 645 | ShiftExpression tShiftOper AdditiveExpression 646 { $$ = new_binary_expression(ctx, $2, $1, $3); } 647 648 /* ECMA-262 3rd Edition 11.6 */ 649 AdditiveExpression 650 : MultiplicativeExpression 651 { $$ = $1; } 652 | AdditiveExpression '+' MultiplicativeExpression 653 { $$ = new_binary_expression(ctx, EXPR_ADD, $1, $3); } 654 | AdditiveExpression '-' MultiplicativeExpression 655 { $$ = new_binary_expression(ctx, EXPR_SUB, $1, $3); } 656 657 /* ECMA-262 3rd Edition 11.5 */ 658 MultiplicativeExpression 659 : UnaryExpression { $$ = $1; } 660 | MultiplicativeExpression '*' UnaryExpression 661 { $$ = new_binary_expression(ctx, EXPR_MUL, $1, $3); } 662 | MultiplicativeExpression '/' UnaryExpression 663 { $$ = new_binary_expression(ctx, EXPR_DIV, $1, $3); } 664 | MultiplicativeExpression '%' UnaryExpression 665 { $$ = new_binary_expression(ctx, EXPR_MOD, $1, $3); } 666 667 /* ECMA-262 3rd Edition 11.4 */ 668 UnaryExpression 669 : PostfixExpression { $$ = $1; } 670 | kDELETE UnaryExpression 671 { $$ = new_unary_expression(ctx, EXPR_DELETE, $2); } 672 | kVOID UnaryExpression { $$ = new_unary_expression(ctx, EXPR_VOID, $2); } 673 | kTYPEOF UnaryExpression 674 { $$ = new_unary_expression(ctx, EXPR_TYPEOF, $2); } 675 | tINC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREINC, $2); } 676 | tDEC UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PREDEC, $2); } 677 | '+' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_PLUS, $2); } 678 | '-' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_MINUS, $2); } 679 | '~' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_BITNEG, $2); } 680 | '!' UnaryExpression { $$ = new_unary_expression(ctx, EXPR_LOGNEG, $2); } 681 682 /* ECMA-262 3rd Edition 11.2 */ 683 PostfixExpression 684 : LeftHandSideExpression 685 { $$ = $1; } 686 | LeftHandSideExpression /* NONL */ tINC 687 { $$ = new_unary_expression(ctx, EXPR_POSTINC, $1); } 688 | LeftHandSideExpression /* NONL */ tDEC 689 { $$ = new_unary_expression(ctx, EXPR_POSTDEC, $1); } 690 691 692 /* ECMA-262 3rd Edition 11.2 */ 693 LeftHandSideExpression 694 : NewExpression { $$ = $1; } 695 | CallExpression { $$ = $1; } 696 697 /* ECMA-262 3rd Edition 11.2 */ 698 NewExpression 699 : MemberExpression { $$ = $1; } 700 | kNEW NewExpression { $$ = new_new_expression(ctx, $2, NULL); } 701 702 /* ECMA-262 3rd Edition 11.2 */ 703 MemberExpression 704 : PrimaryExpression { $$ = $1; } 705 | FunctionExpression { $$ = $1; } 706 | MemberExpression '[' Expression ']' 707 { $$ = new_binary_expression(ctx, EXPR_ARRAY, $1, $3); } 708 | MemberExpression '.' tIdentifier 709 { $$ = new_member_expression(ctx, $1, $3); } 710 | kNEW MemberExpression Arguments 711 { $$ = new_new_expression(ctx, $2, $3); } 712 713 /* ECMA-262 3rd Edition 11.2 */ 714 CallExpression 715 : MemberExpression Arguments 716 { $$ = new_call_expression(ctx, $1, $2); } 717 | CallExpression Arguments 718 { $$ = new_call_expression(ctx, $1, $2); } 719 | CallExpression '[' Expression ']' 720 { $$ = new_binary_expression(ctx, EXPR_ARRAY, $1, $3); } 721 | CallExpression '.' tIdentifier 722 { $$ = new_member_expression(ctx, $1, $3); } 723 724 /* ECMA-262 3rd Edition 11.2 */ 725 Arguments 726 : '(' ')' { $$ = NULL; } 727 | '(' ArgumentList ')' { $$ = $2; } 728 729 /* ECMA-262 3rd Edition 11.2 */ 730 ArgumentList 731 : AssignmentExpression { $$ = new_argument_list(ctx, $1); } 732 | ArgumentList ',' AssignmentExpression 733 { $$ = argument_list_add(ctx, $1, $3); } 734 735 /* ECMA-262 3rd Edition 11.1 */ 736 PrimaryExpression 737 : kTHIS { $$ = new_expression(ctx, EXPR_THIS, 0); } 738 | tIdentifier { $$ = new_identifier_expression(ctx, $1); } 739 | Literal { $$ = new_literal_expression(ctx, $1); } 740 | ArrayLiteral { $$ = $1; } 741 | ObjectLiteral { $$ = $1; } 742 | '(' Expression ')' { $$ = $2; } 743 744 /* ECMA-262 3rd Edition 11.1.4 */ 745 ArrayLiteral 746 : '[' ']' { $$ = new_array_literal_expression(ctx, NULL, 0); } 747 | '[' Elision ']' { $$ = new_array_literal_expression(ctx, NULL, $2+1); } 748 | '[' ElementList ']' { $$ = new_array_literal_expression(ctx, $2, 0); } 749 | '[' ElementList ',' Elision_opt ']' 750 { $$ = new_array_literal_expression(ctx, $2, $4+1); } 751 752 /* ECMA-262 3rd Edition 11.1.4 */ 753 ElementList 754 : Elision_opt AssignmentExpression 755 { $$ = new_element_list(ctx, $1, $2); } 756 | ElementList ',' Elision_opt AssignmentExpression 757 { $$ = element_list_add(ctx, $1, $3, $4); } 758 759 /* ECMA-262 3rd Edition 11.1.4 */ 760 Elision 761 : ',' { $$ = 1; } 762 | Elision ',' { $$ = $1 + 1; } 763 764 /* ECMA-262 3rd Edition 11.1.4 */ 765 Elision_opt 766 : /* empty */ { $$ = 0; } 767 | Elision { $$ = $1; } 768 769 /* ECMA-262 3rd Edition 11.1.5 */ 770 ObjectLiteral 771 : '{' '}' { $$ = new_prop_and_value_expression(ctx, NULL); } 772 | '{' PropertyNameAndValueList '}' 773 { $$ = new_prop_and_value_expression(ctx, $2); } 774 775 /* ECMA-262 3rd Edition 11.1.5 */ 776 PropertyNameAndValueList 777 : PropertyName ':' AssignmentExpression 778 { $$ = new_property_list(ctx, $1, $3); } 779 | PropertyNameAndValueList ',' PropertyName ':' AssignmentExpression 780 { $$ = property_list_add(ctx, $1, $3, $5); } 781 782 /* ECMA-262 3rd Edition 11.1.5 */ 783 PropertyName 784 : tIdentifier { $$ = new_string_literal(ctx, $1); } 785 | tStringLiteral { $$ = new_string_literal(ctx, $1); } 786 | tNumericLiteral { $$ = $1; } 787 788 /* ECMA-262 3rd Edition 7.6 */ 789 Identifier_opt 790 : /* empty*/ { $$ = NULL; } 791 | tIdentifier { $$ = $1; } 792 793 /* ECMA-262 3rd Edition 7.8 */ 794 Literal 795 : kNULL { $$ = new_null_literal(ctx); } 796 | BooleanLiteral { $$ = $1; } 797 | tNumericLiteral { $$ = $1; } 798 | tStringLiteral { $$ = new_string_literal(ctx, $1); } 799 | '/' { $$ = parse_regexp(ctx); 800 if(!$$) YYABORT; } 801 | kDIVEQ { $$ = parse_regexp(ctx); 802 if(!$$) YYABORT; } 803 804 /* ECMA-262 3rd Edition 7.8.2 */ 805 BooleanLiteral 806 : kTRUE { $$ = new_boolean_literal(ctx, VARIANT_TRUE); } 807 | kFALSE { $$ = new_boolean_literal(ctx, VARIANT_FALSE); } 808 | tBooleanLiteral { $$ = $1; } 809 810 semicolon_opt 811 : ';' 812 | error { if(!allow_auto_semicolon(ctx)) {YYABORT;} } 813 814 left_bracket 815 : '(' 816 | error { set_error(ctx, JS_E_MISSING_LBRACKET); YYABORT; } 817 818 right_bracket 819 : ')' 820 | error { set_error(ctx, JS_E_MISSING_RBRACKET); YYABORT; } 821 822 semicolon 823 : ';' 824 | error { set_error(ctx, JS_E_MISSING_SEMICOLON); YYABORT; } 825 826 %% 827 828 static BOOL allow_auto_semicolon(parser_ctx_t *ctx) 829 { 830 return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}'; 831 } 832 833 static void *new_statement(parser_ctx_t *ctx, statement_type_t type, size_t size) 834 { 835 statement_t *stat; 836 837 stat = parser_alloc(ctx, size ? size : sizeof(*stat)); 838 if(!stat) 839 return NULL; 840 841 stat->type = type; 842 stat->next = NULL; 843 844 return stat; 845 } 846 847 static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str) 848 { 849 literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); 850 851 ret->type = LT_STRING; 852 ret->u.wstr = str; 853 854 return ret; 855 } 856 857 static literal_t *new_null_literal(parser_ctx_t *ctx) 858 { 859 literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); 860 861 ret->type = LT_NULL; 862 863 return ret; 864 } 865 866 static prop_val_t *new_prop_val(parser_ctx_t *ctx, literal_t *name, expression_t *value) 867 { 868 prop_val_t *ret = parser_alloc(ctx, sizeof(prop_val_t)); 869 870 ret->name = name; 871 ret->value = value; 872 ret->next = NULL; 873 874 return ret; 875 } 876 877 static property_list_t *new_property_list(parser_ctx_t *ctx, literal_t *name, expression_t *value) 878 { 879 property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t)); 880 881 ret->head = ret->tail = new_prop_val(ctx, name, value); 882 883 return ret; 884 } 885 886 static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list, literal_t *name, expression_t *value) 887 { 888 list->tail = list->tail->next = new_prop_val(ctx, name, value); 889 890 return list; 891 } 892 893 static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t *expr) 894 { 895 array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t)); 896 897 ret->elision = elision; 898 ret->expr = expr; 899 ret->next = NULL; 900 901 return ret; 902 } 903 904 static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t *expr) 905 { 906 element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t)); 907 908 ret->head = ret->tail = new_array_element(ctx, elision, expr); 909 910 return ret; 911 } 912 913 static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int elision, expression_t *expr) 914 { 915 list->tail = list->tail->next = new_array_element(ctx, elision, expr); 916 917 return list; 918 } 919 920 static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr) 921 { 922 argument_t *ret = parser_alloc(ctx, sizeof(argument_t)); 923 924 ret->expr = expr; 925 ret->next = NULL; 926 927 return ret; 928 } 929 930 static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr) 931 { 932 argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t)); 933 934 ret->head = ret->tail = new_argument(ctx, expr); 935 936 return ret; 937 } 938 939 static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list, expression_t *expr) 940 { 941 list->tail = list->tail->next = new_argument(ctx, expr); 942 943 return list; 944 } 945 946 static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement) 947 { 948 catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t)); 949 950 ret->identifier = identifier; 951 ret->statement = statement; 952 953 return ret; 954 } 955 956 static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr, statement_list_t *stat_list) 957 { 958 case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t)); 959 960 ret->expr = expr; 961 ret->stat = stat_list ? stat_list->head : NULL; 962 ret->next = NULL; 963 964 return ret; 965 } 966 967 static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule) 968 { 969 case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t)); 970 971 ret->head = ret->tail = case_clausule; 972 973 return ret; 974 } 975 976 static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t *case_clausule) 977 { 978 list->tail = list->tail->next = case_clausule; 979 980 return list; 981 } 982 983 static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1, 984 case_clausule_t *default_clausule, case_list_t *case_list2) 985 { 986 case_clausule_t *ret = NULL, *iter = NULL, *iter2; 987 statement_t *stat = NULL; 988 989 if(case_list1) { 990 ret = case_list1->head; 991 iter = case_list1->tail; 992 } 993 994 if(default_clausule) { 995 if(ret) 996 iter = iter->next = default_clausule; 997 else 998 ret = iter = default_clausule; 999 } 1000 1001 if(case_list2) { 1002 if(ret) 1003 iter->next = case_list2->head; 1004 else 1005 ret = case_list2->head; 1006 } 1007 1008 if(!ret) 1009 return NULL; 1010 1011 for(iter = ret; iter; iter = iter->next) { 1012 for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next); 1013 if(!iter2) 1014 break; 1015 1016 while(iter != iter2) { 1017 iter->stat = iter2->stat; 1018 iter = iter->next; 1019 } 1020 1021 if(stat) { 1022 while(stat->next) 1023 stat = stat->next; 1024 stat->next = iter->stat; 1025 }else { 1026 stat = iter->stat; 1027 } 1028 } 1029 1030 return ret; 1031 } 1032 1033 static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list) 1034 { 1035 block_statement_t *ret; 1036 1037 ret = new_statement(ctx, STAT_BLOCK, sizeof(*ret)); 1038 if(!ret) 1039 return NULL; 1040 1041 ret->stat_list = list ? list->head : NULL; 1042 1043 return &ret->stat; 1044 } 1045 1046 static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR *identifier, expression_t *expr) 1047 { 1048 variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t)); 1049 1050 ret->identifier = identifier; 1051 ret->expr = expr; 1052 ret->next = NULL; 1053 ret->global_next = NULL; 1054 1055 return ret; 1056 } 1057 1058 static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t *decl) 1059 { 1060 variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t)); 1061 1062 ret->head = ret->tail = decl; 1063 1064 return ret; 1065 } 1066 1067 static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list, variable_declaration_t *decl) 1068 { 1069 list->tail = list->tail->next = decl; 1070 1071 return list; 1072 } 1073 1074 static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list) 1075 { 1076 var_statement_t *ret; 1077 1078 ret = new_statement(ctx, STAT_VAR, sizeof(*ret)); 1079 if(!ret) 1080 return NULL; 1081 1082 ret->variable_list = variable_list->head; 1083 1084 return &ret->stat; 1085 } 1086 1087 static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr) 1088 { 1089 expression_statement_t *ret; 1090 1091 ret = new_statement(ctx, STAT_EXPR, sizeof(*ret)); 1092 if(!ret) 1093 return NULL; 1094 1095 ret->expr = expr; 1096 1097 return &ret->stat; 1098 } 1099 1100 static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *if_stat, statement_t *else_stat) 1101 { 1102 if_statement_t *ret; 1103 1104 ret = new_statement(ctx, STAT_IF, sizeof(*ret)); 1105 if(!ret) 1106 return NULL; 1107 1108 ret->expr = expr; 1109 ret->if_stat = if_stat; 1110 ret->else_stat = else_stat; 1111 1112 return &ret->stat; 1113 } 1114 1115 static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t *expr, statement_t *stat) 1116 { 1117 while_statement_t *ret; 1118 1119 ret = new_statement(ctx, STAT_WHILE, sizeof(*ret)); 1120 if(!ret) 1121 return NULL; 1122 1123 ret->do_while = dowhile; 1124 ret->expr = expr; 1125 ret->statement = stat; 1126 1127 return &ret->stat; 1128 } 1129 1130 static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list, expression_t *begin_expr, 1131 expression_t *expr, expression_t *end_expr, statement_t *statement) 1132 { 1133 for_statement_t *ret; 1134 1135 ret = new_statement(ctx, STAT_FOR, sizeof(*ret)); 1136 if(!ret) 1137 return NULL; 1138 1139 ret->variable_list = variable_list ? variable_list->head : NULL; 1140 ret->begin_expr = begin_expr; 1141 ret->expr = expr; 1142 ret->end_expr = end_expr; 1143 ret->statement = statement; 1144 1145 return &ret->stat; 1146 } 1147 1148 static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t *variable, expression_t *expr, 1149 expression_t *in_expr, statement_t *statement) 1150 { 1151 forin_statement_t *ret; 1152 1153 ret = new_statement(ctx, STAT_FORIN, sizeof(*ret)); 1154 if(!ret) 1155 return NULL; 1156 1157 ret->variable = variable; 1158 ret->expr = expr; 1159 ret->in_expr = in_expr; 1160 ret->statement = statement; 1161 1162 return &ret->stat; 1163 } 1164 1165 static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier) 1166 { 1167 branch_statement_t *ret; 1168 1169 ret = new_statement(ctx, STAT_CONTINUE, sizeof(*ret)); 1170 if(!ret) 1171 return NULL; 1172 1173 ret->identifier = identifier; 1174 1175 return &ret->stat; 1176 } 1177 1178 static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier) 1179 { 1180 branch_statement_t *ret; 1181 1182 ret = new_statement(ctx, STAT_BREAK, sizeof(*ret)); 1183 if(!ret) 1184 return NULL; 1185 1186 ret->identifier = identifier; 1187 1188 return &ret->stat; 1189 } 1190 1191 static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr) 1192 { 1193 expression_statement_t *ret; 1194 1195 ret = new_statement(ctx, STAT_RETURN, sizeof(*ret)); 1196 if(!ret) 1197 return NULL; 1198 1199 ret->expr = expr; 1200 1201 return &ret->stat; 1202 } 1203 1204 static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t *statement) 1205 { 1206 with_statement_t *ret; 1207 1208 ret = new_statement(ctx, STAT_WITH, sizeof(*ret)); 1209 if(!ret) 1210 return NULL; 1211 1212 ret->expr = expr; 1213 ret->statement = statement; 1214 1215 return &ret->stat; 1216 } 1217 1218 static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier, statement_t *statement) 1219 { 1220 labelled_statement_t *ret; 1221 1222 ret = new_statement(ctx, STAT_LABEL, sizeof(*ret)); 1223 if(!ret) 1224 return NULL; 1225 1226 ret->identifier = identifier; 1227 ret->statement = statement; 1228 1229 return &ret->stat; 1230 } 1231 1232 static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr, case_clausule_t *case_list) 1233 { 1234 switch_statement_t *ret; 1235 1236 ret = new_statement(ctx, STAT_SWITCH, sizeof(*ret)); 1237 if(!ret) 1238 return NULL; 1239 1240 ret->expr = expr; 1241 ret->case_list = case_list; 1242 1243 return &ret->stat; 1244 } 1245 1246 static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr) 1247 { 1248 expression_statement_t *ret; 1249 1250 ret = new_statement(ctx, STAT_THROW, sizeof(*ret)); 1251 if(!ret) 1252 return NULL; 1253 1254 ret->expr = expr; 1255 1256 return &ret->stat; 1257 } 1258 1259 static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement, 1260 catch_block_t *catch_block, statement_t *finally_statement) 1261 { 1262 try_statement_t *ret; 1263 1264 ret = new_statement(ctx, STAT_TRY, sizeof(*ret)); 1265 if(!ret) 1266 return NULL; 1267 1268 ret->try_statement = try_statement; 1269 ret->catch_block = catch_block; 1270 ret->finally_statement = finally_statement; 1271 1272 return &ret->stat; 1273 } 1274 1275 static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier) 1276 { 1277 parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t)); 1278 1279 ret->identifier = identifier; 1280 ret->next = NULL; 1281 1282 return ret; 1283 } 1284 1285 static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier) 1286 { 1287 parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t)); 1288 1289 ret->head = ret->tail = new_parameter(ctx, identifier); 1290 1291 return ret; 1292 } 1293 1294 static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list, const WCHAR *identifier) 1295 { 1296 list->tail = list->tail->next = new_parameter(ctx, identifier); 1297 1298 return list; 1299 } 1300 1301 static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier, parameter_list_t *parameter_list, 1302 source_elements_t *source_elements, const WCHAR *event_target, const WCHAR *src_str, DWORD src_len) 1303 { 1304 function_expression_t *ret = new_expression(ctx, EXPR_FUNC, sizeof(*ret)); 1305 1306 ret->identifier = identifier; 1307 ret->parameter_list = parameter_list ? parameter_list->head : NULL; 1308 ret->source_elements = source_elements; 1309 ret->event_target = event_target; 1310 ret->src_str = src_str; 1311 ret->src_len = src_len; 1312 ret->next = NULL; 1313 1314 return &ret->expr; 1315 } 1316 1317 static void *new_expression(parser_ctx_t *ctx, expression_type_t type, size_t size) 1318 { 1319 expression_t *ret = parser_alloc(ctx, size ? size : sizeof(*ret)); 1320 1321 ret->type = type; 1322 1323 return ret; 1324 } 1325 1326 static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type, 1327 expression_t *expression1, expression_t *expression2) 1328 { 1329 binary_expression_t *ret = new_expression(ctx, type, sizeof(*ret)); 1330 1331 ret->expression1 = expression1; 1332 ret->expression2 = expression2; 1333 1334 return &ret->expr; 1335 } 1336 1337 static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type, expression_t *expression) 1338 { 1339 unary_expression_t *ret = new_expression(ctx, type, sizeof(*ret)); 1340 1341 ret->expression = expression; 1342 1343 return &ret->expr; 1344 } 1345 1346 static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t *expression, 1347 expression_t *true_expression, expression_t *false_expression) 1348 { 1349 conditional_expression_t *ret = new_expression(ctx, EXPR_COND, sizeof(*ret)); 1350 1351 ret->expression = expression; 1352 ret->true_expression = true_expression; 1353 ret->false_expression = false_expression; 1354 1355 return &ret->expr; 1356 } 1357 1358 static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression, const WCHAR *identifier) 1359 { 1360 member_expression_t *ret = new_expression(ctx, EXPR_MEMBER, sizeof(*ret)); 1361 1362 ret->expression = expression; 1363 ret->identifier = identifier; 1364 1365 return &ret->expr; 1366 } 1367 1368 static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list) 1369 { 1370 call_expression_t *ret = new_expression(ctx, EXPR_NEW, sizeof(*ret)); 1371 1372 ret->expression = expression; 1373 ret->argument_list = argument_list ? argument_list->head : NULL; 1374 1375 return &ret->expr; 1376 } 1377 1378 static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression, argument_list_t *argument_list) 1379 { 1380 call_expression_t *ret = new_expression(ctx, EXPR_CALL, sizeof(*ret)); 1381 1382 ret->expression = expression; 1383 ret->argument_list = argument_list ? argument_list->head : NULL; 1384 1385 return &ret->expr; 1386 } 1387 1388 static int parser_error(parser_ctx_t *ctx, const char *str) 1389 { 1390 return 0; 1391 } 1392 1393 static void set_error(parser_ctx_t *ctx, UINT error) 1394 { 1395 ctx->hres = error; 1396 } 1397 1398 static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next) 1399 { 1400 if(obj || *(ctx->ptr-1)==next) return TRUE; 1401 1402 set_error(ctx, JS_E_SYNTAX); 1403 return FALSE; 1404 } 1405 1406 1407 static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR *identifier) 1408 { 1409 identifier_expression_t *ret = new_expression(ctx, EXPR_IDENT, sizeof(*ret)); 1410 1411 ret->identifier = identifier; 1412 1413 return &ret->expr; 1414 } 1415 1416 static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t *element_list, int length) 1417 { 1418 array_literal_expression_t *ret = new_expression(ctx, EXPR_ARRAYLIT, sizeof(*ret)); 1419 1420 ret->element_list = element_list ? element_list->head : NULL; 1421 ret->length = length; 1422 1423 return &ret->expr; 1424 } 1425 1426 static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t *property_list) 1427 { 1428 property_value_expression_t *ret = new_expression(ctx, EXPR_PROPVAL, sizeof(*ret)); 1429 1430 ret->property_list = property_list ? property_list->head : NULL; 1431 1432 return &ret->expr; 1433 } 1434 1435 static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal) 1436 { 1437 literal_expression_t *ret = new_expression(ctx, EXPR_LITERAL, sizeof(*ret)); 1438 1439 ret->literal = literal; 1440 1441 return &ret->expr; 1442 } 1443 1444 static source_elements_t *new_source_elements(parser_ctx_t *ctx) 1445 { 1446 source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t)); 1447 1448 memset(ret, 0, sizeof(*ret)); 1449 1450 return ret; 1451 } 1452 1453 static source_elements_t *source_elements_add_statement(source_elements_t *source_elements, statement_t *statement) 1454 { 1455 if(source_elements->statement_tail) 1456 source_elements->statement_tail = source_elements->statement_tail->next = statement; 1457 else 1458 source_elements->statement = source_elements->statement_tail = statement; 1459 1460 return source_elements; 1461 } 1462 1463 static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement) 1464 { 1465 statement_list_t *ret = parser_alloc_tmp(ctx, sizeof(statement_list_t)); 1466 1467 ret->head = ret->tail = statement; 1468 1469 return ret; 1470 } 1471 1472 static statement_list_t *statement_list_add(statement_list_t *list, statement_t *statement) 1473 { 1474 list->tail = list->tail->next = statement; 1475 1476 return list; 1477 } 1478 1479 static void program_parsed(parser_ctx_t *ctx, source_elements_t *source) 1480 { 1481 ctx->source = source; 1482 if(!ctx->lexer_error) 1483 ctx->hres = S_OK; 1484 } 1485 1486 void parser_release(parser_ctx_t *ctx) 1487 { 1488 script_release(ctx->script); 1489 heap_pool_free(&ctx->heap); 1490 heap_free(ctx); 1491 } 1492 1493 HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter, BOOL from_eval, 1494 parser_ctx_t **ret) 1495 { 1496 parser_ctx_t *parser_ctx; 1497 heap_pool_t *mark; 1498 HRESULT hres; 1499 1500 const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0}; 1501 1502 parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t)); 1503 if(!parser_ctx) 1504 return E_OUTOFMEMORY; 1505 1506 parser_ctx->hres = JS_E_SYNTAX; 1507 parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW); 1508 1509 parser_ctx->begin = parser_ctx->ptr = code; 1510 parser_ctx->end = parser_ctx->begin + strlenW(parser_ctx->begin); 1511 1512 script_addref(ctx); 1513 parser_ctx->script = ctx; 1514 1515 mark = heap_pool_mark(&ctx->tmp_heap); 1516 heap_pool_init(&parser_ctx->heap); 1517 1518 parser_parse(parser_ctx); 1519 heap_pool_clear(mark); 1520 hres = parser_ctx->hres; 1521 if(FAILED(hres)) { 1522 WARN("parser failed around %s\n", 1523 debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20)); 1524 parser_release(parser_ctx); 1525 return hres; 1526 } 1527 1528 *ret = parser_ctx; 1529 return S_OK; 1530 } 1531