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