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