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