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