JavaScriptCore/kjs/grammar.y

   1 %{
   2
   3 /*
   4  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   5  *  Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
   6  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include "value.h"
  29 #include "object.h"
  30 #include "types.h"
  31 #include "interpreter.h"
  32 #include "nodes.h"
  33 #include "lexer.h"
  34 #include "internal.h"
  35 #include "CommonIdentifiers.h"
  36 #include <wtf/MathExtras.h>
  37
  38 // Not sure why, but yacc doesn't add this define along with the others.
  39 #define yylloc kjsyylloc
  40
  41 #define YYMAXDEPTH 10000
  42 #define YYENABLE_NLS 0
  43
  44 /* default values for bison */
  45 #define YYDEBUG 0
  46 #if !PLATFORM(DARWIN)
  47     // avoid triggering warnings in older bison
  48 #define YYERROR_VERBOSE
  49 #endif
  50
  51 extern int kjsyylex();
  52 int kjsyyerror(const char *);
  53 static bool allowAutomaticSemicolon();
  54
  55 #define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0)
  56 #define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line)
  57
  58 using namespace KJS;
  59
  60 static Node* makeAssignNode(Node* loc, Operator, Node* expr);
  61 static Node* makePrefixNode(Node* expr, Operator);
  62 static Node* makePostfixNode(Node* expr, Operator);
  63 static PropertyNode* makeGetterOrSetterPropertyNode(const Identifier &getOrSet, const Identifier& name, ParameterNode*, FunctionBodyNode*);
  64 static Node *makeFunctionCallNode(Node *func, ArgumentsNode *args);
  65 static Node *makeTypeOfNode(Node *expr);
  66 static Node *makeDeleteNode(Node *expr);
  67 static Node *makeNegateNode(Node *expr);
  68 static Node* makeNumberNode(double);
  69
  70 #if COMPILER(MSVC)
  71
  72 #pragma warning(disable: 4065)
  73 #pragma warning(disable: 4244)
  74 #pragma warning(disable: 4702)
  75
  76 // At least some of the time, the declarations of malloc and free that bison
  77 // generates are causing warnings. A way to avoid this is to explicitly define
  78 // the macros so that bison doesn't try to declare malloc and free.
  79 #define YYMALLOC malloc
  80 #define YYFREE free
  81
  82 #endif
  83
  84 %}
  85
  86 %union {
  87   int                 ival;
  88   double              dval;
  89   UString             *ustr;
  90   Identifier          *ident;
  91   Node                *node;
  92   StatementNode       *stat;
  93   ParameterList       param;
  94   FunctionBodyNode    *body;
  95   FuncDeclNode        *func;
  96   FuncExprNode        *funcExpr;
  97   ProgramNode         *prog;
  98   AssignExprNode      *init;
  99   SourceElements      *srcs;
 100   ArgumentsNode       *args;
 101   ArgumentList        alist;
 102   VarDeclNode         *decl;
 103   VarDeclList         vlist;
 104   CaseBlockNode       *cblk;
 105   ClauseList          clist;
 106   CaseClauseNode      *ccl;
 107   ElementList         elm;
 108   Operator            op;
 109   PropertyList        plist;
 110   PropertyNode       *pnode;
 111 }
 112
 113 %start Program
 114
 115 /* literals */
 116 %token NULLTOKEN TRUETOKEN FALSETOKEN
 117
 118 /* keywords */
 119 %token BREAK CASE DEFAULT FOR NEW VAR CONSTTOKEN CONTINUE
 120 %token FUNCTION RETURN VOIDTOKEN DELETETOKEN
 121 %token IF THISTOKEN DO WHILE INTOKEN INSTANCEOF TYPEOF
 122 %token SWITCH WITH RESERVED
 123 %token THROW TRY CATCH FINALLY
 124 %token DEBUGGER
 125
 126 /* give an if without an else higher precedence than an else to resolve the ambiguity */
 127 %nonassoc IF_WITHOUT_ELSE
 128 %nonassoc ELSE
 129
 130 /* punctuators */
 131 %token EQEQ NE                     /* == and != */
 132 %token STREQ STRNEQ                /* === and !== */
 133 %token LE GE                       /* < and > */
 134 %token OR AND                      /* || and && */
 135 %token PLUSPLUS MINUSMINUS         /* ++ and --  */
 136 %token LSHIFT                      /* << */
 137 %token RSHIFT URSHIFT              /* >> and >>> */
 138 %token PLUSEQUAL MINUSEQUAL        /* += and -= */
 139 %token MULTEQUAL DIVEQUAL          /* *= and /= */
 140 %token LSHIFTEQUAL                 /* <<= */
 141 %token RSHIFTEQUAL URSHIFTEQUAL    /* >>= and >>>= */
 142 %token ANDEQUAL MODEQUAL           /* &= and %= */
 143 %token XOREQUAL OREQUAL            /* ^= and |= */
 144
 145 /* terminal types */
 146 %token <dval> NUMBER
 147 %token <ustr> STRING
 148 %token <ident> IDENT
 149
 150 /* automatically inserted semicolon */
 151 %token AUTOPLUSPLUS AUTOMINUSMINUS
 152
 153 /* non-terminal types */
 154 %type <node>  Literal ArrayLiteral
 155
 156 %type <node>  PrimaryExpr PrimaryExprNoBrace
 157 %type <node>  MemberExpr MemberExprNoBF /* BF => brace or function */
 158 %type <node>  NewExpr NewExprNoBF
 159 %type <node>  CallExpr CallExprNoBF
 160 %type <node>  LeftHandSideExpr LeftHandSideExprNoBF
 161 %type <node>  PostfixExpr PostfixExprNoBF
 162 %type <node>  UnaryExpr UnaryExprNoBF UnaryExprCommon
 163 %type <node>  MultiplicativeExpr MultiplicativeExprNoBF
 164 %type <node>  AdditiveExpr AdditiveExprNoBF
 165 %type <node>  ShiftExpr ShiftExprNoBF
 166 %type <node>  RelationalExpr RelationalExprNoIn RelationalExprNoBF
 167 %type <node>  EqualityExpr EqualityExprNoIn EqualityExprNoBF
 168 %type <node>  BitwiseANDExpr BitwiseANDExprNoIn BitwiseANDExprNoBF
 169 %type <node>  BitwiseXORExpr BitwiseXORExprNoIn BitwiseXORExprNoBF
 170 %type <node>  BitwiseORExpr BitwiseORExprNoIn BitwiseORExprNoBF
 171 %type <node>  LogicalANDExpr LogicalANDExprNoIn LogicalANDExprNoBF
 172 %type <node>  LogicalORExpr LogicalORExprNoIn LogicalORExprNoBF
 173 %type <node>  ConditionalExpr ConditionalExprNoIn ConditionalExprNoBF
 174 %type <node>  AssignmentExpr AssignmentExprNoIn AssignmentExprNoBF
 175 %type <node>  Expr ExprNoIn ExprNoBF
 176
 177 %type <node>  ExprOpt ExprNoInOpt
 178
 179 %type <stat>  Statement Block
 180 %type <stat>  VariableStatement ConstStatement EmptyStatement ExprStatement
 181 %type <stat>  IfStatement IterationStatement ContinueStatement
 182 %type <stat>  BreakStatement ReturnStatement WithStatement
 183 %type <stat>  SwitchStatement LabelledStatement
 184 %type <stat>  ThrowStatement TryStatement
 185 %type <stat>  DebuggerStatement
 186 %type <stat>  SourceElement
 187
 188 %type <init>  Initializer InitializerNoIn
 189 %type <func>  FunctionDeclaration
 190 %type <funcExpr>  FunctionExpr
 191 %type <body>  FunctionBody
 192 %type <srcs>  SourceElements
 193 %type <param> FormalParameterList
 194 %type <op>    AssignmentOperator
 195 %type <args>  Arguments
 196 %type <alist> ArgumentList
 197 %type <vlist> VariableDeclarationList VariableDeclarationListNoIn ConstDeclarationList
 198 %type <decl>  VariableDeclaration VariableDeclarationNoIn ConstDeclaration
 199 %type <cblk>  CaseBlock
 200 %type <ccl>   CaseClause DefaultClause
 201 %type <clist> CaseClauses CaseClausesOpt
 202 %type <ival>  Elision ElisionOpt
 203 %type <elm>   ElementList
 204 %type <pnode> Property
 205 %type <plist> PropertyList
 206 %%
 207
 208 Literal:
 209     NULLTOKEN                           { $$ = new NullNode(); }
 210   | TRUETOKEN                           { $$ = new BooleanNode(true); }
 211   | FALSETOKEN                          { $$ = new BooleanNode(false); }
 212   | NUMBER                              { $$ = makeNumberNode($1); }
 213   | STRING                              { $$ = new StringNode($1); }
 214   | '/' /* regexp */                    {
 215                                             Lexer *l = Lexer::curr();
 216                                             if (!l->scanRegExp()) YYABORT;
 217                                             $$ = new RegExpNode(l->pattern, l->flags);
 218                                         }
 219   | DIVEQUAL /* regexp with /= */       {
 220                                             Lexer *l = Lexer::curr();
 221                                             if (!l->scanRegExp()) YYABORT;
 222                                             $$ = new RegExpNode("=" + l->pattern, l->flags);
 223                                         }
 224 ;
 225
 226 Property:
 227     IDENT ':' AssignmentExpr            { $$ = new PropertyNode(*$1, $3, PropertyNode::Constant); }
 228   | STRING ':' AssignmentExpr           { $$ = new PropertyNode(Identifier(*$1), $3, PropertyNode::Constant); }
 229   | NUMBER ':' AssignmentExpr           { $$ = new PropertyNode(Identifier(UString::from($1)), $3, PropertyNode::Constant); }
 230   | IDENT IDENT '(' ')' FunctionBody    { $$ = makeGetterOrSetterPropertyNode(*$1, *$2, 0, $5); if (!$$) YYABORT; }
 231   | IDENT IDENT '(' FormalParameterList ')' FunctionBody
 232                                         { $$ = makeGetterOrSetterPropertyNode(*$1, *$2, $4.head, $6); if (!$$) YYABORT; }
 233 ;
 234
 235 PropertyList:
 236     Property                            { $$.head = new PropertyListNode($1);
 237                                           $$.tail = $$.head; }
 238   | PropertyList ',' Property           { $$.head = $1.head;
 239                                           $$.tail = new PropertyListNode($3, $1.tail); }
 240 ;
 241
 242 PrimaryExpr:
 243     PrimaryExprNoBrace
 244   | '{' '}'                             { $$ = new ObjectLiteralNode(); }
 245   | '{' PropertyList '}'                { $$ = new ObjectLiteralNode($2.head); }
 246   /* allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939 */
 247   | '{' PropertyList ',' '}'            { $$ = new ObjectLiteralNode($2.head); }
 248 ;
 249
 250 PrimaryExprNoBrace:
 251     THISTOKEN                           { $$ = new ThisNode(); }
 252   | Literal
 253   | ArrayLiteral
 254   | IDENT                               { $$ = new ResolveNode(*$1); }
 255   | '(' Expr ')'                        { $$ = $2; }
 256 ;
 257
 258 ArrayLiteral:
 259     '[' ElisionOpt ']'                  { $$ = new ArrayNode($2); }
 260   | '[' ElementList ']'                 { $$ = new ArrayNode($2.head); }
 261   | '[' ElementList ',' ElisionOpt ']'  { $$ = new ArrayNode($4, $2.head); }
 262 ;
 263
 264 ElementList:
 265     ElisionOpt AssignmentExpr           { $$.head = new ElementNode($1, $2);
 266                                           $$.tail = $$.head; }
 267   | ElementList ',' ElisionOpt AssignmentExpr
 268                                         { $$.head = $1.head;
 269                                           $$.tail = new ElementNode($1.tail, $3, $4); }
 270 ;
 271
 272 ElisionOpt:
 273     /* nothing */                       { $$ = 0; }
 274   | Elision
 275 ;
 276
 277 Elision:
 278     ','                                 { $$ = 1; }
 279   | Elision ','                         { $$ = $1 + 1; }
 280 ;
 281
 282 MemberExpr:
 283     PrimaryExpr
 284   | FunctionExpr                        { $$ = $1; }
 285   | MemberExpr '[' Expr ']'             { $$ = new BracketAccessorNode($1, $3); }
 286   | MemberExpr '.' IDENT                { $$ = new DotAccessorNode($1, *$3); }
 287   | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
 288 ;
 289
 290 MemberExprNoBF:
 291     PrimaryExprNoBrace
 292   | MemberExprNoBF '[' Expr ']'         { $$ = new BracketAccessorNode($1, $3); }
 293   | MemberExprNoBF '.' IDENT            { $$ = new DotAccessorNode($1, *$3); }
 294   | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
 295 ;
 296
 297 NewExpr:
 298     MemberExpr
 299   | NEW NewExpr                         { $$ = new NewExprNode($2); }
 300 ;
 301
 302 NewExprNoBF:
 303     MemberExprNoBF
 304   | NEW NewExpr                         { $$ = new NewExprNode($2); }
 305 ;
 306
 307 CallExpr:
 308     MemberExpr Arguments                { $$ = makeFunctionCallNode($1, $2); }
 309   | CallExpr Arguments                  { $$ = makeFunctionCallNode($1, $2); }
 310   | CallExpr '[' Expr ']'               { $$ = new BracketAccessorNode($1, $3); }
 311   | CallExpr '.' IDENT                  { $$ = new DotAccessorNode($1, *$3); }
 312 ;
 313
 314 CallExprNoBF:
 315     MemberExprNoBF Arguments            { $$ = makeFunctionCallNode($1, $2); }
 316   | CallExprNoBF Arguments              { $$ = makeFunctionCallNode($1, $2); }
 317   | CallExprNoBF '[' Expr ']'           { $$ = new BracketAccessorNode($1, $3); }
 318   | CallExprNoBF '.' IDENT              { $$ = new DotAccessorNode($1, *$3); }
 319 ;
 320
 321 Arguments:
 322     '(' ')'                             { $$ = new ArgumentsNode(); }
 323   | '(' ArgumentList ')'                { $$ = new ArgumentsNode($2.head); }
 324 ;
 325
 326 ArgumentList:
 327     AssignmentExpr                      { $$.head = new ArgumentListNode($1);
 328                                           $$.tail = $$.head; }
 329   | ArgumentList ',' AssignmentExpr     { $$.head = $1.head;
 330                                           $$.tail = new ArgumentListNode($1.tail, $3); }
 331 ;
 332
 333 LeftHandSideExpr:
 334     NewExpr
 335   | CallExpr
 336 ;
 337
 338 LeftHandSideExprNoBF:
 339     NewExprNoBF
 340   | CallExprNoBF
 341 ;
 342
 343 PostfixExpr:
 344     LeftHandSideExpr
 345   | LeftHandSideExpr PLUSPLUS           { $$ = makePostfixNode($1, OpPlusPlus); }
 346   | LeftHandSideExpr MINUSMINUS         { $$ = makePostfixNode($1, OpMinusMinus); }
 347 ;
 348
 349 PostfixExprNoBF:
 350     LeftHandSideExprNoBF
 351   | LeftHandSideExprNoBF PLUSPLUS       { $$ = makePostfixNode($1, OpPlusPlus); }
 352   | LeftHandSideExprNoBF MINUSMINUS     { $$ = makePostfixNode($1, OpMinusMinus); }
 353 ;
 354
 355 UnaryExprCommon:
 356     DELETETOKEN UnaryExpr               { $$ = makeDeleteNode($2); }
 357   | VOIDTOKEN UnaryExpr                 { $$ = new VoidNode($2); }
 358   | TYPEOF UnaryExpr                    { $$ = makeTypeOfNode($2); }
 359   | PLUSPLUS UnaryExpr                  { $$ = makePrefixNode($2, OpPlusPlus); }
 360   | AUTOPLUSPLUS UnaryExpr              { $$ = makePrefixNode($2, OpPlusPlus); }
 361   | MINUSMINUS UnaryExpr                { $$ = makePrefixNode($2, OpMinusMinus); }
 362   | AUTOMINUSMINUS UnaryExpr            { $$ = makePrefixNode($2, OpMinusMinus); }
 363   | '+' UnaryExpr                       { $$ = new UnaryPlusNode($2); }
 364   | '-' UnaryExpr                       { $$ = makeNegateNode($2); }
 365   | '~' UnaryExpr                       { $$ = new BitwiseNotNode($2); }
 366   | '!' UnaryExpr                       { $$ = new LogicalNotNode($2); }
 367
 368 UnaryExpr:
 369     PostfixExpr
 370   | UnaryExprCommon
 371 ;
 372
 373 UnaryExprNoBF:
 374     PostfixExprNoBF
 375   | UnaryExprCommon
 376 ;
 377
 378 MultiplicativeExpr:
 379     UnaryExpr
 380   | MultiplicativeExpr '*' UnaryExpr    { $$ = new MultNode($1, $3); }
 381   | MultiplicativeExpr '/' UnaryExpr    { $$ = new DivNode($1, $3); }
 382   | MultiplicativeExpr '%' UnaryExpr    { $$ = new ModNode($1, $3); }
 383 ;
 384
 385 MultiplicativeExprNoBF:
 386     UnaryExprNoBF
 387   | MultiplicativeExprNoBF '*' UnaryExpr
 388                                         { $$ = new MultNode($1, $3); }
 389   | MultiplicativeExprNoBF '/' UnaryExpr
 390                                         { $$ = new DivNode($1, $3); }
 391   | MultiplicativeExprNoBF '%' UnaryExpr
 392                                         { $$ = new ModNode($1, $3); }
 393 ;
 394
 395 AdditiveExpr:
 396     MultiplicativeExpr
 397   | AdditiveExpr '+' MultiplicativeExpr { $$ = new AddNode($1, $3); }
 398   | AdditiveExpr '-' MultiplicativeExpr { $$ = new SubNode($1, $3); }
 399 ;
 400
 401 AdditiveExprNoBF:
 402     MultiplicativeExprNoBF
 403   | AdditiveExprNoBF '+' MultiplicativeExpr
 404                                         { $$ = new AddNode($1, $3); }
 405   | AdditiveExprNoBF '-' MultiplicativeExpr
 406                                         { $$ = new SubNode($1, $3); }
 407 ;
 408
 409 ShiftExpr:
 410     AdditiveExpr
 411   | ShiftExpr LSHIFT AdditiveExpr       { $$ = new LeftShiftNode($1, $3); }
 412   | ShiftExpr RSHIFT AdditiveExpr       { $$ = new RightShiftNode($1, $3); }
 413   | ShiftExpr URSHIFT AdditiveExpr      { $$ = new UnsignedRightShiftNode($1, $3); }
 414 ;
 415
 416 ShiftExprNoBF:
 417     AdditiveExprNoBF
 418   | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = new LeftShiftNode($1, $3); }
 419   | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = new RightShiftNode($1, $3); }
 420   | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = new UnsignedRightShiftNode($1, $3); }
 421 ;
 422
 423 RelationalExpr:
 424     ShiftExpr
 425   | RelationalExpr '<' ShiftExpr        { $$ = new LessNode($1, $3); }
 426   | RelationalExpr '>' ShiftExpr        { $$ = new GreaterNode($1, $3); }
 427   | RelationalExpr LE ShiftExpr         { $$ = new LessEqNode($1, $3); }
 428   | RelationalExpr GE ShiftExpr         { $$ = new GreaterEqNode($1, $3); }
 429   | RelationalExpr INSTANCEOF ShiftExpr { $$ = new InstanceOfNode($1, $3); }
 430   | RelationalExpr INTOKEN ShiftExpr    { $$ = new InNode($1, $3); }
 431 ;
 432
 433 RelationalExprNoIn:
 434     ShiftExpr
 435   | RelationalExprNoIn '<' ShiftExpr    { $$ = new LessNode($1, $3); }
 436   | RelationalExprNoIn '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
 437   | RelationalExprNoIn LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
 438   | RelationalExprNoIn GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
 439   | RelationalExprNoIn INSTANCEOF ShiftExpr
 440                                         { $$ = new InstanceOfNode($1, $3); }
 441 ;
 442
 443 RelationalExprNoBF:
 444     ShiftExprNoBF
 445   | RelationalExprNoBF '<' ShiftExpr    { $$ = new LessNode($1, $3); }
 446   | RelationalExprNoBF '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
 447   | RelationalExprNoBF LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
 448   | RelationalExprNoBF GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
 449   | RelationalExprNoBF INSTANCEOF ShiftExpr
 450                                         { $$ = new InstanceOfNode($1, $3); }
 451   | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = new InNode($1, $3); }
 452 ;
 453
 454 EqualityExpr:
 455     RelationalExpr
 456   | EqualityExpr EQEQ RelationalExpr    { $$ = new EqualNode($1, $3); }
 457   | EqualityExpr NE RelationalExpr      { $$ = new NotEqualNode($1, $3); }
 458   | EqualityExpr STREQ RelationalExpr   { $$ = new StrictEqualNode($1, $3); }
 459   | EqualityExpr STRNEQ RelationalExpr  { $$ = new NotStrictEqualNode($1, $3); }
 460 ;
 461
 462 EqualityExprNoIn:
 463     RelationalExprNoIn
 464   | EqualityExprNoIn EQEQ RelationalExprNoIn
 465                                         { $$ = new EqualNode($1, $3); }
 466   | EqualityExprNoIn NE RelationalExprNoIn
 467                                         { $$ = new NotEqualNode($1, $3); }
 468   | EqualityExprNoIn STREQ RelationalExprNoIn
 469                                         { $$ = new StrictEqualNode($1, $3); }
 470   | EqualityExprNoIn STRNEQ RelationalExprNoIn
 471                                         { $$ = new NotStrictEqualNode($1, $3); }
 472 ;
 473
 474 EqualityExprNoBF:
 475     RelationalExprNoBF
 476   | EqualityExprNoBF EQEQ RelationalExpr
 477                                         { $$ = new EqualNode($1, $3); }
 478   | EqualityExprNoBF NE RelationalExpr  { $$ = new NotEqualNode($1, $3); }
 479   | EqualityExprNoBF STREQ RelationalExpr
 480                                         { $$ = new StrictEqualNode($1, $3); }
 481   | EqualityExprNoBF STRNEQ RelationalExpr
 482                                         { $$ = new NotStrictEqualNode($1, $3); }
 483 ;
 484
 485 BitwiseANDExpr:
 486     EqualityExpr
 487   | BitwiseANDExpr '&' EqualityExpr     { $$ = new BitAndNode($1, $3); }
 488 ;
 489
 490 BitwiseANDExprNoIn:
 491     EqualityExprNoIn
 492   | BitwiseANDExprNoIn '&' EqualityExprNoIn
 493                                         { $$ = new BitAndNode($1, $3); }
 494 ;
 495
 496 BitwiseANDExprNoBF:
 497     EqualityExprNoBF
 498   | BitwiseANDExprNoBF '&' EqualityExpr { $$ = new BitAndNode($1, $3); }
 499 ;
 500
 501 BitwiseXORExpr:
 502     BitwiseANDExpr
 503   | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = new BitXOrNode($1, $3); }
 504 ;
 505
 506 BitwiseXORExprNoIn:
 507     BitwiseANDExprNoIn
 508   | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
 509                                         { $$ = new BitXOrNode($1, $3); }
 510 ;
 511
 512 BitwiseXORExprNoBF:
 513     BitwiseANDExprNoBF
 514   | BitwiseXORExprNoBF '^' BitwiseANDExpr
 515                                         { $$ = new BitXOrNode($1, $3); }
 516 ;
 517
 518 BitwiseORExpr:
 519     BitwiseXORExpr
 520   | BitwiseORExpr '|' BitwiseXORExpr    { $$ = new BitOrNode($1, $3); }
 521 ;
 522
 523 BitwiseORExprNoIn:
 524     BitwiseXORExprNoIn
 525   | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
 526                                         { $$ = new BitOrNode($1, $3); }
 527 ;
 528
 529 BitwiseORExprNoBF:
 530     BitwiseXORExprNoBF
 531   | BitwiseORExprNoBF '|' BitwiseXORExpr
 532                                         { $$ = new BitOrNode($1, $3); }
 533 ;
 534
 535 LogicalANDExpr:
 536     BitwiseORExpr
 537   | LogicalANDExpr AND BitwiseORExpr    { $$ = new LogicalAndNode($1, $3); }
 538 ;
 539
 540 LogicalANDExprNoIn:
 541     BitwiseORExprNoIn
 542   | LogicalANDExprNoIn AND BitwiseORExprNoIn
 543                                         { $$ = new LogicalAndNode($1, $3); }
 544 ;
 545
 546 LogicalANDExprNoBF:
 547     BitwiseORExprNoBF
 548   | LogicalANDExprNoBF AND BitwiseORExpr
 549                                         { $$ = new LogicalAndNode($1, $3); }
 550 ;
 551
 552 LogicalORExpr:
 553     LogicalANDExpr
 554   | LogicalORExpr OR LogicalANDExpr     { $$ = new LogicalOrNode($1, $3); }
 555 ;
 556
 557 LogicalORExprNoIn:
 558     LogicalANDExprNoIn
 559   | LogicalORExprNoIn OR LogicalANDExprNoIn
 560                                         { $$ = new LogicalOrNode($1, $3); }
 561 ;
 562
 563 LogicalORExprNoBF:
 564     LogicalANDExprNoBF
 565   | LogicalORExprNoBF OR LogicalANDExpr { $$ = new LogicalOrNode($1, $3); }
 566 ;
 567
 568 ConditionalExpr:
 569     LogicalORExpr
 570   | LogicalORExpr '?' AssignmentExpr ':' AssignmentExpr
 571                                         { $$ = new ConditionalNode($1, $3, $5); }
 572 ;
 573
 574 ConditionalExprNoIn:
 575     LogicalORExprNoIn
 576   | LogicalORExprNoIn '?' AssignmentExprNoIn ':' AssignmentExprNoIn
 577                                         { $$ = new ConditionalNode($1, $3, $5); }
 578 ;
 579
 580 ConditionalExprNoBF:
 581     LogicalORExprNoBF
 582   | LogicalORExprNoBF '?' AssignmentExpr ':' AssignmentExpr
 583                                         { $$ = new ConditionalNode($1, $3, $5); }
 584 ;
 585
 586 AssignmentExpr:
 587     ConditionalExpr
 588   | LeftHandSideExpr AssignmentOperator AssignmentExpr
 589                                         { $$ = makeAssignNode($1, $2, $3); }
 590 ;
 591
 592 AssignmentExprNoIn:
 593     ConditionalExprNoIn
 594   | LeftHandSideExpr AssignmentOperator AssignmentExprNoIn
 595                                         { $$ = makeAssignNode($1, $2, $3); }
 596 ;
 597
 598 AssignmentExprNoBF:
 599     ConditionalExprNoBF
 600   | LeftHandSideExprNoBF AssignmentOperator AssignmentExpr
 601                                         { $$ = makeAssignNode($1, $2, $3); }
 602 ;
 603
 604 AssignmentOperator:
 605     '='                                 { $$ = OpEqual; }
 606   | PLUSEQUAL                           { $$ = OpPlusEq; }
 607   | MINUSEQUAL                          { $$ = OpMinusEq; }
 608   | MULTEQUAL                           { $$ = OpMultEq; }
 609   | DIVEQUAL                            { $$ = OpDivEq; }
 610   | LSHIFTEQUAL                         { $$ = OpLShift; }
 611   | RSHIFTEQUAL                         { $$ = OpRShift; }
 612   | URSHIFTEQUAL                        { $$ = OpURShift; }
 613   | ANDEQUAL                            { $$ = OpAndEq; }
 614   | XOREQUAL                            { $$ = OpXOrEq; }
 615   | OREQUAL                             { $$ = OpOrEq; }
 616   | MODEQUAL                            { $$ = OpModEq; }
 617 ;
 618
 619 Expr:
 620     AssignmentExpr
 621   | Expr ',' AssignmentExpr             { $$ = new CommaNode($1, $3); }
 622 ;
 623
 624 ExprNoIn:
 625     AssignmentExprNoIn
 626   | ExprNoIn ',' AssignmentExprNoIn     { $$ = new CommaNode($1, $3); }
 627 ;
 628
 629 ExprNoBF:
 630     AssignmentExprNoBF
 631   | ExprNoBF ',' AssignmentExpr         { $$ = new CommaNode($1, $3); }
 632 ;
 633
 634 Statement:
 635     Block
 636   | VariableStatement
 637   | ConstStatement
 638   | EmptyStatement
 639   | ExprStatement
 640   | IfStatement
 641   | IterationStatement
 642   | ContinueStatement
 643   | BreakStatement
 644   | ReturnStatement
 645   | WithStatement
 646   | SwitchStatement
 647   | LabelledStatement
 648   | ThrowStatement
 649   | TryStatement
 650   | DebuggerStatement
 651 ;
 652
 653 Block:
 654     '{' '}'                             { $$ = new BlockNode(0); DBG($$, @2, @2); }
 655   | '{' SourceElements '}'              { $$ = new BlockNode($2); DBG($$, @3, @3); }
 656 ;
 657
 658 VariableStatement:
 659     VAR VariableDeclarationList ';'     { $$ = new VarStatementNode($2.head); DBG($$, @1, @3); }
 660   | VAR VariableDeclarationList error   { $$ = new VarStatementNode($2.head); DBG($$, @1, @2); AUTO_SEMICOLON; }
 661 ;
 662
 663 VariableDeclarationList:
 664     VariableDeclaration                 { $$.head = $1;
 665                                           $$.tail = $$.head; }
 666   | VariableDeclarationList ',' VariableDeclaration
 667                                         { $$.head = $1.head;
 668                                           $1.tail->next = $3;
 669                                           $$.tail = $3; }
 670 ;
 671
 672 VariableDeclarationListNoIn:
 673     VariableDeclarationNoIn             { $$.head = $1;
 674                                           $$.tail = $$.head; }
 675   | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
 676                                         { $$.head = $1.head;
 677                                           $1.tail->next = $3;
 678                                           $$.tail = $3; }
 679 ;
 680
 681 VariableDeclaration:
 682     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
 683   | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
 684 ;
 685
 686 VariableDeclarationNoIn:
 687     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
 688   | IDENT InitializerNoIn               { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
 689 ;
 690
 691 ConstStatement:
 692     CONSTTOKEN ConstDeclarationList ';' { $$ = new VarStatementNode($2.head); DBG($$, @1, @3); }
 693   | CONSTTOKEN ConstDeclarationList error
 694                                         { $$ = new VarStatementNode($2.head); DBG($$, @1, @2); AUTO_SEMICOLON; }
 695 ;
 696
 697 ConstDeclarationList:
 698     ConstDeclaration                    { $$.head = $1;
 699                                           $$.tail = $$.head; }
 700   | ConstDeclarationList ',' ConstDeclaration
 701                                         { $$.head = $1.head;
 702                                           $1.tail->next = $3;
 703                                           $$.tail = $3; }
 704 ;
 705
 706 ConstDeclaration:
 707     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Constant); }
 708   | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Constant); }
 709 ;
 710
 711 Initializer:
 712     '=' AssignmentExpr                  { $$ = new AssignExprNode($2); }
 713 ;
 714
 715 InitializerNoIn:
 716     '=' AssignmentExprNoIn              { $$ = new AssignExprNode($2); }
 717 ;
 718
 719 EmptyStatement:
 720     ';'                                 { $$ = new EmptyStatementNode(); }
 721 ;
 722
 723 ExprStatement:
 724     ExprNoBF ';'                        { $$ = new ExprStatementNode($1); DBG($$, @1, @2); }
 725   | ExprNoBF error                      { $$ = new ExprStatementNode($1); DBG($$, @1, @1); AUTO_SEMICOLON; }
 726 ;
 727
 728 IfStatement:
 729     IF '(' Expr ')' Statement %prec IF_WITHOUT_ELSE
 730                                         { $$ = new IfNode($3, $5, 0); DBG($$, @1, @4); }
 731   | IF '(' Expr ')' Statement ELSE Statement
 732                                         { $$ = new IfNode($3, $5, $7); DBG($$, @1, @4); }
 733 ;
 734
 735 IterationStatement:
 736     DO Statement WHILE '(' Expr ')' ';'    { $$ = new DoWhileNode($2, $5); DBG($$, @1, @3); }
 737   | DO Statement WHILE '(' Expr ')' error  { $$ = new DoWhileNode($2, $5); DBG($$, @1, @3); } // Always performs automatic semicolon insertion.
 738   | WHILE '(' Expr ')' Statement        { $$ = new WhileNode($3, $5); DBG($$, @1, @4); }
 739   | FOR '(' ExprNoInOpt ';' ExprOpt ';' ExprOpt ')' Statement
 740                                         { $$ = new ForNode($3, $5, $7, $9); DBG($$, @1, @8); }
 741   | FOR '(' VAR VariableDeclarationListNoIn ';' ExprOpt ';' ExprOpt ')' Statement
 742                                         { $$ = new ForNode($4.head, $6, $8, $10); DBG($$, @1, @9); }
 743   | FOR '(' LeftHandSideExpr INTOKEN Expr ')' Statement
 744                                         {
 745                                             Node *n = $3;
 746                                             if (!n->isLocation())
 747                                                 YYABORT;
 748                                             $$ = new ForInNode(n, $5, $7);
 749                                             DBG($$, @1, @6);
 750                                         }
 751   | FOR '(' VAR IDENT INTOKEN Expr ')' Statement
 752                                         { $$ = new ForInNode(*$4, 0, $6, $8); DBG($$, @1, @7); }
 753   | FOR '(' VAR IDENT InitializerNoIn INTOKEN Expr ')' Statement
 754                                         { $$ = new ForInNode(*$4, $5, $7, $9); DBG($$, @1, @8); }
 755 ;
 756
 757 ExprOpt:
 758     /* nothing */                       { $$ = 0; }
 759   | Expr
 760 ;
 761
 762 ExprNoInOpt:
 763     /* nothing */                       { $$ = 0; }
 764   | ExprNoIn
 765 ;
 766
 767 ContinueStatement:
 768     CONTINUE ';'                        { $$ = new ContinueNode(); DBG($$, @1, @2); }
 769   | CONTINUE error                      { $$ = new ContinueNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
 770   | CONTINUE IDENT ';'                  { $$ = new ContinueNode(*$2); DBG($$, @1, @3); }
 771   | CONTINUE IDENT error                { $$ = new ContinueNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
 772 ;
 773
 774 BreakStatement:
 775     BREAK ';'                           { $$ = new BreakNode(); DBG($$, @1, @2); }
 776   | BREAK error                         { $$ = new BreakNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
 777   | BREAK IDENT ';'                     { $$ = new BreakNode(*$2); DBG($$, @1, @3); }
 778   | BREAK IDENT error                   { $$ = new BreakNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
 779 ;
 780
 781 ReturnStatement:
 782     RETURN ';'                          { $$ = new ReturnNode(0); DBG($$, @1, @2); }
 783   | RETURN error                        { $$ = new ReturnNode(0); DBG($$, @1, @1); AUTO_SEMICOLON; }
 784   | RETURN Expr ';'                     { $$ = new ReturnNode($2); DBG($$, @1, @3); }
 785   | RETURN Expr error                   { $$ = new ReturnNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
 786 ;
 787
 788 WithStatement:
 789     WITH '(' Expr ')' Statement         { $$ = new WithNode($3, $5); DBG($$, @1, @4); }
 790 ;
 791
 792 SwitchStatement:
 793     SWITCH '(' Expr ')' CaseBlock       { $$ = new SwitchNode($3, $5); DBG($$, @1, @4); }
 794 ;
 795
 796 CaseBlock:
 797     '{' CaseClausesOpt '}'              { $$ = new CaseBlockNode($2.head, 0, 0); }
 798   | '{' CaseClausesOpt DefaultClause CaseClausesOpt '}'
 799                                         { $$ = new CaseBlockNode($2.head, $3, $4.head); }
 800 ;
 801
 802 CaseClausesOpt:
 803     /* nothing */                       { $$.head = 0; $$.tail = 0; }
 804   | CaseClauses
 805 ;
 806
 807 CaseClauses:
 808     CaseClause                          { $$.head = new ClauseListNode($1);
 809                                           $$.tail = $$.head; }
 810   | CaseClauses CaseClause              { $$.head = $1.head;
 811                                           $$.tail = new ClauseListNode($1.tail, $2); }
 812 ;
 813
 814 CaseClause:
 815     CASE Expr ':'                       { $$ = new CaseClauseNode($2); }
 816   | CASE Expr ':' SourceElements        { $$ = new CaseClauseNode($2, $4); }
 817 ;
 818
 819 DefaultClause:
 820     DEFAULT ':'                         { $$ = new CaseClauseNode(0); }
 821   | DEFAULT ':' SourceElements          { $$ = new CaseClauseNode(0, $3); }
 822 ;
 823
 824 LabelledStatement:
 825     IDENT ':' Statement                 { $3->pushLabel(*$1); $$ = new LabelNode(*$1, $3); }
 826 ;
 827
 828 ThrowStatement:
 829     THROW Expr ';'                      { $$ = new ThrowNode($2); DBG($$, @1, @3); }
 830   | THROW Expr error                    { $$ = new ThrowNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
 831 ;
 832
 833 TryStatement:
 834     TRY Block FINALLY Block             { $$ = new TryNode($2, CommonIdentifiers::shared()->nullIdentifier, 0, $4); DBG($$, @1, @2); }
 835   | TRY Block CATCH '(' IDENT ')' Block { $$ = new TryNode($2, *$5, $7, 0); DBG($$, @1, @2); }
 836   | TRY Block CATCH '(' IDENT ')' Block FINALLY Block
 837                                         { $$ = new TryNode($2, *$5, $7, $9); DBG($$, @1, @2); }
 838 ;
 839
 840 DebuggerStatement:
 841     DEBUGGER ';'                        { $$ = new EmptyStatementNode(); DBG($$, @1, @2); }
 842   | DEBUGGER error                      { $$ = new EmptyStatementNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
 843 ;
 844
 845 FunctionDeclaration:
 846     FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncDeclNode(*$2, $5); }
 847   | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
 848                                         { $$ = new FuncDeclNode(*$2, $4.head, $6); }
 849 ;
 850
 851 FunctionExpr:
 852     FUNCTION '(' ')' FunctionBody       { $$ = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, $4); }
 853   | FUNCTION '(' FormalParameterList ')' FunctionBody
 854                                         { $$ = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, $5, $3.head); }
 855   | FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncExprNode(*$2, $5); }
 856   | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
 857                                         { $$ = new FuncExprNode(*$2, $6, $4.head); }
 858 ;
 859
 860 FormalParameterList:
 861     IDENT                               { $$.head = new ParameterNode(*$1);
 862                                           $$.tail = $$.head; }
 863   | FormalParameterList ',' IDENT       { $$.head = $1.head;
 864                                           $$.tail = new ParameterNode($1.tail, *$3); }
 865 ;
 866
 867 FunctionBody:
 868     '{' '}' /* not in spec */           { $$ = new FunctionBodyNode(0); DBG($$, @1, @2); }
 869   | '{' SourceElements '}'              { $$ = new FunctionBodyNode($2); DBG($$, @1, @3); }
 870 ;
 871
 872 Program:
 873     /* not in spec */                   { Parser::accept(new ProgramNode(0)); }
 874     | SourceElements                    { Parser::accept(new ProgramNode($1)); }
 875 ;
 876
 877 SourceElements:
 878     SourceElement                       { $$ = new Vector<RefPtr<StatementNode> >();
 879                                           $$->append($1); }
 880   | SourceElements SourceElement        { $$->append($2); }
 881 ;
 882
 883 SourceElement:
 884     FunctionDeclaration                 { $$ = $1; }
 885   | Statement                           { $$ = $1; }
 886 ;
 887
 888 %%
 889
 890 static Node* makeAssignNode(Node* loc, Operator op, Node* expr)
 891 {
 892     if (!loc->isLocation())
 893         return new AssignErrorNode(loc, op, expr);
 894
 895     if (loc->isResolveNode()) {
 896         ResolveNode* resolve = static_cast<ResolveNode*>(loc);
 897         if (op == OpEqual)
 898             return new AssignResolveNode(resolve->identifier(), expr);
 899         else
 900             return new ReadModifyResolveNode(resolve->identifier(), op, expr);
 901     }
 902     if (loc->isBracketAccessorNode()) {
 903         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
 904         if (op == OpEqual)
 905             return new AssignBracketNode(bracket->base(), bracket->subscript(), expr);
 906         else
 907             return new ReadModifyBracketNode(bracket->base(), bracket->subscript(), op, expr);
 908     }
 909     ASSERT(loc->isDotAccessorNode());
 910     DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
 911     if (op == OpEqual)
 912         return new AssignDotNode(dot->base(), dot->identifier(), expr);
 913     return new ReadModifyDotNode(dot->base(), dot->identifier(), op, expr);
 914 }
 915
 916 static Node* makePrefixNode(Node* expr, Operator op)
 917 {
 918     if (!expr->isLocation())
 919         return new PrefixErrorNode(expr, op);
 920
 921     if (expr->isResolveNode()) {
 922         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 923         if (op == OpPlusPlus)
 924             return new PreIncResolveNode(resolve->identifier());
 925         else
 926             return new PreDecResolveNode(resolve->identifier());
 927     }
 928     if (expr->isBracketAccessorNode()) {
 929         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
 930         if (op == OpPlusPlus)
 931             return new PreIncBracketNode(bracket->base(), bracket->subscript());
 932         else
 933             return new PreDecBracketNode(bracket->base(), bracket->subscript());
 934     }
 935     ASSERT(expr->isDotAccessorNode());
 936     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
 937     if (op == OpPlusPlus)
 938         return new PreIncDotNode(dot->base(), dot->identifier());
 939     return new PreDecDotNode(dot->base(), dot->identifier());
 940 }
 941
 942 static Node* makePostfixNode(Node* expr, Operator op)
 943 {
 944     if (!expr->isLocation())
 945         return new PostfixErrorNode(expr, op);
 946
 947     if (expr->isResolveNode()) {
 948         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 949         if (op == OpPlusPlus)
 950             return new PostIncResolveNode(resolve->identifier());
 951         else
 952             return new PostDecResolveNode(resolve->identifier());
 953     }
 954     if (expr->isBracketAccessorNode()) {
 955         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
 956         if (op == OpPlusPlus)
 957             return new PostIncBracketNode(bracket->base(), bracket->subscript());
 958         else
 959             return new PostDecBracketNode(bracket->base(), bracket->subscript());
 960     }
 961     ASSERT(expr->isDotAccessorNode());
 962     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
 963
 964     if (op == OpPlusPlus)
 965         return new PostIncDotNode(dot->base(), dot->identifier());
 966     return new PostDecDotNode(dot->base(), dot->identifier());
 967 }
 968
 969 static Node* makeFunctionCallNode(Node* func, ArgumentsNode* args)
 970 {
 971     if (!func->isLocation())
 972         return new FunctionCallValueNode(func, args);
 973     if (func->isResolveNode()) {
 974         ResolveNode* resolve = static_cast<ResolveNode*>(func);
 975         return new FunctionCallResolveNode(resolve->identifier(), args);
 976     }
 977     if (func->isBracketAccessorNode()) {
 978         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func);
 979         return new FunctionCallBracketNode(bracket->base(), bracket->subscript(), args);
 980     }
 981     ASSERT(func->isDotAccessorNode());
 982     DotAccessorNode* dot = static_cast<DotAccessorNode*>(func);
 983     return new FunctionCallDotNode(dot->base(), dot->identifier(), args);
 984 }
 985
 986 static Node* makeTypeOfNode(Node* expr)
 987 {
 988     if (expr->isResolveNode()) {
 989         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 990         return new TypeOfResolveNode(resolve->identifier());
 991     }
 992     return new TypeOfValueNode(expr);
 993 }
 994
 995 static Node* makeDeleteNode(Node* expr)
 996 {
 997     if (!expr->isLocation())
 998         return new DeleteValueNode(expr);
 999     if (expr->isResolveNode()) {
1000         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
1001         return new DeleteResolveNode(resolve->identifier());
1002     }
1003     if (expr->isBracketAccessorNode()) {
1004         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
1005         return new DeleteBracketNode(bracket->base(), bracket->subscript());
1006     }
1007     ASSERT(expr->isDotAccessorNode());
1008     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
1009     return new DeleteDotNode(dot->base(), dot->identifier());
1010 }
1011
1012 static PropertyNode* makeGetterOrSetterPropertyNode(const Identifier& getOrSet, const Identifier& name, ParameterNode* params, FunctionBodyNode* body)
1013 {
1014     PropertyNode::Type type;
1015     if (getOrSet == "get")
1016         type = PropertyNode::Getter;
1017     else if (getOrSet == "set")
1018         type = PropertyNode::Setter;
1019     else
1020         return 0;
1021     return new PropertyNode(name, new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, body, params), type);
1022 }
1023
1024 static Node* makeNegateNode(Node* n)
1025 {
1026     if (n->isNumber()) {
1027         NumberNode* number = static_cast<NumberNode*>(n);
1028
1029         if (number->value() > 0.0) {
1030             number->setValue(-number->value());
1031             return number;
1032         }
1033     }
1034
1035     return new NegateNode(n);
1036 }
1037
1038 static Node* makeNumberNode(double d)
1039 {
1040     JSValue* value = JSImmediate::fromDouble(d);
1041     if (value)
1042         return new ImmediateNumberNode(value, d);
1043     return new NumberNode(d);
1044 }
1045
1046 /* called by yyparse on error */
1047 int yyerror(const char *)
1048 {
1049     return 1;
1050 }
1051
1052 /* may we automatically insert a semicolon ? */
1053 static bool allowAutomaticSemicolon()
1054 {
1055     return yychar == '}' || yychar == 0 || Lexer::curr()->prevTerminator();
1056 }