2007-11-10 Eric Seidel <eric@webkit.org>
[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 "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 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     SourceElements*     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::curr();
224                                             if (!l->scanRegExp()) YYABORT;
225                                             $$ = new RegExpNode(l->pattern, l->flags);
226                                         }
227   | DIVEQUAL /* regexp with /= */       {
228                                             Lexer *l = Lexer::curr();
229                                             if (!l->scanRegExp()) YYABORT;
230                                             $$ = new RegExpNode("=" + l->pattern, l->flags);
231                                         }
232 ;
233
234 Property:
235     IDENT ':' AssignmentExpr            { $$ = new PropertyNode(*$1, $3, PropertyNode::Constant); }
236   | STRING ':' AssignmentExpr           { $$ = new PropertyNode(Identifier(*$1), $3, PropertyNode::Constant); }
237   | NUMBER ':' AssignmentExpr           { $$ = new PropertyNode(Identifier(UString::from($1)), $3, PropertyNode::Constant); }
238   | IDENT IDENT '(' ')' FunctionBody    { $$ = makeGetterOrSetterPropertyNode(*$1, *$2, 0, $5); if (!$$) YYABORT; }
239   | IDENT IDENT '(' FormalParameterList ')' FunctionBody
240                                         { $$ = makeGetterOrSetterPropertyNode(*$1, *$2, $4.head, $6); if (!$$) YYABORT; }
241 ;
242
243 PropertyList:
244     Property                            { $$.head = new PropertyListNode($1); 
245                                           $$.tail = $$.head; }
246   | PropertyList ',' Property           { $$.head = $1.head;
247                                           $$.tail = new PropertyListNode($3, $1.tail); }
248 ;
249
250 PrimaryExpr:
251     PrimaryExprNoBrace
252   | '{' '}'                             { $$ = new ObjectLiteralNode(); }
253   | '{' PropertyList '}'                { $$ = new ObjectLiteralNode($2.head); }
254   /* allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939 */
255   | '{' PropertyList ',' '}'            { $$ = new ObjectLiteralNode($2.head); }
256 ;
257
258 PrimaryExprNoBrace:
259     THISTOKEN                           { $$ = new ThisNode(); }
260   | Literal
261   | ArrayLiteral
262   | IDENT                               { $$ = new ResolveNode(*$1); }
263   | '(' Expr ')'                        { $$ = $2; }
264 ;
265
266 ArrayLiteral:
267     '[' ElisionOpt ']'                  { $$ = new ArrayNode($2); }
268   | '[' ElementList ']'                 { $$ = new ArrayNode($2.head); }
269   | '[' ElementList ',' ElisionOpt ']'  { $$ = new ArrayNode($4, $2.head); }
270 ;
271
272 ElementList:
273     ElisionOpt AssignmentExpr           { $$.head = new ElementNode($1, $2);
274                                           $$.tail = $$.head; }
275   | ElementList ',' ElisionOpt AssignmentExpr
276                                         { $$.head = $1.head;
277                                           $$.tail = new ElementNode($1.tail, $3, $4); }
278 ;
279
280 ElisionOpt:
281     /* nothing */                       { $$ = 0; }
282   | Elision
283 ;
284
285 Elision:
286     ','                                 { $$ = 1; }
287   | Elision ','                         { $$ = $1 + 1; }
288 ;
289
290 MemberExpr:
291     PrimaryExpr
292   | FunctionExpr                        { $$ = $1; }
293   | MemberExpr '[' Expr ']'             { $$ = new BracketAccessorNode($1, $3); }
294   | MemberExpr '.' IDENT                { $$ = new DotAccessorNode($1, *$3); }
295   | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
296 ;
297
298 MemberExprNoBF:
299     PrimaryExprNoBrace
300   | MemberExprNoBF '[' Expr ']'         { $$ = new BracketAccessorNode($1, $3); }
301   | MemberExprNoBF '.' IDENT            { $$ = new DotAccessorNode($1, *$3); }
302   | NEW MemberExpr Arguments            { $$ = new NewExprNode($2, $3); }
303 ;
304
305 NewExpr:
306     MemberExpr
307   | NEW NewExpr                         { $$ = new NewExprNode($2); }
308 ;
309
310 NewExprNoBF:
311     MemberExprNoBF
312   | NEW NewExpr                         { $$ = new NewExprNode($2); }
313 ;
314
315 CallExpr:
316     MemberExpr Arguments                { $$ = makeFunctionCallNode($1, $2); }
317   | CallExpr Arguments                  { $$ = makeFunctionCallNode($1, $2); }
318   | CallExpr '[' Expr ']'               { $$ = new BracketAccessorNode($1, $3); }
319   | CallExpr '.' IDENT                  { $$ = new DotAccessorNode($1, *$3); }
320 ;
321
322 CallExprNoBF:
323     MemberExprNoBF Arguments            { $$ = makeFunctionCallNode($1, $2); }
324   | CallExprNoBF Arguments              { $$ = makeFunctionCallNode($1, $2); }
325   | CallExprNoBF '[' Expr ']'           { $$ = new BracketAccessorNode($1, $3); }
326   | CallExprNoBF '.' IDENT              { $$ = new DotAccessorNode($1, *$3); }
327 ;
328
329 Arguments:
330     '(' ')'                             { $$ = new ArgumentsNode(); }
331   | '(' ArgumentList ')'                { $$ = new ArgumentsNode($2.head); }
332 ;
333
334 ArgumentList:
335     AssignmentExpr                      { $$.head = new ArgumentListNode($1);
336                                           $$.tail = $$.head; }
337   | ArgumentList ',' AssignmentExpr     { $$.head = $1.head;
338                                           $$.tail = new ArgumentListNode($1.tail, $3); }
339 ;
340
341 LeftHandSideExpr:
342     NewExpr
343   | CallExpr
344 ;
345
346 LeftHandSideExprNoBF:
347     NewExprNoBF
348   | CallExprNoBF
349 ;
350
351 PostfixExpr:
352     LeftHandSideExpr
353   | LeftHandSideExpr PLUSPLUS           { $$ = makePostfixNode($1, OpPlusPlus); }
354   | LeftHandSideExpr MINUSMINUS         { $$ = makePostfixNode($1, OpMinusMinus); }
355 ;
356
357 PostfixExprNoBF:
358     LeftHandSideExprNoBF
359   | LeftHandSideExprNoBF PLUSPLUS       { $$ = makePostfixNode($1, OpPlusPlus); }
360   | LeftHandSideExprNoBF MINUSMINUS     { $$ = makePostfixNode($1, OpMinusMinus); }
361 ;
362
363 UnaryExprCommon:
364     DELETETOKEN UnaryExpr               { $$ = makeDeleteNode($2); }
365   | VOIDTOKEN UnaryExpr                 { $$ = new VoidNode($2); }
366   | TYPEOF UnaryExpr                    { $$ = makeTypeOfNode($2); }
367   | PLUSPLUS UnaryExpr                  { $$ = makePrefixNode($2, OpPlusPlus); }
368   | AUTOPLUSPLUS UnaryExpr              { $$ = makePrefixNode($2, OpPlusPlus); }
369   | MINUSMINUS UnaryExpr                { $$ = makePrefixNode($2, OpMinusMinus); }
370   | AUTOMINUSMINUS UnaryExpr            { $$ = makePrefixNode($2, OpMinusMinus); }
371   | '+' UnaryExpr                       { $$ = new UnaryPlusNode($2); }
372   | '-' UnaryExpr                       { $$ = makeNegateNode($2); }
373   | '~' UnaryExpr                       { $$ = new BitwiseNotNode($2); }
374   | '!' UnaryExpr                       { $$ = new LogicalNotNode($2); }
375
376 UnaryExpr:
377     PostfixExpr
378   | UnaryExprCommon
379 ;
380
381 UnaryExprNoBF:
382     PostfixExprNoBF
383   | UnaryExprCommon
384 ;
385
386 MultiplicativeExpr:
387     UnaryExpr
388   | MultiplicativeExpr '*' UnaryExpr    { $$ = new MultNode($1, $3); }
389   | MultiplicativeExpr '/' UnaryExpr    { $$ = new DivNode($1, $3); }
390   | MultiplicativeExpr '%' UnaryExpr    { $$ = new ModNode($1, $3); }
391 ;
392
393 MultiplicativeExprNoBF:
394     UnaryExprNoBF
395   | MultiplicativeExprNoBF '*' UnaryExpr
396                                         { $$ = new MultNode($1, $3); }
397   | MultiplicativeExprNoBF '/' UnaryExpr
398                                         { $$ = new DivNode($1, $3); }
399   | MultiplicativeExprNoBF '%' UnaryExpr
400                                         { $$ = new ModNode($1, $3); }
401 ;
402
403 AdditiveExpr:
404     MultiplicativeExpr
405   | AdditiveExpr '+' MultiplicativeExpr { $$ = makeAddNode($1, $3); }
406   | AdditiveExpr '-' MultiplicativeExpr { $$ = new SubNode($1, $3); }
407 ;
408
409 AdditiveExprNoBF:
410     MultiplicativeExprNoBF
411   | AdditiveExprNoBF '+' MultiplicativeExpr
412                                         { $$ = makeAddNode($1, $3); }
413   | AdditiveExprNoBF '-' MultiplicativeExpr
414                                         { $$ = new SubNode($1, $3); }
415 ;
416
417 ShiftExpr:
418     AdditiveExpr
419   | ShiftExpr LSHIFT AdditiveExpr       { $$ = new LeftShiftNode($1, $3); }
420   | ShiftExpr RSHIFT AdditiveExpr       { $$ = new RightShiftNode($1, $3); }
421   | ShiftExpr URSHIFT AdditiveExpr      { $$ = new UnsignedRightShiftNode($1, $3); }
422 ;
423
424 ShiftExprNoBF:
425     AdditiveExprNoBF
426   | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = new LeftShiftNode($1, $3); }
427   | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = new RightShiftNode($1, $3); }
428   | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = new UnsignedRightShiftNode($1, $3); }
429 ;
430
431 RelationalExpr:
432     ShiftExpr
433   | RelationalExpr '<' ShiftExpr        { $$ = makeLessNode($1, $3); }
434   | RelationalExpr '>' ShiftExpr        { $$ = new GreaterNode($1, $3); }
435   | RelationalExpr LE ShiftExpr         { $$ = new LessEqNode($1, $3); }
436   | RelationalExpr GE ShiftExpr         { $$ = new GreaterEqNode($1, $3); }
437   | RelationalExpr INSTANCEOF ShiftExpr { $$ = new InstanceOfNode($1, $3); }
438   | RelationalExpr INTOKEN ShiftExpr    { $$ = new InNode($1, $3); }
439 ;
440
441 RelationalExprNoIn:
442     ShiftExpr
443   | RelationalExprNoIn '<' ShiftExpr    { $$ = makeLessNode($1, $3); }
444   | RelationalExprNoIn '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
445   | RelationalExprNoIn LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
446   | RelationalExprNoIn GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
447   | RelationalExprNoIn INSTANCEOF ShiftExpr
448                                         { $$ = new InstanceOfNode($1, $3); }
449 ;
450
451 RelationalExprNoBF:
452     ShiftExprNoBF
453   | RelationalExprNoBF '<' ShiftExpr    { $$ = makeLessNode($1, $3); }
454   | RelationalExprNoBF '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
455   | RelationalExprNoBF LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
456   | RelationalExprNoBF GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
457   | RelationalExprNoBF INSTANCEOF ShiftExpr
458                                         { $$ = new InstanceOfNode($1, $3); }
459   | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = new InNode($1, $3); }
460 ;
461
462 EqualityExpr:
463     RelationalExpr
464   | EqualityExpr EQEQ RelationalExpr    { $$ = new EqualNode($1, $3); }
465   | EqualityExpr NE RelationalExpr      { $$ = new NotEqualNode($1, $3); }
466   | EqualityExpr STREQ RelationalExpr   { $$ = new StrictEqualNode($1, $3); }
467   | EqualityExpr STRNEQ RelationalExpr  { $$ = new NotStrictEqualNode($1, $3); }
468 ;
469
470 EqualityExprNoIn:
471     RelationalExprNoIn
472   | EqualityExprNoIn EQEQ RelationalExprNoIn
473                                         { $$ = new EqualNode($1, $3); }
474   | EqualityExprNoIn NE RelationalExprNoIn
475                                         { $$ = new NotEqualNode($1, $3); }
476   | EqualityExprNoIn STREQ RelationalExprNoIn
477                                         { $$ = new StrictEqualNode($1, $3); }
478   | EqualityExprNoIn STRNEQ RelationalExprNoIn
479                                         { $$ = new NotStrictEqualNode($1, $3); }
480 ;
481
482 EqualityExprNoBF:
483     RelationalExprNoBF
484   | EqualityExprNoBF EQEQ RelationalExpr
485                                         { $$ = new EqualNode($1, $3); }
486   | EqualityExprNoBF NE RelationalExpr  { $$ = new NotEqualNode($1, $3); }
487   | EqualityExprNoBF STREQ RelationalExpr
488                                         { $$ = new StrictEqualNode($1, $3); }
489   | EqualityExprNoBF STRNEQ RelationalExpr
490                                         { $$ = new NotStrictEqualNode($1, $3); }
491 ;
492
493 BitwiseANDExpr:
494     EqualityExpr
495   | BitwiseANDExpr '&' EqualityExpr     { $$ = new BitAndNode($1, $3); }
496 ;
497
498 BitwiseANDExprNoIn:
499     EqualityExprNoIn
500   | BitwiseANDExprNoIn '&' EqualityExprNoIn
501                                         { $$ = new BitAndNode($1, $3); }
502 ;
503
504 BitwiseANDExprNoBF:
505     EqualityExprNoBF
506   | BitwiseANDExprNoBF '&' EqualityExpr { $$ = new BitAndNode($1, $3); }
507 ;
508
509 BitwiseXORExpr:
510     BitwiseANDExpr
511   | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = new BitXOrNode($1, $3); }
512 ;
513
514 BitwiseXORExprNoIn:
515     BitwiseANDExprNoIn
516   | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
517                                         { $$ = new BitXOrNode($1, $3); }
518 ;
519
520 BitwiseXORExprNoBF:
521     BitwiseANDExprNoBF
522   | BitwiseXORExprNoBF '^' BitwiseANDExpr
523                                         { $$ = new BitXOrNode($1, $3); }
524 ;
525
526 BitwiseORExpr:
527     BitwiseXORExpr
528   | BitwiseORExpr '|' BitwiseXORExpr    { $$ = new BitOrNode($1, $3); }
529 ;
530
531 BitwiseORExprNoIn:
532     BitwiseXORExprNoIn
533   | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
534                                         { $$ = new BitOrNode($1, $3); }
535 ;
536
537 BitwiseORExprNoBF:
538     BitwiseXORExprNoBF
539   | BitwiseORExprNoBF '|' BitwiseXORExpr
540                                         { $$ = new BitOrNode($1, $3); }
541 ;
542
543 LogicalANDExpr:
544     BitwiseORExpr
545   | LogicalANDExpr AND BitwiseORExpr    { $$ = new LogicalAndNode($1, $3); }
546 ;
547
548 LogicalANDExprNoIn:
549     BitwiseORExprNoIn
550   | LogicalANDExprNoIn AND BitwiseORExprNoIn
551                                         { $$ = new LogicalAndNode($1, $3); }
552 ;
553
554 LogicalANDExprNoBF:
555     BitwiseORExprNoBF
556   | LogicalANDExprNoBF AND BitwiseORExpr
557                                         { $$ = new LogicalAndNode($1, $3); }
558 ;
559
560 LogicalORExpr:
561     LogicalANDExpr
562   | LogicalORExpr OR LogicalANDExpr     { $$ = new LogicalOrNode($1, $3); }
563 ;
564
565 LogicalORExprNoIn:
566     LogicalANDExprNoIn
567   | LogicalORExprNoIn OR LogicalANDExprNoIn
568                                         { $$ = new LogicalOrNode($1, $3); }
569 ;
570
571 LogicalORExprNoBF:
572     LogicalANDExprNoBF
573   | LogicalORExprNoBF OR LogicalANDExpr { $$ = new LogicalOrNode($1, $3); }
574 ;
575
576 ConditionalExpr:
577     LogicalORExpr
578   | LogicalORExpr '?' AssignmentExpr ':' AssignmentExpr
579                                         { $$ = new ConditionalNode($1, $3, $5); }
580 ;
581
582 ConditionalExprNoIn:
583     LogicalORExprNoIn
584   | LogicalORExprNoIn '?' AssignmentExprNoIn ':' AssignmentExprNoIn
585                                         { $$ = new ConditionalNode($1, $3, $5); }
586 ;
587
588 ConditionalExprNoBF:
589     LogicalORExprNoBF
590   | LogicalORExprNoBF '?' AssignmentExpr ':' AssignmentExpr
591                                         { $$ = new ConditionalNode($1, $3, $5); }
592 ;
593
594 AssignmentExpr:
595     ConditionalExpr
596   | LeftHandSideExpr AssignmentOperator AssignmentExpr
597                                         { $$ = makeAssignNode($1, $2, $3); }
598 ;
599
600 AssignmentExprNoIn:
601     ConditionalExprNoIn
602   | LeftHandSideExpr AssignmentOperator AssignmentExprNoIn
603                                         { $$ = makeAssignNode($1, $2, $3); }
604 ;
605
606 AssignmentExprNoBF:
607     ConditionalExprNoBF
608   | LeftHandSideExprNoBF AssignmentOperator AssignmentExpr
609                                         { $$ = makeAssignNode($1, $2, $3); }
610 ;
611
612 AssignmentOperator:
613     '='                                 { $$ = OpEqual; }
614   | PLUSEQUAL                           { $$ = OpPlusEq; }
615   | MINUSEQUAL                          { $$ = OpMinusEq; }
616   | MULTEQUAL                           { $$ = OpMultEq; }
617   | DIVEQUAL                            { $$ = OpDivEq; }
618   | LSHIFTEQUAL                         { $$ = OpLShift; }
619   | RSHIFTEQUAL                         { $$ = OpRShift; }
620   | URSHIFTEQUAL                        { $$ = OpURShift; }
621   | ANDEQUAL                            { $$ = OpAndEq; }
622   | XOREQUAL                            { $$ = OpXOrEq; }
623   | OREQUAL                             { $$ = OpOrEq; }
624   | MODEQUAL                            { $$ = OpModEq; }
625 ;
626
627 Expr:
628     AssignmentExpr
629   | Expr ',' AssignmentExpr             { $$ = new CommaNode($1, $3); }
630 ;
631
632 ExprNoIn:
633     AssignmentExprNoIn
634   | ExprNoIn ',' AssignmentExprNoIn     { $$ = new CommaNode($1, $3); }
635 ;
636
637 ExprNoBF:
638     AssignmentExprNoBF
639   | ExprNoBF ',' AssignmentExpr         { $$ = new CommaNode($1, $3); }
640 ;
641
642 Statement:
643     Block
644   | VariableStatement
645   | ConstStatement
646   | EmptyStatement
647   | ExprStatement
648   | IfStatement
649   | IterationStatement
650   | ContinueStatement
651   | BreakStatement
652   | ReturnStatement
653   | WithStatement
654   | SwitchStatement
655   | LabelledStatement
656   | ThrowStatement
657   | TryStatement
658   | DebuggerStatement
659 ;
660
661 Block:
662     '{' '}'                             { $$ = new BlockNode(0); DBG($$, @2, @2); }
663   | '{' SourceElements '}'              { $$ = new BlockNode($2); DBG($$, @3, @3); }
664 ;
665
666 VariableStatement:
667     VAR VariableDeclarationList ';'     { $$ = new VarStatementNode($2.head); DBG($$, @1, @3); }
668   | VAR VariableDeclarationList error   { $$ = new VarStatementNode($2.head); DBG($$, @1, @2); AUTO_SEMICOLON; }
669 ;
670
671 VariableDeclarationList:
672     VariableDeclaration                 { $$.head = $1; 
673                                           $$.tail = $$.head; }
674   | VariableDeclarationList ',' VariableDeclaration
675                                         { $$.head = $1.head;
676                                           $1.tail->next = $3;
677                                           $$.tail = $3; }
678 ;
679
680 VariableDeclarationListNoIn:
681     VariableDeclarationNoIn             { $$.head = $1; 
682                                           $$.tail = $$.head; }
683   | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
684                                         { $$.head = $1.head;
685                                           $1.tail->next = $3;
686                                           $$.tail = $3; }
687 ;
688
689 VariableDeclaration:
690     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
691   | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
692 ;
693
694 VariableDeclarationNoIn:
695     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Variable); }
696   | IDENT InitializerNoIn               { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Variable); }
697 ;
698
699 ConstStatement:
700     CONSTTOKEN ConstDeclarationList ';' { $$ = new VarStatementNode($2.head); DBG($$, @1, @3); }
701   | CONSTTOKEN ConstDeclarationList error
702                                         { $$ = new VarStatementNode($2.head); DBG($$, @1, @2); AUTO_SEMICOLON; }
703 ;
704
705 ConstDeclarationList:
706     ConstDeclaration                    { $$.head = $1; 
707                                           $$.tail = $$.head; }
708   | ConstDeclarationList ',' ConstDeclaration
709                                         { $$.head = $1.head;
710                                           $1.tail->next = $3;
711                                           $$.tail = $3; }
712 ;
713
714 ConstDeclaration:
715     IDENT                               { $$ = new VarDeclNode(*$1, 0, VarDeclNode::Constant); }
716   | IDENT Initializer                   { $$ = new VarDeclNode(*$1, $2, VarDeclNode::Constant); }
717 ;
718
719 Initializer:
720     '=' AssignmentExpr                  { $$ = new AssignExprNode($2); }
721 ;
722
723 InitializerNoIn:
724     '=' AssignmentExprNoIn              { $$ = new AssignExprNode($2); }
725 ;
726
727 EmptyStatement:
728     ';'                                 { $$ = new EmptyStatementNode(); }
729 ;
730
731 ExprStatement:
732     ExprNoBF ';'                        { $$ = new ExprStatementNode($1); DBG($$, @1, @2); }
733   | ExprNoBF error                      { $$ = new ExprStatementNode($1); DBG($$, @1, @1); AUTO_SEMICOLON; }
734 ;
735
736 IfStatement:
737     IF '(' Expr ')' Statement %prec IF_WITHOUT_ELSE
738                                         { $$ = new IfNode($3, $5, 0); DBG($$, @1, @4); }
739   | IF '(' Expr ')' Statement ELSE Statement
740                                         { $$ = new IfNode($3, $5, $7); DBG($$, @1, @4); }
741 ;
742
743 IterationStatement:
744     DO Statement WHILE '(' Expr ')' ';'    { $$ = new DoWhileNode($2, $5); DBG($$, @1, @3); }
745   | DO Statement WHILE '(' Expr ')' error  { $$ = new DoWhileNode($2, $5); DBG($$, @1, @3); } // Always performs automatic semicolon insertion.
746   | WHILE '(' Expr ')' Statement        { $$ = new WhileNode($3, $5); DBG($$, @1, @4); }
747   | FOR '(' ExprNoInOpt ';' ExprOpt ';' ExprOpt ')' Statement
748                                         { $$ = new ForNode($3, $5, $7, $9); DBG($$, @1, @8); }
749   | FOR '(' VAR VariableDeclarationListNoIn ';' ExprOpt ';' ExprOpt ')' Statement
750                                         { $$ = new ForNode($4.head, $6, $8, $10); DBG($$, @1, @9); }
751   | FOR '(' LeftHandSideExpr INTOKEN Expr ')' Statement
752                                         {
753                                             ExpressionNode* n = $3;
754                                             if (!n->isLocation())
755                                                 YYABORT;
756                                             $$ = new ForInNode(n, $5, $7);
757                                             DBG($$, @1, @6);
758                                         }
759   | FOR '(' VAR IDENT INTOKEN Expr ')' Statement
760                                         { $$ = new ForInNode(*$4, 0, $6, $8); DBG($$, @1, @7); }
761   | FOR '(' VAR IDENT InitializerNoIn INTOKEN Expr ')' Statement
762                                         { $$ = new ForInNode(*$4, $5, $7, $9); DBG($$, @1, @8); }
763 ;
764
765 ExprOpt:
766     /* nothing */                       { $$ = 0; }
767   | Expr
768 ;
769
770 ExprNoInOpt:
771     /* nothing */                       { $$ = 0; }
772   | ExprNoIn
773 ;
774
775 ContinueStatement:
776     CONTINUE ';'                        { $$ = new ContinueNode(); DBG($$, @1, @2); }
777   | CONTINUE error                      { $$ = new ContinueNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
778   | CONTINUE IDENT ';'                  { $$ = new ContinueNode(*$2); DBG($$, @1, @3); }
779   | CONTINUE IDENT error                { $$ = new ContinueNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
780 ;
781
782 BreakStatement:
783     BREAK ';'                           { $$ = new BreakNode(); DBG($$, @1, @2); }
784   | BREAK error                         { $$ = new BreakNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
785   | BREAK IDENT ';'                     { $$ = new BreakNode(*$2); DBG($$, @1, @3); }
786   | BREAK IDENT error                   { $$ = new BreakNode(*$2); DBG($$, @1, @2); AUTO_SEMICOLON; }
787 ;
788
789 ReturnStatement:
790     RETURN ';'                          { $$ = new ReturnNode(0); DBG($$, @1, @2); }
791   | RETURN error                        { $$ = new ReturnNode(0); DBG($$, @1, @1); AUTO_SEMICOLON; }
792   | RETURN Expr ';'                     { $$ = new ReturnNode($2); DBG($$, @1, @3); }
793   | RETURN Expr error                   { $$ = new ReturnNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
794 ;
795
796 WithStatement:
797     WITH '(' Expr ')' Statement         { $$ = new WithNode($3, $5); DBG($$, @1, @4); }
798 ;
799
800 SwitchStatement:
801     SWITCH '(' Expr ')' CaseBlock       { $$ = new SwitchNode($3, $5); DBG($$, @1, @4); }
802 ;
803
804 CaseBlock:
805     '{' CaseClausesOpt '}'              { $$ = new CaseBlockNode($2.head, 0, 0); }
806   | '{' CaseClausesOpt DefaultClause CaseClausesOpt '}'
807                                         { $$ = new CaseBlockNode($2.head, $3, $4.head); }
808 ;
809
810 CaseClausesOpt:
811     /* nothing */                       { $$.head = 0; $$.tail = 0; }
812   | CaseClauses
813 ;
814
815 CaseClauses:
816     CaseClause                          { $$.head = new ClauseListNode($1);
817                                           $$.tail = $$.head; }
818   | CaseClauses CaseClause              { $$.head = $1.head; 
819                                           $$.tail = new ClauseListNode($1.tail, $2); }
820 ;
821
822 CaseClause:
823     CASE Expr ':'                       { $$ = new CaseClauseNode($2); }
824   | CASE Expr ':' SourceElements        { $$ = new CaseClauseNode($2, $4); }
825 ;
826
827 DefaultClause:
828     DEFAULT ':'                         { $$ = new CaseClauseNode(0); }
829   | DEFAULT ':' SourceElements          { $$ = new CaseClauseNode(0, $3); }
830 ;
831
832 LabelledStatement:
833     IDENT ':' Statement                 { $3->pushLabel(*$1); $$ = new LabelNode(*$1, $3); }
834 ;
835
836 ThrowStatement:
837     THROW Expr ';'                      { $$ = new ThrowNode($2); DBG($$, @1, @3); }
838   | THROW Expr error                    { $$ = new ThrowNode($2); DBG($$, @1, @2); AUTO_SEMICOLON; }
839 ;
840
841 TryStatement:
842     TRY Block FINALLY Block             { $$ = new TryNode($2, CommonIdentifiers::shared()->nullIdentifier, 0, $4); DBG($$, @1, @2); }
843   | TRY Block CATCH '(' IDENT ')' Block { $$ = new TryNode($2, *$5, $7, 0); DBG($$, @1, @2); }
844   | TRY Block CATCH '(' IDENT ')' Block FINALLY Block
845                                         { $$ = new TryNode($2, *$5, $7, $9); DBG($$, @1, @2); }
846 ;
847
848 DebuggerStatement:
849     DEBUGGER ';'                        { $$ = new EmptyStatementNode(); DBG($$, @1, @2); }
850   | DEBUGGER error                      { $$ = new EmptyStatementNode(); DBG($$, @1, @1); AUTO_SEMICOLON; }
851 ;
852
853 FunctionDeclaration:
854     FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncDeclNode(*$2, $5); }
855   | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
856                                         { $$ = new FuncDeclNode(*$2, $4.head, $6); }
857 ;
858
859 FunctionExpr:
860     FUNCTION '(' ')' FunctionBody       { $$ = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, $4); }
861   | FUNCTION '(' FormalParameterList ')' FunctionBody
862                                         { $$ = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, $5, $3.head); }
863   | FUNCTION IDENT '(' ')' FunctionBody { $$ = new FuncExprNode(*$2, $5); }
864   | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody
865                                         { $$ = new FuncExprNode(*$2, $6, $4.head); }
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(0); DBG($$, @1, @2); }
877   | '{' SourceElements '}'              { $$ = new FunctionBodyNode($2); DBG($$, @1, @3); }
878 ;
879
880 Program:
881     /* not in spec */                   { Parser::accept(new ProgramNode(0)); }
882     | SourceElements                    { Parser::accept(new ProgramNode($1)); }
883 ;
884
885 SourceElements:
886     SourceElement                       { $$ = new Vector<RefPtr<StatementNode> >();
887                                           $$->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::curr()->prevTerminator();
1097 }