Reviewed by John.
[WebKit-https.git] / JavaScriptCore / kjs / grammar.cpp
1
2 /*  A Bison parser, made from grammar.y
3     by GNU Bison version 1.28  */
4
5 #define YYBISON 1  /* Identify Bison output.  */
6
7 #define yyparse kjsyyparse
8 #define yylex kjsyylex
9 #define yyerror kjsyyerror
10 #define yylval kjsyylval
11 #define yychar kjsyychar
12 #define yydebug kjsyydebug
13 #define yynerrs kjsyynerrs
14 #define YYLSP_NEEDED
15
16 #define NULLTOKEN       257
17 #define TRUETOKEN       258
18 #define FALSETOKEN      259
19 #define STRING  260
20 #define NUMBER  261
21 #define BREAK   262
22 #define CASE    263
23 #define DEFAULT 264
24 #define FOR     265
25 #define NEW     266
26 #define VAR     267
27 #define CONTINUE        268
28 #define FUNCTION        269
29 #define RETURN  270
30 #define VOID    271
31 #define DELETE  272
32 #define IF      273
33 #define THIS    274
34 #define DO      275
35 #define WHILE   276
36 #define ELSE    277
37 #define IN      278
38 #define INSTANCEOF      279
39 #define TYPEOF  280
40 #define SWITCH  281
41 #define WITH    282
42 #define RESERVED        283
43 #define THROW   284
44 #define TRY     285
45 #define CATCH   286
46 #define FINALLY 287
47 #define EQEQ    288
48 #define NE      289
49 #define STREQ   290
50 #define STRNEQ  291
51 #define LE      292
52 #define GE      293
53 #define OR      294
54 #define AND     295
55 #define PLUSPLUS        296
56 #define MINUSMINUS      297
57 #define LSHIFT  298
58 #define RSHIFT  299
59 #define URSHIFT 300
60 #define PLUSEQUAL       301
61 #define MINUSEQUAL      302
62 #define MULTEQUAL       303
63 #define DIVEQUAL        304
64 #define LSHIFTEQUAL     305
65 #define RSHIFTEQUAL     306
66 #define URSHIFTEQUAL    307
67 #define ANDEQUAL        308
68 #define MODEQUAL        309
69 #define XOREQUAL        310
70 #define OREQUAL 311
71 #define IDENT   312
72 #define AUTOPLUSPLUS    313
73 #define AUTOMINUSMINUS  314
74
75 #line 1 "grammar.y"
76
77
78 /*
79  *  This file is part of the KDE libraries
80  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
81  *
82  *  This library is free software; you can redistribute it and/or
83  *  modify it under the terms of the GNU Lesser General Public
84  *  License as published by the Free Software Foundation; either
85  *  version 2 of the License, or (at your option) any later version.
86  *
87  *  This library is distributed in the hope that it will be useful,
88  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
89  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
90  *  Lesser General Public License for more details.
91  *
92  *  You should have received a copy of the GNU Lesser General Public
93  *  License along with this library; if not, write to the Free Software
94  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
95  *
96  */
97
98 #ifdef HAVE_CONFIG_H
99 #include <config.h>
100 #endif
101 #include <string.h>
102 #include <stdlib.h>
103 #include "value.h"
104 #include "object.h"
105 #include "types.h"
106 #include "interpreter.h"
107 #include "nodes.h"
108 #include "lexer.h"
109 #include "internal.h"
110
111 // Not sure why, but yacc doesn't add this define along with the others.
112 #define yylloc kjsyylloc
113
114 /* default values for bison */
115 #define YYDEBUG 0
116 #define YYMAXDEPTH 0
117 #if !APPLE_CHANGES
118 #define YYERROR_VERBOSE
119 #endif
120 #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::sid); } // location
121
122 extern int kjsyylex();
123 int kjsyyerror(const char *);
124 static bool automatic();
125
126 using namespace KJS;
127
128
129 #line 55 "grammar.y"
130 typedef union {
131   int                 ival;
132   double              dval;
133   UString             *ustr;
134   Identifier          *ident;
135   Node                *node;
136   StatementNode       *stat;
137   ParameterNode       *param;
138   FunctionBodyNode    *body;
139   FuncDeclNode        *func;
140   ProgramNode         *prog;
141   AssignExprNode      *init;
142   SourceElementsNode  *srcs;
143   StatListNode        *slist;
144   ArgumentsNode       *args;
145   ArgumentListNode    *alist;
146   VarDeclNode         *decl;
147   VarDeclListNode     *vlist;
148   CaseBlockNode       *cblk;
149   ClauseListNode      *clist;
150   CaseClauseNode      *ccl;
151   ElementNode         *elm;
152   Operator            op;
153   PropertyValueNode   *plist;
154   PropertyNode        *pnode;
155   CatchNode           *cnode;
156   FinallyNode         *fnode;
157 } YYSTYPE;
158
159 #ifndef YYLTYPE
160 typedef
161   struct yyltype
162     {
163       int timestamp;
164       int first_line;
165       int first_column;
166       int last_line;
167       int last_column;
168       char *text;
169    }
170   yyltype;
171
172 #define YYLTYPE yyltype
173 #endif
174
175 #include <stdio.h>
176
177 #ifndef __cplusplus
178 #ifndef __STDC__
179 #define const
180 #endif
181 #endif
182
183
184
185 #define YYFINAL         359
186 #define YYFLAG          -32768
187 #define YYNTBASE        85
188
189 #define YYTRANSLATE(x) ((unsigned)(x) <= 314 ? yytranslate[x] : 149)
190
191 static const char yytranslate[] = {     0,
192      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
193      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
194      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
195      2,     2,    74,     2,     2,     2,    76,    79,     2,    62,
196     63,    75,    71,    68,    72,    70,    61,     2,     2,     2,
197      2,     2,     2,     2,     2,     2,     2,    69,    84,    77,
198     83,    78,    82,     2,     2,     2,     2,     2,     2,     2,
199      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
200      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
201     66,     2,    67,    80,     2,     2,     2,     2,     2,     2,
202      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
203      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
204      2,     2,    64,    81,    65,    73,     2,     2,     2,     2,
205      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
206      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
207      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
208      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
209      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
210      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
211      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
212      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
213      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
214      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
215      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
216      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
217      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
218      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
219     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
220     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
221     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
222     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
223     57,    58,    59,    60
224 };
225
226 #if YYDEBUG != 0
227 static const short yyprhs[] = {     0,
228      0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
229     20,    22,    26,    29,    33,    37,    41,    47,    50,    55,
230     56,    58,    60,    63,    67,    73,    75,    77,    79,    81,
231     83,    88,    92,    96,    98,   101,   104,   107,   112,   116,
232    119,   123,   125,   129,   131,   133,   135,   138,   141,   143,
233    146,   149,   152,   155,   158,   161,   164,   167,   170,   173,
234    176,   178,   182,   186,   190,   192,   196,   200,   202,   206,
235    210,   214,   216,   220,   224,   228,   232,   236,   240,   242,
236    246,   250,   254,   258,   260,   264,   266,   270,   272,   276,
237    278,   282,   284,   288,   290,   296,   298,   302,   304,   306,
238    308,   310,   312,   314,   316,   318,   320,   322,   324,   326,
239    328,   332,   334,   336,   338,   340,   342,   344,   346,   348,
240    350,   352,   354,   356,   358,   360,   363,   367,   369,   372,
241    376,   380,   382,   386,   388,   391,   394,   396,   399,   402,
242    408,   416,   423,   429,   439,   450,   458,   467,   477,   478,
243    480,   483,   486,   490,   494,   497,   500,   504,   508,   511,
244    514,   518,   522,   528,   534,   538,   544,   545,   547,   549,
245    552,   556,   561,   564,   568,   572,   576,   580,   584,   588,
246    593,   599,   602,   608,   615,   620,   626,   628,   632,   635,
247    639,   640,   642,   644,   647,   649
248 };
249
250 static const short yyrhs[] = {     3,
251      0,     4,     0,     5,     0,     7,     0,     6,     0,    61,
252      0,    50,     0,    20,     0,    58,     0,    85,     0,    87,
253      0,    62,   114,    63,     0,    64,    65,     0,    64,    91,
254     65,     0,    66,    89,    67,     0,    66,    88,    67,     0,
255     66,    88,    68,    89,    67,     0,    89,   112,     0,    88,
256     68,    89,   112,     0,     0,    90,     0,    68,     0,    90,
257     68,     0,    92,    69,   112,     0,    91,    68,    92,    69,
258    112,     0,    58,     0,     6,     0,     7,     0,    86,     0,
259    143,     0,    93,    66,   114,    67,     0,    93,    70,    58,
260      0,    12,    93,    96,     0,    93,     0,    12,    94,     0,
261     93,    96,     0,    95,    96,     0,    95,    66,   114,    67,
262      0,    95,    70,    58,     0,    62,    63,     0,    62,    97,
263     63,     0,   112,     0,    97,    68,   112,     0,    94,     0,
264     95,     0,    98,     0,    98,    42,     0,    98,    43,     0,
265     99,     0,    18,   100,     0,    17,   100,     0,    26,   100,
266      0,    42,   100,     0,    59,   100,     0,    43,   100,     0,
267     60,   100,     0,    71,   100,     0,    72,   100,     0,    73,
268    100,     0,    74,   100,     0,   100,     0,   101,    75,   100,
269      0,   101,    61,   100,     0,   101,    76,   100,     0,   101,
270      0,   102,    71,   101,     0,   102,    72,   101,     0,   102,
271      0,   103,    44,   102,     0,   103,    45,   102,     0,   103,
272     46,   102,     0,   103,     0,   104,    77,   103,     0,   104,
273     78,   103,     0,   104,    38,   103,     0,   104,    39,   103,
274      0,   104,    25,   103,     0,   104,    24,   103,     0,   104,
275      0,   105,    34,   104,     0,   105,    35,   104,     0,   105,
276     36,   104,     0,   105,    37,   104,     0,   105,     0,   106,
277     79,   105,     0,   106,     0,   107,    80,   106,     0,   107,
278      0,   108,    81,   107,     0,   108,     0,   109,    41,   108,
279      0,   109,     0,   110,    40,   109,     0,   110,     0,   110,
280     82,   112,    69,   112,     0,   111,     0,    98,   113,   112,
281      0,    83,     0,    47,     0,    48,     0,    49,     0,    50,
282      0,    51,     0,    52,     0,    53,     0,    54,     0,    56,
283      0,    57,     0,    55,     0,   112,     0,   114,    68,   112,
284      0,   116,     0,   118,     0,   122,     0,   123,     0,   124,
285      0,   125,     0,   127,     0,   128,     0,   129,     0,   130,
286      0,   131,     0,   137,     0,   138,     0,   139,     0,    64,
287     65,     0,    64,   147,    65,     0,   115,     0,   117,   115,
288      0,    13,   119,    84,     0,    13,   119,     1,     0,   120,
289      0,   119,    68,   120,     0,    58,     0,    58,   121,     0,
290     83,   112,     0,    84,     0,   114,    84,     0,   114,     1,
291      0,    19,    62,   114,    63,   115,     0,    19,    62,   114,
292     63,   115,    23,   115,     0,    21,   115,    22,    62,   114,
293     63,     0,    22,    62,   114,    63,   115,     0,    11,    62,
294    126,    84,   126,    84,   126,    63,   115,     0,    11,    62,
295     13,   119,    84,   126,    84,   126,    63,   115,     0,    11,
296     62,    98,    24,   114,    63,   115,     0,    11,    62,    13,
297     58,    24,   114,    63,   115,     0,    11,    62,    13,    58,
298    121,    24,   114,    63,   115,     0,     0,   114,     0,    14,
299     84,     0,    14,     1,     0,    14,    58,    84,     0,    14,
300     58,     1,     0,     8,    84,     0,     8,     1,     0,     8,
301     58,    84,     0,     8,    58,     1,     0,    16,    84,     0,
302     16,     1,     0,    16,   114,    84,     0,    16,   114,     1,
303      0,    28,    62,   114,    63,   115,     0,    27,    62,   114,
304     63,   132,     0,    64,   133,    65,     0,    64,   133,   136,
305    133,    65,     0,     0,   134,     0,   135,     0,   134,   135,
306      0,     9,   114,    69,     0,     9,   114,    69,   117,     0,
307     10,    69,     0,    10,    69,   117,     0,    58,    69,   115,
308      0,    30,   114,    84,     0,    30,   114,     1,     0,    31,
309    116,   140,     0,    31,   116,   141,     0,    31,   116,   140,
310    141,     0,    32,    62,    58,    63,   116,     0,    33,   116,
311      0,    15,    58,    62,    63,   145,     0,    15,    58,    62,
312    144,    63,   145,     0,    15,    62,    63,   145,     0,    15,
313     62,   144,    63,   145,     0,    58,     0,   144,    68,    58,
314      0,    64,    65,     0,    64,   147,    65,     0,     0,   147,
315      0,   148,     0,   147,   148,     0,   115,     0,   142,     0
316 };
317
318 #endif
319
320 #if YYDEBUG != 0
321 static const short yyrline[] = { 0,
322    169,   171,   172,   173,   174,   175,   178,   184,   186,   187,
323    188,   189,   190,   191,   194,   196,   197,   200,   202,   206,
324    208,   211,   213,   216,   218,   222,   224,   225,   228,   230,
325    231,   232,   233,   236,   238,   241,   243,   244,   245,   248,
326    250,   253,   255,   258,   260,   263,   265,   266,   269,   271,
327    272,   273,   274,   275,   276,   277,   278,   279,   280,   281,
328    284,   286,   287,   288,   291,   293,   294,   297,   299,   300,
329    301,   304,   306,   308,   310,   312,   314,   316,   320,   322,
330    323,   324,   325,   328,   330,   333,   335,   338,   340,   343,
331    345,   349,   351,   355,   357,   361,   363,   367,   369,   370,
332    371,   372,   373,   374,   375,   376,   377,   378,   379,   382,
333    384,   387,   389,   390,   391,   392,   393,   394,   395,   396,
334    397,   398,   399,   400,   401,   404,   406,   409,   411,   414,
335    417,   426,   428,   432,   434,   437,   441,   445,   448,   455,
336    457,   461,   463,   464,   467,   470,   473,   476,   481,   483,
337    486,   488,   492,   493,   499,   501,   505,   506,   513,   515,
338    519,   520,   526,   531,   536,   538,   542,   544,   547,   549,
339    552,   554,   557,   559,   562,   567,   569,   572,   574,   575,
340    578,   582,   586,   588,   591,   593,   598,   600,   603,   606,
341    610,   613,   617,   619,   622,   624
342 };
343 #endif
344
345
346 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
347
348 static const char * const yytname[] = {   "$","error","$undefined.","NULLTOKEN",
349 "TRUETOKEN","FALSETOKEN","STRING","NUMBER","BREAK","CASE","DEFAULT","FOR","NEW",
350 "VAR","CONTINUE","FUNCTION","RETURN","VOID","DELETE","IF","THIS","DO","WHILE",
351 "ELSE","IN","INSTANCEOF","TYPEOF","SWITCH","WITH","RESERVED","THROW","TRY","CATCH",
352 "FINALLY","EQEQ","NE","STREQ","STRNEQ","LE","GE","OR","AND","PLUSPLUS","MINUSMINUS",
353 "LSHIFT","RSHIFT","URSHIFT","PLUSEQUAL","MINUSEQUAL","MULTEQUAL","DIVEQUAL",
354 "LSHIFTEQUAL","RSHIFTEQUAL","URSHIFTEQUAL","ANDEQUAL","MODEQUAL","XOREQUAL",
355 "OREQUAL","IDENT","AUTOPLUSPLUS","AUTOMINUSMINUS","'/'","'('","')'","'{'","'}'",
356 "'['","']'","','","':'","'.'","'+'","'-'","'~'","'!'","'*'","'%'","'<'","'>'",
357 "'&'","'^'","'|'","'?'","'='","';'","Literal","PrimaryExpr","ArrayLiteral","ElementList",
358 "ElisionOpt","Elision","PropertyNameAndValueList","PropertyName","MemberExpr",
359 "NewExpr","CallExpr","Arguments","ArgumentList","LeftHandSideExpr","PostfixExpr",
360 "UnaryExpr","MultiplicativeExpr","AdditiveExpr","ShiftExpr","RelationalExpr",
361 "EqualityExpr","BitwiseANDExpr","BitwiseXORExpr","BitwiseORExpr","LogicalANDExpr",
362 "LogicalORExpr","ConditionalExpr","AssignmentExpr","AssignmentOperator","Expr",
363 "Statement","Block","StatementList","VariableStatement","VariableDeclarationList",
364 "VariableDeclaration","Initializer","EmptyStatement","ExprStatement","IfStatement",
365 "IterationStatement","ExprOpt","ContinueStatement","BreakStatement","ReturnStatement",
366 "WithStatement","SwitchStatement","CaseBlock","CaseClausesOpt","CaseClauses",
367 "CaseClause","DefaultClause","LabelledStatement","ThrowStatement","TryStatement",
368 "Catch","Finally","FunctionDeclaration","FunctionExpr","FormalParameterList",
369 "FunctionBody","Program","SourceElements","SourceElement", NULL
370 };
371 #endif
372
373 static const short yyr1[] = {     0,
374     85,    85,    85,    85,    85,    85,    85,    86,    86,    86,
375     86,    86,    86,    86,    87,    87,    87,    88,    88,    89,
376     89,    90,    90,    91,    91,    92,    92,    92,    93,    93,
377     93,    93,    93,    94,    94,    95,    95,    95,    95,    96,
378     96,    97,    97,    98,    98,    99,    99,    99,   100,   100,
379    100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
380    101,   101,   101,   101,   102,   102,   102,   103,   103,   103,
381    103,   104,   104,   104,   104,   104,   104,   104,   105,   105,
382    105,   105,   105,   106,   106,   107,   107,   108,   108,   109,
383    109,   110,   110,   111,   111,   112,   112,   113,   113,   113,
384    113,   113,   113,   113,   113,   113,   113,   113,   113,   114,
385    114,   115,   115,   115,   115,   115,   115,   115,   115,   115,
386    115,   115,   115,   115,   115,   116,   116,   117,   117,   118,
387    118,   119,   119,   120,   120,   121,   122,   123,   123,   124,
388    124,   125,   125,   125,   125,   125,   125,   125,   126,   126,
389    127,   127,   127,   127,   128,   128,   128,   128,   129,   129,
390    129,   129,   130,   131,   132,   132,   133,   133,   134,   134,
391    135,   135,   136,   136,   137,   138,   138,   139,   139,   139,
392    140,   141,   142,   142,   143,   143,   144,   144,   145,   145,
393    146,   146,   147,   147,   148,   148
394 };
395
396 static const short yyr2[] = {     0,
397      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
398      1,     3,     2,     3,     3,     3,     5,     2,     4,     0,
399      1,     1,     2,     3,     5,     1,     1,     1,     1,     1,
400      4,     3,     3,     1,     2,     2,     2,     4,     3,     2,
401      3,     1,     3,     1,     1,     1,     2,     2,     1,     2,
402      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
403      1,     3,     3,     3,     1,     3,     3,     1,     3,     3,
404      3,     1,     3,     3,     3,     3,     3,     3,     1,     3,
405      3,     3,     3,     1,     3,     1,     3,     1,     3,     1,
406      3,     1,     3,     1,     5,     1,     3,     1,     1,     1,
407      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
408      3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
409      1,     1,     1,     1,     1,     2,     3,     1,     2,     3,
410      3,     1,     3,     1,     2,     2,     1,     2,     2,     5,
411      7,     6,     5,     9,    10,     7,     8,     9,     0,     1,
412      2,     2,     3,     3,     2,     2,     3,     3,     2,     2,
413      3,     3,     5,     5,     3,     5,     0,     1,     1,     2,
414      3,     4,     2,     3,     3,     3,     3,     3,     3,     4,
415      5,     2,     5,     6,     4,     5,     1,     3,     2,     3,
416      0,     1,     1,     2,     1,     1
417 };
418
419 static const short yydefact[] = {   191,
420      1,     2,     3,     5,     4,     0,     0,     0,     0,     0,
421      0,     0,     0,     0,     0,     8,     0,     0,     0,     0,
422      0,     0,     0,     0,     0,     7,     9,     0,     0,     6,
423      0,     0,    20,     0,     0,     0,     0,   137,    10,    29,
424     11,    34,    44,    45,    46,    49,    61,    65,    68,    72,
425     79,    84,    86,    88,    90,    92,    94,    96,   110,     0,
426    195,   112,   113,   114,   115,   116,   117,   118,   119,   120,
427    121,   122,   123,   124,   125,   196,    30,   192,   193,   156,
428      0,   155,   149,     0,     9,     0,    34,    35,   134,     0,
429    132,   152,     0,   151,     0,     0,   160,   159,     0,    46,
430     51,    50,     0,     0,     0,    52,     0,     0,     0,     0,
431      0,    53,    55,     0,    54,    56,     0,     5,     4,     9,
432     13,     0,     0,     0,    22,     0,     0,    21,    57,    58,
433     59,    60,     0,     0,     0,    36,     0,     0,    37,    47,
434     48,    99,   100,   101,   102,   103,   104,   105,   106,   109,
435    107,   108,    98,     0,     0,     0,     0,     0,     0,     0,
436      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
437      0,     0,     0,     0,     0,     0,     0,     0,   139,     0,
438    138,   194,   158,   157,     0,    46,   150,     0,    27,    28,
439     26,    13,    33,     0,   135,   131,     0,   130,   154,   153,
440      0,   187,     0,     0,   162,   161,     0,     0,     0,     0,
441      0,   177,   176,   126,     0,     0,   178,   179,   175,    12,
442     14,     0,     0,   127,    16,    20,    15,    18,    23,    40,
443      0,    42,     0,    32,     0,    39,    97,    63,    62,    64,
444     66,    67,    69,    70,    71,    78,    77,    75,    76,    73,
445     74,    80,    81,    82,    83,    85,    87,    89,    91,    93,
446      0,   111,   134,     0,     0,   149,   136,   133,     0,     0,
447      0,   185,     0,     0,     0,     0,     0,     0,     0,     0,
448    182,   180,     0,    24,     0,    41,     0,    31,    38,     0,
449      0,   135,   149,     0,     0,   183,     0,   189,     0,   186,
450    188,   140,     0,   143,   167,   164,   163,     0,     0,    17,
451     19,    43,    95,     0,     0,     0,     0,   149,   184,   190,
452      0,   142,     0,     0,   168,   169,     0,    25,     0,     0,
453    149,   146,     0,   141,     0,     0,   165,   167,   170,   181,
454    147,     0,     0,     0,   171,   173,     0,   148,     0,   144,
455    128,   172,   174,   166,   145,   129,     0,     0,     0
456 };
457
458 static const short yydefgoto[] = {    39,
459     40,    41,   126,   127,   128,   122,   123,    42,    43,    44,
460    136,   231,    45,    46,    47,    48,    49,    50,    51,    52,
461     53,    54,    55,    56,    57,    58,    59,   154,    60,    61,
462     62,   352,    63,    90,    91,   195,    64,    65,    66,    67,
463    188,    68,    69,    70,    71,    72,   306,   324,   325,   326,
464    338,    73,    74,    75,   217,   218,    76,    77,   204,   272,
465    357,   124,    79
466 };
467
468 static const short yypact[] = {   780,
469 -32768,-32768,-32768,-32768,-32768,     5,   -52,   111,     9,     6,
470     25,   336,  1253,  1253,    -3,-32768,   854,    47,  1253,    50,
471     57,  1253,    29,  1253,  1253,-32768,    36,  1253,  1253,-32768,
472   1253,   410,    12,  1253,  1253,  1253,  1253,-32768,-32768,-32768,
473 -32768,    83,-32768,    84,   180,-32768,-32768,   -34,    61,   220,
474     82,   212,    76,    94,    95,   151,    31,-32768,-32768,    11,
475 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
476 -32768,-32768,-32768,-32768,-32768,-32768,-32768,   780,-32768,-32768,
477      7,-32768,   965,   102,-32768,    45,    83,-32768,   112,    16,
478 -32768,-32768,     8,-32768,   197,   -19,-32768,-32768,    18,   105,
479 -32768,-32768,  1253,   198,  1253,-32768,  1253,  1253,    20,   484,
480    119,-32768,-32768,   854,-32768,-32768,    -6,   192,   203,    36,
481    936,   -37,   207,   558,-32768,   174,  1037,   209,-32768,-32768,
482 -32768,-32768,  1109,  1253,   221,-32768,  1253,   222,-32768,-32768,
483 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
484 -32768,-32768,-32768,  1253,  1253,  1253,  1253,  1253,  1253,  1253,
485   1253,  1253,  1253,  1253,  1253,  1253,  1253,  1253,  1253,  1253,
486   1253,  1253,  1253,  1253,  1253,  1253,  1253,  1253,-32768,  1253,
487 -32768,-32768,-32768,-32768,   223,    87,   210,   199,-32768,-32768,
488 -32768,-32768,-32768,  1253,-32768,-32768,     9,-32768,-32768,-32768,
489     64,-32768,   224,    99,-32768,-32768,   103,   225,   121,   122,
490    123,-32768,-32768,-32768,   227,    29,   252,-32768,-32768,-32768,
491 -32768,    27,  1253,-32768,-32768,    12,-32768,-32768,-32768,-32768,
492    125,-32768,   187,-32768,   201,-32768,-32768,-32768,-32768,-32768,
493    -34,   -34,    61,    61,    61,   220,   220,   220,   220,   220,
494    220,    82,    82,    82,    82,   212,    76,    94,    95,   151,
495    217,-32768,    -1,   -44,  1253,  1253,-32768,-32768,   224,   156,
496    632,-32768,   224,   232,   854,  1253,   854,   228,   854,   233,
497 -32768,-32768,   226,-32768,  1181,-32768,  1253,-32768,-32768,  1253,
498   1253,   269,  1253,   158,   213,-32768,   224,-32768,   706,-32768,
499 -32768,   271,   175,-32768,   287,-32768,-32768,   235,  1253,-32768,
500 -32768,-32768,-32768,   176,  1253,   215,   854,  1253,-32768,-32768,
501    854,-32768,  1253,    43,   287,-32768,    29,-32768,   854,   177,
502   1253,-32768,   238,-32768,   202,   234,-32768,   287,-32768,-32768,
503 -32768,   854,   239,   854,   854,   854,   242,-32768,   854,-32768,
504 -32768,   854,   854,-32768,-32768,-32768,   308,   310,-32768
505 };
506
507 static const short yypgoto[] = {-32768,
508 -32768,-32768,-32768,    85,-32768,-32768,    91,   307,   309,-32768,
509    -26,-32768,    41,-32768,     1,   116,  -114,    15,    81,   143,
510    144,   145,   147,   142,-32768,-32768,  -122,-32768,    -9,   -17,
511    -22,   -25,-32768,   139,   129,    67,-32768,-32768,-32768,-32768,
512   -250,-32768,-32768,-32768,-32768,-32768,-32768,    -7,-32768,    13,
513 -32768,-32768,-32768,-32768,-32768,   117,-32768,-32768,   132,  -224,
514 -32768,     2,   -74
515 };
516
517
518 #define YYLAST          1327
519
520
521 static const short yytable[] = {   104,
522    111,    78,    99,   182,   228,    80,    92,   183,   199,    83,
523    232,   179,   109,   101,   102,   295,   196,   139,   205,   106,
524    212,   117,   291,   197,   112,   113,   155,   221,   115,   116,
525    222,   237,   189,   190,   129,   130,   131,   132,   202,   293,
526    156,   157,   316,   203,   296,   243,   244,   245,   300,   182,
527    189,   190,   336,   100,   100,   261,   220,   262,   103,   100,
528    193,   180,    81,    93,   100,   100,    89,   333,   100,   100,
529    177,   267,   319,   187,   100,   100,   100,   100,   180,   125,
530    343,   194,    95,   197,   191,   180,    96,   180,    82,    94,
531    184,   200,   110,   207,   181,   209,   219,   210,   211,   198,
532    284,   206,   191,   213,   114,   163,   164,   337,   105,   192,
533    265,   107,   178,     1,     2,     3,     4,     5,   108,   165,
534    166,   202,     8,   186,   233,    84,   269,   235,   140,   141,
535     16,   158,   159,   142,   143,   144,   145,   146,   147,   148,
536    149,   150,   151,   152,   133,   133,   140,   141,   134,   137,
537    215,   216,   135,   138,   173,   238,   239,   240,   167,   168,
538     26,   273,   311,    96,   312,   275,   274,   313,    85,   153,
539    180,    30,    31,   174,    86,   175,    33,   246,   247,   248,
540    249,   250,   251,   277,   278,   279,   328,   286,   180,   180,
541    180,   176,   287,   281,   194,   100,   100,   100,   100,   100,
542    100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
543    100,   100,   100,   100,   100,   100,   100,   100,   297,   208,
544    317,   140,   141,   274,   182,   180,   142,   143,   144,   145,
545    146,   147,   148,   149,   150,   151,   152,   322,   329,   342,
546    225,   226,   180,   180,   180,   169,   170,   171,   172,   252,
547    253,   254,   255,   288,   180,   294,   187,   302,   201,   304,
548    -27,   307,   153,   160,   161,   162,   303,   289,   180,   180,
549    345,   -28,   299,   241,   242,   223,   229,   180,   234,   236,
550    263,   314,   266,   187,   216,   290,   276,   271,   280,   301,
551    308,   305,   315,   321,   309,   323,   318,   327,   331,   332,
552    344,   349,   346,   334,   340,   330,   354,   358,   187,   359,
553    285,   341,   283,   335,    87,   256,    88,   257,   260,   258,
554    353,   187,   259,   264,   348,   268,   350,   351,   351,   292,
555    347,   355,   270,   282,   356,   356,    97,   339,     1,     2,
556      3,     4,     5,     0,     0,     0,     0,     8,     0,     0,
557     84,     0,    13,    14,     0,    16,     0,     0,     0,     0,
558      0,    19,     0,     0,     0,     0,     0,     0,     0,     0,
559      0,     0,     0,     0,     0,     0,     0,    24,    25,     0,
560      0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
561      0,     0,     0,    85,    28,    29,    30,    31,     0,    86,
562      0,    33,     0,     0,     0,     0,    34,    35,    36,    37,
563      0,     0,     1,     2,     3,   118,   119,     6,     0,    98,
564      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
565     17,    18,     0,     0,     0,    19,    20,    21,     0,    22,
566     23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
567      0,    24,    25,     0,     0,     0,     0,     0,     0,    26,
568      0,     0,     0,     0,     0,     0,     0,   120,    28,    29,
569     30,    31,     0,    32,   121,    33,     0,     0,     0,     0,
570     34,    35,    36,    37,     0,     0,     1,     2,     3,     4,
571      5,     6,     0,    38,     7,     8,     9,    10,    11,    12,
572     13,    14,    15,    16,    17,    18,     0,     0,     0,    19,
573     20,    21,     0,    22,    23,     0,     0,     0,     0,     0,
574      0,     0,     0,     0,     0,    24,    25,     0,     0,     0,
575      0,     0,     0,    26,     0,     0,     0,     0,     0,     0,
576      0,    27,    28,    29,    30,    31,     0,    32,   214,    33,
577      0,     0,     0,     0,    34,    35,    36,    37,     0,     0,
578      1,     2,     3,     4,     5,     6,     0,    38,     7,     8,
579      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
580      0,     0,     0,    19,    20,    21,     0,    22,    23,     0,
581      0,     0,     0,     0,     0,     0,     0,     0,     0,    24,
582     25,     0,     0,     0,     0,     0,     0,    26,     0,     0,
583      0,     0,     0,     0,     0,    27,    28,    29,    30,    31,
584      0,    32,   224,    33,     0,     0,     0,     0,    34,    35,
585     36,    37,     0,     0,     1,     2,     3,     4,     5,     6,
586      0,    38,     7,     8,     9,    10,    11,    12,    13,    14,
587     15,    16,    17,    18,     0,     0,     0,    19,    20,    21,
588      0,    22,    23,     0,     0,     0,     0,     0,     0,     0,
589      0,     0,     0,    24,    25,     0,     0,     0,     0,     0,
590      0,    26,     0,     0,     0,     0,     0,     0,     0,    27,
591     28,    29,    30,    31,     0,    32,   298,    33,     0,     0,
592      0,     0,    34,    35,    36,    37,     0,     0,     1,     2,
593      3,     4,     5,     6,     0,    38,     7,     8,     9,    10,
594     11,    12,    13,    14,    15,    16,    17,    18,     0,     0,
595      0,    19,    20,    21,     0,    22,    23,     0,     0,     0,
596      0,     0,     0,     0,     0,     0,     0,    24,    25,     0,
597      0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
598      0,     0,     0,    27,    28,    29,    30,    31,     0,    32,
599    320,    33,     0,     0,     0,     0,    34,    35,    36,    37,
600      0,     0,     1,     2,     3,     4,     5,     6,     0,    38,
601      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
602     17,    18,     0,     0,     0,    19,    20,    21,     0,    22,
603     23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
604      0,    24,    25,     0,     0,     0,     0,     0,     0,    26,
605      0,     0,     0,     0,     0,     0,     0,    27,    28,    29,
606     30,    31,     0,    32,     0,    33,     0,     0,     0,     0,
607     34,    35,    36,    37,     0,     0,     1,     2,     3,     4,
608      5,     6,     0,    38,     7,     8,     9,    10,    84,    12,
609     13,    14,    15,    16,    17,    18,     0,     0,     0,    19,
610     20,    21,     0,    22,    23,     0,     0,     0,     0,     0,
611      0,     0,     0,     0,     0,    24,    25,     0,     0,     0,
612      0,     0,     0,    26,     0,     0,     0,     0,     0,     0,
613      0,    27,    28,    29,    30,    31,     0,    32,     0,    33,
614      0,     0,     0,     0,    34,    35,    36,    37,     0,     0,
615      0,     0,     0,     0,     0,  -126,     0,    38,  -126,  -126,
616   -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,
617   -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,     0,
618      0,  -126,  -126,  -126,     0,  -126,  -126,     1,     2,     3,
619      4,     5,     0,     0,     0,     0,     8,   185,     0,    84,
620      0,    13,    14,     0,    16,     0,     0,     0,     0,     0,
621     19,     0,     0,  -126,  -126,  -126,     0,     0,     0,  -126,
622   -126,     0,     0,     0,     0,     0,    24,    25,  -126,  -126,
623      0,     0,     0,     0,    26,     0,     0,     0,     0,     0,
624      0,     0,    85,    28,    29,    30,    31,     0,    86,     0,
625     33,     0,     0,     0,     0,    34,    35,    36,    37,     1,
626      2,     3,     4,     5,     0,     0,     0,     0,     8,     0,
627      0,    84,     0,    13,    14,     0,    16,     0,     0,     0,
628      0,     0,    19,     0,     0,     0,     0,     0,     0,     0,
629      0,     0,     0,     0,     0,     0,     0,     0,    24,    25,
630      0,     0,     0,     0,     0,     0,    26,     0,     0,     0,
631      0,     0,     0,     0,    85,    28,    29,    30,    31,     0,
632     86,     0,    33,   227,     0,     0,     0,    34,    35,    36,
633     37,     1,     2,     3,     4,     5,     0,     0,     0,     0,
634      8,     0,     0,    84,     0,    13,    14,     0,    16,     0,
635      0,     0,     0,     0,    19,     0,     0,     0,     0,     0,
636      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
637     24,    25,     0,     0,     0,     0,     0,     0,    26,     0,
638      0,     0,     0,     0,     0,     0,    85,    28,    29,    30,
639     31,   230,    86,     0,    33,     0,     0,     0,     0,    34,
640     35,    36,    37,     1,     2,     3,     4,     5,     0,     0,
641      0,     0,     8,     0,     0,    84,     0,    13,    14,     0,
642     16,     0,     0,     0,     0,     0,    19,     0,     0,     0,
643      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
644      0,     0,    24,    25,     0,     0,     0,     0,     0,     0,
645     26,     0,     0,     0,     0,     0,     0,     0,    85,    28,
646     29,    30,    31,     0,    86,     0,    33,   310,     0,     0,
647      0,    34,    35,    36,    37,     1,     2,     3,     4,     5,
648      0,     0,     0,     0,     8,     0,     0,    84,     0,    13,
649     14,     0,    16,     0,     0,     0,     0,     0,    19,     0,
650      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
651      0,     0,     0,     0,    24,    25,     0,     0,     0,     0,
652      0,     0,    26,     0,     0,     0,     0,     0,     0,     0,
653     85,    28,    29,    30,    31,     0,    86,     0,    33,     0,
654      0,     0,     0,    34,    35,    36,    37
655 };
656
657 static const short yycheck[] = {    17,
658     23,     0,    12,    78,   127,     1,     1,     1,     1,    62,
659    133,     1,    22,    13,    14,   266,     1,    44,     1,    19,
660      1,    31,    24,    68,    24,    25,    61,    65,    28,    29,
661     68,   154,     6,     7,    34,    35,    36,    37,    58,    84,
662     75,    76,   293,    63,   269,   160,   161,   162,   273,   124,
663      6,     7,    10,    13,    14,   178,    63,   180,    62,    19,
664     87,    68,    58,    58,    24,    25,    58,   318,    28,    29,
665     40,   194,   297,    83,    34,    35,    36,    37,    68,    68,
666    331,    83,    58,    68,    58,    68,    62,    68,    84,    84,
667     84,    84,    64,   103,    84,   105,   114,   107,   108,    84,
668    223,    84,    58,    84,    69,    24,    25,    65,    62,    65,
669     24,    62,    82,     3,     4,     5,     6,     7,    62,    38,
670     39,    58,    12,    83,   134,    15,    63,   137,    42,    43,
671     20,    71,    72,    47,    48,    49,    50,    51,    52,    53,
672     54,    55,    56,    57,    62,    62,    42,    43,    66,    66,
673     32,    33,    70,    70,    79,   155,   156,   157,    77,    78,
674     50,    63,   285,    62,   287,    63,    68,   290,    58,    83,
675     68,    61,    62,    80,    64,    81,    66,   163,   164,   165,
676    166,   167,   168,    63,    63,    63,   309,    63,    68,    68,
677     68,    41,    68,   216,    83,   155,   156,   157,   158,   159,
678    160,   161,   162,   163,   164,   165,   166,   167,   168,   169,
679    170,   171,   172,   173,   174,   175,   176,   177,    63,    22,
680     63,    42,    43,    68,   299,    68,    47,    48,    49,    50,
681     51,    52,    53,    54,    55,    56,    57,    63,    63,    63,
682     67,    68,    68,    68,    68,    34,    35,    36,    37,   169,
683    170,   171,   172,    67,    68,   265,   266,   275,    62,   277,
684     69,   279,    83,    44,    45,    46,   276,    67,    68,    68,
685     69,    69,   271,   158,   159,    69,    68,    68,    58,    58,
686     58,   291,    84,   293,    33,    69,    62,    64,    62,    58,
687     58,    64,    24,    23,    69,     9,    84,    63,    84,   317,
688     63,    63,    69,   321,   327,   315,    65,     0,   318,     0,
689    226,   329,   222,   323,     8,   173,     8,   174,   177,   175,
690    346,   331,   176,   185,   342,   197,   344,   345,   346,   263,
691    338,   349,   201,   217,   352,   353,     1,   325,     3,     4,
692      5,     6,     7,    -1,    -1,    -1,    -1,    12,    -1,    -1,
693     15,    -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,
694     -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
695     -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,
696     -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
697     -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,    64,
698     -1,    66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,
699     -1,    -1,     3,     4,     5,     6,     7,     8,    -1,    84,
700     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
701     21,    22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,
702     31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
703     -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,
704     -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,
705     61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,
706     71,    72,    73,    74,    -1,    -1,     3,     4,     5,     6,
707      7,     8,    -1,    84,    11,    12,    13,    14,    15,    16,
708     17,    18,    19,    20,    21,    22,    -1,    -1,    -1,    26,
709     27,    28,    -1,    30,    31,    -1,    -1,    -1,    -1,    -1,
710     -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,
711     -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,
712     -1,    58,    59,    60,    61,    62,    -1,    64,    65,    66,
713     -1,    -1,    -1,    -1,    71,    72,    73,    74,    -1,    -1,
714      3,     4,     5,     6,     7,     8,    -1,    84,    11,    12,
715     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
716     -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,    -1,
717     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
718     43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,
719     -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,
720     -1,    64,    65,    66,    -1,    -1,    -1,    -1,    71,    72,
721     73,    74,    -1,    -1,     3,     4,     5,     6,     7,     8,
722     -1,    84,    11,    12,    13,    14,    15,    16,    17,    18,
723     19,    20,    21,    22,    -1,    -1,    -1,    26,    27,    28,
724     -1,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
725     -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,
726     -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
727     59,    60,    61,    62,    -1,    64,    65,    66,    -1,    -1,
728     -1,    -1,    71,    72,    73,    74,    -1,    -1,     3,     4,
729      5,     6,     7,     8,    -1,    84,    11,    12,    13,    14,
730     15,    16,    17,    18,    19,    20,    21,    22,    -1,    -1,
731     -1,    26,    27,    28,    -1,    30,    31,    -1,    -1,    -1,
732     -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,
733     -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
734     -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,    64,
735     65,    66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,
736     -1,    -1,     3,     4,     5,     6,     7,     8,    -1,    84,
737     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
738     21,    22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,
739     31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
740     -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,
741     -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,
742     61,    62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,
743     71,    72,    73,    74,    -1,    -1,     3,     4,     5,     6,
744      7,     8,    -1,    84,    11,    12,    13,    14,    15,    16,
745     17,    18,    19,    20,    21,    22,    -1,    -1,    -1,    26,
746     27,    28,    -1,    30,    31,    -1,    -1,    -1,    -1,    -1,
747     -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,
748     -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,
749     -1,    58,    59,    60,    61,    62,    -1,    64,    -1,    66,
750     -1,    -1,    -1,    -1,    71,    72,    73,    74,    -1,    -1,
751     -1,    -1,    -1,    -1,    -1,     0,    -1,    84,     3,     4,
752      5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
753     15,    16,    17,    18,    19,    20,    21,    22,    23,    -1,
754     -1,    26,    27,    28,    -1,    30,    31,     3,     4,     5,
755      6,     7,    -1,    -1,    -1,    -1,    12,    13,    -1,    15,
756     -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,
757     26,    -1,    -1,    58,    59,    60,    -1,    -1,    -1,    64,
758     65,    -1,    -1,    -1,    -1,    -1,    42,    43,    73,    74,
759     -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,
760     -1,    -1,    58,    59,    60,    61,    62,    -1,    64,    -1,
761     66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,     3,
762      4,     5,     6,     7,    -1,    -1,    -1,    -1,    12,    -1,
763     -1,    15,    -1,    17,    18,    -1,    20,    -1,    -1,    -1,
764     -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
765     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,
766     -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,
767     -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,
768     64,    -1,    66,    67,    -1,    -1,    -1,    71,    72,    73,
769     74,     3,     4,     5,     6,     7,    -1,    -1,    -1,    -1,
770     12,    -1,    -1,    15,    -1,    17,    18,    -1,    20,    -1,
771     -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,
772     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
773     42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,
774     -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,
775     62,    63,    64,    -1,    66,    -1,    -1,    -1,    -1,    71,
776     72,    73,    74,     3,     4,     5,     6,     7,    -1,    -1,
777     -1,    -1,    12,    -1,    -1,    15,    -1,    17,    18,    -1,
778     20,    -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,
779     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
780     -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,
781     50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,
782     60,    61,    62,    -1,    64,    -1,    66,    67,    -1,    -1,
783     -1,    71,    72,    73,    74,     3,     4,     5,     6,     7,
784     -1,    -1,    -1,    -1,    12,    -1,    -1,    15,    -1,    17,
785     18,    -1,    20,    -1,    -1,    -1,    -1,    -1,    26,    -1,
786     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
787     -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,
788     -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
789     58,    59,    60,    61,    62,    -1,    64,    -1,    66,    -1,
790     -1,    -1,    -1,    71,    72,    73,    74
791 };
792 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
793 #line 3 "/usr/share/bison.simple"
794 /* This file comes from bison-1.28.  */
795
796 /* Skeleton output parser for bison,
797    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
798
799    This program is free software; you can redistribute it and/or modify
800    it under the terms of the GNU General Public License as published by
801    the Free Software Foundation; either version 2, or (at your option)
802    any later version.
803
804    This program is distributed in the hope that it will be useful,
805    but WITHOUT ANY WARRANTY; without even the implied warranty of
806    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
807    GNU General Public License for more details.
808
809    You should have received a copy of the GNU General Public License
810    along with this program; if not, write to the Free Software
811    Foundation, Inc., 59 Temple Place - Suite 330,
812    Boston, MA 02111-1307, USA.  */
813
814 /* As a special exception, when this file is copied by Bison into a
815    Bison output file, you may use that output file without restriction.
816    This special exception was added by the Free Software Foundation
817    in version 1.24 of Bison.  */
818
819 /* This is the parser code that is written into each bison parser
820   when the %semantic_parser declaration is not specified in the grammar.
821   It was written by Richard Stallman by simplifying the hairy parser
822   used when %semantic_parser is specified.  */
823
824 #ifndef YYSTACK_USE_ALLOCA
825 #ifdef alloca
826 #define YYSTACK_USE_ALLOCA
827 #else /* alloca not defined */
828 #ifdef __GNUC__
829 #define YYSTACK_USE_ALLOCA
830 #define alloca __builtin_alloca
831 #else /* not GNU C.  */
832 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
833 #define YYSTACK_USE_ALLOCA
834 #include <alloca.h>
835 #else /* not sparc */
836 /* We think this test detects Watcom and Microsoft C.  */
837 /* This used to test MSDOS, but that is a bad idea
838    since that symbol is in the user namespace.  */
839 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
840 #if 0 /* No need for malloc.h, which pollutes the namespace;
841          instead, just don't use alloca.  */
842 #include <malloc.h>
843 #endif
844 #else /* not MSDOS, or __TURBOC__ */
845 #if defined(_AIX)
846 /* I don't know what this was needed for, but it pollutes the namespace.
847    So I turned it off.   rms, 2 May 1997.  */
848 /* #include <malloc.h>  */
849  #pragma alloca
850 #define YYSTACK_USE_ALLOCA
851 #else /* not MSDOS, or __TURBOC__, or _AIX */
852 #if 0
853 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
854                  and on HPUX 10.  Eventually we can turn this on.  */
855 #define YYSTACK_USE_ALLOCA
856 #define alloca __builtin_alloca
857 #endif /* __hpux */
858 #endif
859 #endif /* not _AIX */
860 #endif /* not MSDOS, or __TURBOC__ */
861 #endif /* not sparc */
862 #endif /* not GNU C */
863 #endif /* alloca not defined */
864 #endif /* YYSTACK_USE_ALLOCA not defined */
865
866 #ifdef YYSTACK_USE_ALLOCA
867 #define YYSTACK_ALLOC alloca
868 #else
869 #define YYSTACK_ALLOC malloc
870 #endif
871
872 /* Note: there must be only one dollar sign in this file.
873    It is replaced by the list of actions, each action
874    as one case of the switch.  */
875
876 #define yyerrok         (yyerrstatus = 0)
877 #define yyclearin       (yychar = YYEMPTY)
878 #define YYEMPTY         -2
879 #define YYEOF           0
880 #define YYACCEPT        goto yyacceptlab
881 #define YYABORT         goto yyabortlab
882 #define YYERROR         goto yyerrlab1
883 /* Like YYERROR except do call yyerror.
884    This remains here temporarily to ease the
885    transition to the new meaning of YYERROR, for GCC.
886    Once GCC version 2 has supplanted version 1, this can go.  */
887 #define YYFAIL          goto yyerrlab
888 #define YYRECOVERING()  (!!yyerrstatus)
889 #define YYBACKUP(token, value) \
890 do                                                              \
891   if (yychar == YYEMPTY && yylen == 1)                          \
892     { yychar = (token), yylval = (value);                       \
893       yychar1 = YYTRANSLATE (yychar);                           \
894       YYPOPSTACK;                                               \
895       goto yybackup;                                            \
896     }                                                           \
897   else                                                          \
898     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
899 while (0)
900
901 #define YYTERROR        1
902 #define YYERRCODE       256
903
904 #ifndef YYPURE
905 #define YYLEX           yylex()
906 #endif
907
908 #ifdef YYPURE
909 #ifdef YYLSP_NEEDED
910 #ifdef YYLEX_PARAM
911 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
912 #else
913 #define YYLEX           yylex(&yylval, &yylloc)
914 #endif
915 #else /* not YYLSP_NEEDED */
916 #ifdef YYLEX_PARAM
917 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
918 #else
919 #define YYLEX           yylex(&yylval)
920 #endif
921 #endif /* not YYLSP_NEEDED */
922 #endif
923
924 /* If nonreentrant, generate the variables here */
925
926 #ifndef YYPURE
927
928 int     yychar;                 /*  the lookahead symbol                */
929 YYSTYPE yylval;                 /*  the semantic value of the           */
930                                 /*  lookahead symbol                    */
931
932 #ifdef YYLSP_NEEDED
933 YYLTYPE yylloc;                 /*  location data for the lookahead     */
934                                 /*  symbol                              */
935 #endif
936
937 int yynerrs;                    /*  number of parse errors so far       */
938 #endif  /* not YYPURE */
939
940 #if YYDEBUG != 0
941 int yydebug;                    /*  nonzero means print parse trace     */
942 /* Since this is uninitialized, it does not stop multiple parsers
943    from coexisting.  */
944 #endif
945
946 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
947
948 #ifndef YYINITDEPTH
949 #define YYINITDEPTH 200
950 #endif
951
952 /*  YYMAXDEPTH is the maximum size the stacks can grow to
953     (effective only if the built-in stack extension method is used).  */
954
955 #if YYMAXDEPTH == 0
956 #undef YYMAXDEPTH
957 #endif
958
959 #ifndef YYMAXDEPTH
960 #define YYMAXDEPTH 10000
961 #endif
962 \f
963 /* Define __yy_memcpy.  Note that the size argument
964    should be passed with type unsigned int, because that is what the non-GCC
965    definitions require.  With GCC, __builtin_memcpy takes an arg
966    of type size_t, but it can handle unsigned int.  */
967
968 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
969 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
970 #else                           /* not GNU C or C++ */
971 #ifndef __cplusplus
972
973 /* This is the most reliable way to avoid incompatibilities
974    in available built-in functions on various systems.  */
975 static void
976 __yy_memcpy (to, from, count)
977      char *to;
978      char *from;
979      unsigned int count;
980 {
981   register char *f = from;
982   register char *t = to;
983   register int i = count;
984
985   while (i-- > 0)
986     *t++ = *f++;
987 }
988
989 #else /* __cplusplus */
990
991 /* This is the most reliable way to avoid incompatibilities
992    in available built-in functions on various systems.  */
993 static void
994 __yy_memcpy (char *to, char *from, unsigned int count)
995 {
996   register char *t = to;
997   register char *f = from;
998   register int i = count;
999
1000   while (i-- > 0)
1001     *t++ = *f++;
1002 }
1003
1004 #endif
1005 #endif
1006 \f
1007 #line 217 "/usr/share/bison.simple"
1008
1009 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
1010    into yyparse.  The argument should have type void *.
1011    It should actually point to an object.
1012    Grammar actions can access the variable by casting it
1013    to the proper pointer type.  */
1014
1015 #ifdef YYPARSE_PARAM
1016 #ifdef __cplusplus
1017 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
1018 #define YYPARSE_PARAM_DECL
1019 #else /* not __cplusplus */
1020 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
1021 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
1022 #endif /* not __cplusplus */
1023 #else /* not YYPARSE_PARAM */
1024 #define YYPARSE_PARAM_ARG
1025 #define YYPARSE_PARAM_DECL
1026 #endif /* not YYPARSE_PARAM */
1027
1028 /* Prevent warning if -Wstrict-prototypes.  */
1029 #ifdef __GNUC__
1030 #ifdef YYPARSE_PARAM
1031 int yyparse (void *);
1032 #else
1033 int yyparse (void);
1034 #endif
1035 #endif
1036
1037 int
1038 yyparse(YYPARSE_PARAM_ARG)
1039      YYPARSE_PARAM_DECL
1040 {
1041   register int yystate;
1042   register int yyn;
1043   register short *yyssp;
1044   register YYSTYPE *yyvsp;
1045   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
1046   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
1047
1048   short yyssa[YYINITDEPTH];     /*  the state stack                     */
1049   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
1050
1051   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
1052   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
1053
1054 #ifdef YYLSP_NEEDED
1055   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
1056   YYLTYPE *yyls = yylsa;
1057   YYLTYPE *yylsp;
1058
1059 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
1060 #else
1061 #define YYPOPSTACK   (yyvsp--, yyssp--)
1062 #endif
1063
1064   int yystacksize = YYINITDEPTH;
1065   int yyfree_stacks = 0;
1066
1067 #ifdef YYPURE
1068   int yychar;
1069   YYSTYPE yylval;
1070   int yynerrs;
1071 #ifdef YYLSP_NEEDED
1072   YYLTYPE yylloc;
1073 #endif
1074 #endif
1075
1076   YYSTYPE yyval;                /*  the variable used to return         */
1077                                 /*  semantic values from the action     */
1078                                 /*  routines                            */
1079
1080   int yylen;
1081
1082 #if YYDEBUG != 0
1083   if (yydebug)
1084     fprintf(stderr, "Starting parse\n");
1085 #endif
1086
1087   yystate = 0;
1088   yyerrstatus = 0;
1089   yynerrs = 0;
1090   yychar = YYEMPTY;             /* Cause a token to be read.  */
1091
1092   /* Initialize stack pointers.
1093      Waste one element of value and location stack
1094      so that they stay on the same level as the state stack.
1095      The wasted elements are never initialized.  */
1096
1097   yyssp = yyss - 1;
1098   yyvsp = yyvs;
1099 #ifdef YYLSP_NEEDED
1100   yylsp = yyls;
1101 #endif
1102
1103 /* Push a new state, which is found in  yystate  .  */
1104 /* In all cases, when you get here, the value and location stacks
1105    have just been pushed. so pushing a state here evens the stacks.  */
1106 yynewstate:
1107
1108   *++yyssp = yystate;
1109
1110   if (yyssp >= yyss + yystacksize - 1)
1111     {
1112       /* Give user a chance to reallocate the stack */
1113       /* Use copies of these so that the &'s don't force the real ones into memory. */
1114       YYSTYPE *yyvs1 = yyvs;
1115       short *yyss1 = yyss;
1116 #ifdef YYLSP_NEEDED
1117       YYLTYPE *yyls1 = yyls;
1118 #endif
1119
1120       /* Get the current used size of the three stacks, in elements.  */
1121       int size = yyssp - yyss + 1;
1122
1123 #ifdef yyoverflow
1124       /* Each stack pointer address is followed by the size of
1125          the data in use in that stack, in bytes.  */
1126 #ifdef YYLSP_NEEDED
1127       /* This used to be a conditional around just the two extra args,
1128          but that might be undefined if yyoverflow is a macro.  */
1129       yyoverflow("parser stack overflow",
1130                  &yyss1, size * sizeof (*yyssp),
1131                  &yyvs1, size * sizeof (*yyvsp),
1132                  &yyls1, size * sizeof (*yylsp),
1133                  &yystacksize);
1134 #else
1135       yyoverflow("parser stack overflow",
1136                  &yyss1, size * sizeof (*yyssp),
1137                  &yyvs1, size * sizeof (*yyvsp),
1138                  &yystacksize);
1139 #endif
1140
1141       yyss = yyss1; yyvs = yyvs1;
1142 #ifdef YYLSP_NEEDED
1143       yyls = yyls1;
1144 #endif
1145 #else /* no yyoverflow */
1146       /* Extend the stack our own way.  */
1147       if (yystacksize >= YYMAXDEPTH)
1148         {
1149           yyerror("parser stack overflow");
1150           if (yyfree_stacks)
1151             {
1152               free (yyss);
1153               free (yyvs);
1154 #ifdef YYLSP_NEEDED
1155               free (yyls);
1156 #endif
1157             }
1158           return 2;
1159         }
1160       yystacksize *= 2;
1161       if (yystacksize > YYMAXDEPTH)
1162         yystacksize = YYMAXDEPTH;
1163 #ifndef YYSTACK_USE_ALLOCA
1164       yyfree_stacks = 1;
1165 #endif
1166       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
1167       __yy_memcpy ((char *)yyss, (char *)yyss1,
1168                    size * (unsigned int) sizeof (*yyssp));
1169       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
1170       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
1171                    size * (unsigned int) sizeof (*yyvsp));
1172 #ifdef YYLSP_NEEDED
1173       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
1174       __yy_memcpy ((char *)yyls, (char *)yyls1,
1175                    size * (unsigned int) sizeof (*yylsp));
1176 #endif
1177 #endif /* no yyoverflow */
1178
1179       yyssp = yyss + size - 1;
1180       yyvsp = yyvs + size - 1;
1181 #ifdef YYLSP_NEEDED
1182       yylsp = yyls + size - 1;
1183 #endif
1184
1185 #if YYDEBUG != 0
1186       if (yydebug)
1187         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
1188 #endif
1189
1190       if (yyssp >= yyss + yystacksize - 1)
1191         YYABORT;
1192     }
1193
1194 #if YYDEBUG != 0
1195   if (yydebug)
1196     fprintf(stderr, "Entering state %d\n", yystate);
1197 #endif
1198
1199   goto yybackup;
1200  yybackup:
1201
1202 /* Do appropriate processing given the current state.  */
1203 /* Read a lookahead token if we need one and don't already have one.  */
1204 /* yyresume: */
1205
1206   /* First try to decide what to do without reference to lookahead token.  */
1207
1208   yyn = yypact[yystate];
1209   if (yyn == YYFLAG)
1210     goto yydefault;
1211
1212   /* Not known => get a lookahead token if don't already have one.  */
1213
1214   /* yychar is either YYEMPTY or YYEOF
1215      or a valid token in external form.  */
1216
1217   if (yychar == YYEMPTY)
1218     {
1219 #if YYDEBUG != 0
1220       if (yydebug)
1221         fprintf(stderr, "Reading a token: ");
1222 #endif
1223       yychar = YYLEX;
1224     }
1225
1226   /* Convert token to internal form (in yychar1) for indexing tables with */
1227
1228   if (yychar <= 0)              /* This means end of input. */
1229     {
1230       yychar1 = 0;
1231       yychar = YYEOF;           /* Don't call YYLEX any more */
1232
1233 #if YYDEBUG != 0
1234       if (yydebug)
1235         fprintf(stderr, "Now at end of input.\n");
1236 #endif
1237     }
1238   else
1239     {
1240       yychar1 = YYTRANSLATE(yychar);
1241
1242 #if YYDEBUG != 0
1243       if (yydebug)
1244         {
1245           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1246           /* Give the individual parser a way to print the precise meaning
1247              of a token, for further debugging info.  */
1248 #ifdef YYPRINT
1249           YYPRINT (stderr, yychar, yylval);
1250 #endif
1251           fprintf (stderr, ")\n");
1252         }
1253 #endif
1254     }
1255
1256   yyn += yychar1;
1257   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1258     goto yydefault;
1259
1260   yyn = yytable[yyn];
1261
1262   /* yyn is what to do for this token type in this state.
1263      Negative => reduce, -yyn is rule number.
1264      Positive => shift, yyn is new state.
1265        New state is final state => don't bother to shift,
1266        just return success.
1267      0, or most negative number => error.  */
1268
1269   if (yyn < 0)
1270     {
1271       if (yyn == YYFLAG)
1272         goto yyerrlab;
1273       yyn = -yyn;
1274       goto yyreduce;
1275     }
1276   else if (yyn == 0)
1277     goto yyerrlab;
1278
1279   if (yyn == YYFINAL)
1280     YYACCEPT;
1281
1282   /* Shift the lookahead token.  */
1283
1284 #if YYDEBUG != 0
1285   if (yydebug)
1286     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1287 #endif
1288
1289   /* Discard the token being shifted unless it is eof.  */
1290   if (yychar != YYEOF)
1291     yychar = YYEMPTY;
1292
1293   *++yyvsp = yylval;
1294 #ifdef YYLSP_NEEDED
1295   *++yylsp = yylloc;
1296 #endif
1297
1298   /* count tokens shifted since error; after three, turn off error status.  */
1299   if (yyerrstatus) yyerrstatus--;
1300
1301   yystate = yyn;
1302   goto yynewstate;
1303
1304 /* Do the default action for the current state.  */
1305 yydefault:
1306
1307   yyn = yydefact[yystate];
1308   if (yyn == 0)
1309     goto yyerrlab;
1310
1311 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
1312 yyreduce:
1313   yylen = yyr2[yyn];
1314   if (yylen > 0)
1315     yyval = yyvsp[1-yylen]; /* implement default value of the action */
1316
1317 #if YYDEBUG != 0
1318   if (yydebug)
1319     {
1320       int i;
1321
1322       fprintf (stderr, "Reducing via rule %d (line %d), ",
1323                yyn, yyrline[yyn]);
1324
1325       /* Print the symbols being reduced, and their result.  */
1326       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1327         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1328       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1329     }
1330 #endif
1331
1332
1333   switch (yyn) {
1334
1335 case 1:
1336 #line 170 "grammar.y"
1337 { yyval.node = new NullNode(); ;
1338     break;}
1339 case 2:
1340 #line 171 "grammar.y"
1341 { yyval.node = new BooleanNode(true); ;
1342     break;}
1343 case 3:
1344 #line 172 "grammar.y"
1345 { yyval.node = new BooleanNode(false); ;
1346     break;}
1347 case 4:
1348 #line 173 "grammar.y"
1349 { yyval.node = new NumberNode(yyvsp[0].dval); ;
1350     break;}
1351 case 5:
1352 #line 174 "grammar.y"
1353 { yyval.node = new StringNode(yyvsp[0].ustr); ;
1354     break;}
1355 case 6:
1356 #line 175 "grammar.y"
1357 { Lexer *l = Lexer::curr();
1358                                      if (!l->scanRegExp()) YYABORT;
1359                                      yyval.node = new RegExpNode(l->pattern,l->flags);;
1360     break;}
1361 case 7:
1362 #line 179 "grammar.y"
1363 { Lexer *l = Lexer::curr();
1364                                      if (!l->scanRegExp()) YYABORT;
1365                                      yyval.node = new RegExpNode(UString('=')+l->pattern,l->flags);;
1366     break;}
1367 case 8:
1368 #line 185 "grammar.y"
1369 { yyval.node = new ThisNode(); ;
1370     break;}
1371 case 9:
1372 #line 186 "grammar.y"
1373 { yyval.node = new ResolveNode(*yyvsp[0].ident); ;
1374     break;}
1375 case 12:
1376 #line 189 "grammar.y"
1377 { yyval.node = new GroupNode(yyvsp[-1].node); ;
1378     break;}
1379 case 13:
1380 #line 190 "grammar.y"
1381 { yyval.node = new ObjectLiteralNode(); ;
1382     break;}
1383 case 14:
1384 #line 191 "grammar.y"
1385 { yyval.node = new ObjectLiteralNode(yyvsp[-1].plist); ;
1386     break;}
1387 case 15:
1388 #line 195 "grammar.y"
1389 { yyval.node = new ArrayNode(yyvsp[-1].ival); ;
1390     break;}
1391 case 16:
1392 #line 196 "grammar.y"
1393 { yyval.node = new ArrayNode(yyvsp[-1].elm); ;
1394     break;}
1395 case 17:
1396 #line 197 "grammar.y"
1397 { yyval.node = new ArrayNode(yyvsp[-1].ival, yyvsp[-3].elm); ;
1398     break;}
1399 case 18:
1400 #line 201 "grammar.y"
1401 { yyval.elm = new ElementNode(yyvsp[-1].ival, yyvsp[0].node); ;
1402     break;}
1403 case 19:
1404 #line 203 "grammar.y"
1405 { yyval.elm = new ElementNode(yyvsp[-3].elm, yyvsp[-1].ival, yyvsp[0].node); ;
1406     break;}
1407 case 20:
1408 #line 207 "grammar.y"
1409 { yyval.ival = 0; ;
1410     break;}
1411 case 22:
1412 #line 212 "grammar.y"
1413 { yyval.ival = 1; ;
1414     break;}
1415 case 23:
1416 #line 213 "grammar.y"
1417 { yyval.ival = yyvsp[-1].ival + 1; ;
1418     break;}
1419 case 24:
1420 #line 217 "grammar.y"
1421 { yyval.plist = new PropertyValueNode(yyvsp[-2].pnode, yyvsp[0].node); ;
1422     break;}
1423 case 25:
1424 #line 219 "grammar.y"
1425 { yyval.plist = new PropertyValueNode(yyvsp[-2].pnode, yyvsp[0].node, yyvsp[-4].plist); ;
1426     break;}
1427 case 26:
1428 #line 223 "grammar.y"
1429 { yyval.pnode = new PropertyNode(*yyvsp[0].ident); ;
1430     break;}
1431 case 27:
1432 #line 224 "grammar.y"
1433 { yyval.pnode = new PropertyNode(Identifier(*yyvsp[0].ustr)); ;
1434     break;}
1435 case 28:
1436 #line 225 "grammar.y"
1437 { yyval.pnode = new PropertyNode(yyvsp[0].dval); ;
1438     break;}
1439 case 31:
1440 #line 231 "grammar.y"
1441 { yyval.node = new AccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ;
1442     break;}
1443 case 32:
1444 #line 232 "grammar.y"
1445 { yyval.node = new AccessorNode2(yyvsp[-2].node, *yyvsp[0].ident); ;
1446     break;}
1447 case 33:
1448 #line 233 "grammar.y"
1449 { yyval.node = new NewExprNode(yyvsp[-1].node, yyvsp[0].args); ;
1450     break;}
1451 case 35:
1452 #line 238 "grammar.y"
1453 { yyval.node = new NewExprNode(yyvsp[0].node); ;
1454     break;}
1455 case 36:
1456 #line 242 "grammar.y"
1457 { yyval.node = new FunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ;
1458     break;}
1459 case 37:
1460 #line 243 "grammar.y"
1461 { yyval.node = new FunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ;
1462     break;}
1463 case 38:
1464 #line 244 "grammar.y"
1465 { yyval.node = new AccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ;
1466     break;}
1467 case 39:
1468 #line 245 "grammar.y"
1469 { yyval.node = new AccessorNode2(yyvsp[-2].node, *yyvsp[0].ident); ;
1470     break;}
1471 case 40:
1472 #line 249 "grammar.y"
1473 { yyval.args = new ArgumentsNode(); ;
1474     break;}
1475 case 41:
1476 #line 250 "grammar.y"
1477 { yyval.args = new ArgumentsNode(yyvsp[-1].alist); ;
1478     break;}
1479 case 42:
1480 #line 254 "grammar.y"
1481 { yyval.alist = new ArgumentListNode(yyvsp[0].node); ;
1482     break;}
1483 case 43:
1484 #line 255 "grammar.y"
1485 { yyval.alist = new ArgumentListNode(yyvsp[-2].alist, yyvsp[0].node); ;
1486     break;}
1487 case 47:
1488 #line 265 "grammar.y"
1489 { yyval.node = new PostfixNode(yyvsp[-1].node, OpPlusPlus); ;
1490     break;}
1491 case 48:
1492 #line 266 "grammar.y"
1493 { yyval.node = new PostfixNode(yyvsp[-1].node, OpMinusMinus); ;
1494     break;}
1495 case 50:
1496 #line 271 "grammar.y"
1497 { yyval.node = new DeleteNode(yyvsp[0].node); ;
1498     break;}
1499 case 51:
1500 #line 272 "grammar.y"
1501 { yyval.node = new VoidNode(yyvsp[0].node); ;
1502     break;}
1503 case 52:
1504 #line 273 "grammar.y"
1505 { yyval.node = new TypeOfNode(yyvsp[0].node); ;
1506     break;}
1507 case 53:
1508 #line 274 "grammar.y"
1509 { yyval.node = new PrefixNode(OpPlusPlus, yyvsp[0].node); ;
1510     break;}
1511 case 54:
1512 #line 275 "grammar.y"
1513 { yyval.node = new PrefixNode(OpPlusPlus, yyvsp[0].node); ;
1514     break;}
1515 case 55:
1516 #line 276 "grammar.y"
1517 { yyval.node = new PrefixNode(OpMinusMinus, yyvsp[0].node); ;
1518     break;}
1519 case 56:
1520 #line 277 "grammar.y"
1521 { yyval.node = new PrefixNode(OpMinusMinus, yyvsp[0].node); ;
1522     break;}
1523 case 57:
1524 #line 278 "grammar.y"
1525 { yyval.node = new UnaryPlusNode(yyvsp[0].node); ;
1526     break;}
1527 case 58:
1528 #line 279 "grammar.y"
1529 { yyval.node = new NegateNode(yyvsp[0].node); ;
1530     break;}
1531 case 59:
1532 #line 280 "grammar.y"
1533 { yyval.node = new BitwiseNotNode(yyvsp[0].node); ;
1534     break;}
1535 case 60:
1536 #line 281 "grammar.y"
1537 { yyval.node = new LogicalNotNode(yyvsp[0].node); ;
1538     break;}
1539 case 62:
1540 #line 286 "grammar.y"
1541 { yyval.node = new MultNode(yyvsp[-2].node, yyvsp[0].node, '*'); ;
1542     break;}
1543 case 63:
1544 #line 287 "grammar.y"
1545 { yyval.node = new MultNode(yyvsp[-2].node, yyvsp[0].node, '/'); ;
1546     break;}
1547 case 64:
1548 #line 288 "grammar.y"
1549 { yyval.node = new MultNode(yyvsp[-2].node,yyvsp[0].node,'%'); ;
1550     break;}
1551 case 66:
1552 #line 293 "grammar.y"
1553 { yyval.node = new AddNode(yyvsp[-2].node, yyvsp[0].node, '+'); ;
1554     break;}
1555 case 67:
1556 #line 294 "grammar.y"
1557 { yyval.node = new AddNode(yyvsp[-2].node, yyvsp[0].node, '-'); ;
1558     break;}
1559 case 69:
1560 #line 299 "grammar.y"
1561 { yyval.node = new ShiftNode(yyvsp[-2].node, OpLShift, yyvsp[0].node); ;
1562     break;}
1563 case 70:
1564 #line 300 "grammar.y"
1565 { yyval.node = new ShiftNode(yyvsp[-2].node, OpRShift, yyvsp[0].node); ;
1566     break;}
1567 case 71:
1568 #line 301 "grammar.y"
1569 { yyval.node = new ShiftNode(yyvsp[-2].node, OpURShift, yyvsp[0].node); ;
1570     break;}
1571 case 73:
1572 #line 307 "grammar.y"
1573 { yyval.node = new RelationalNode(yyvsp[-2].node, OpLess, yyvsp[0].node); ;
1574     break;}
1575 case 74:
1576 #line 309 "grammar.y"
1577 { yyval.node = new RelationalNode(yyvsp[-2].node, OpGreater, yyvsp[0].node); ;
1578     break;}
1579 case 75:
1580 #line 311 "grammar.y"
1581 { yyval.node = new RelationalNode(yyvsp[-2].node, OpLessEq, yyvsp[0].node); ;
1582     break;}
1583 case 76:
1584 #line 313 "grammar.y"
1585 { yyval.node = new RelationalNode(yyvsp[-2].node, OpGreaterEq, yyvsp[0].node); ;
1586     break;}
1587 case 77:
1588 #line 315 "grammar.y"
1589 { yyval.node = new RelationalNode(yyvsp[-2].node, OpInstanceOf, yyvsp[0].node); ;
1590     break;}
1591 case 78:
1592 #line 317 "grammar.y"
1593 { yyval.node = new RelationalNode(yyvsp[-2].node, OpIn, yyvsp[0].node); ;
1594     break;}
1595 case 80:
1596 #line 322 "grammar.y"
1597 { yyval.node = new EqualNode(yyvsp[-2].node, OpEqEq, yyvsp[0].node); ;
1598     break;}
1599 case 81:
1600 #line 323 "grammar.y"
1601 { yyval.node = new EqualNode(yyvsp[-2].node, OpNotEq, yyvsp[0].node); ;
1602     break;}
1603 case 82:
1604 #line 324 "grammar.y"
1605 { yyval.node = new EqualNode(yyvsp[-2].node, OpStrEq, yyvsp[0].node); ;
1606     break;}
1607 case 83:
1608 #line 325 "grammar.y"
1609 { yyval.node = new EqualNode(yyvsp[-2].node, OpStrNEq, yyvsp[0].node);;
1610     break;}
1611 case 85:
1612 #line 330 "grammar.y"
1613 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitAnd, yyvsp[0].node); ;
1614     break;}
1615 case 87:
1616 #line 335 "grammar.y"
1617 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitXOr, yyvsp[0].node); ;
1618     break;}
1619 case 89:
1620 #line 340 "grammar.y"
1621 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitOr, yyvsp[0].node); ;
1622     break;}
1623 case 91:
1624 #line 346 "grammar.y"
1625 { yyval.node = new BinaryLogicalNode(yyvsp[-2].node, OpAnd, yyvsp[0].node); ;
1626     break;}
1627 case 93:
1628 #line 352 "grammar.y"
1629 { yyval.node = new BinaryLogicalNode(yyvsp[-2].node, OpOr, yyvsp[0].node); ;
1630     break;}
1631 case 95:
1632 #line 358 "grammar.y"
1633 { yyval.node = new ConditionalNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ;
1634     break;}
1635 case 97:
1636 #line 364 "grammar.y"
1637 { yyval.node = new AssignNode(yyvsp[-2].node, yyvsp[-1].op, yyvsp[0].node);;
1638     break;}
1639 case 98:
1640 #line 368 "grammar.y"
1641 { yyval.op = OpEqual; ;
1642     break;}
1643 case 99:
1644 #line 369 "grammar.y"
1645 { yyval.op = OpPlusEq; ;
1646     break;}
1647 case 100:
1648 #line 370 "grammar.y"
1649 { yyval.op = OpMinusEq; ;
1650     break;}
1651 case 101:
1652 #line 371 "grammar.y"
1653 { yyval.op = OpMultEq; ;
1654     break;}
1655 case 102:
1656 #line 372 "grammar.y"
1657 { yyval.op = OpDivEq; ;
1658     break;}
1659 case 103:
1660 #line 373 "grammar.y"
1661 { yyval.op = OpLShift; ;
1662     break;}
1663 case 104:
1664 #line 374 "grammar.y"
1665 { yyval.op = OpRShift; ;
1666     break;}
1667 case 105:
1668 #line 375 "grammar.y"
1669 { yyval.op = OpURShift; ;
1670     break;}
1671 case 106:
1672 #line 376 "grammar.y"
1673 { yyval.op = OpAndEq; ;
1674     break;}
1675 case 107:
1676 #line 377 "grammar.y"
1677 { yyval.op = OpXOrEq; ;
1678     break;}
1679 case 108:
1680 #line 378 "grammar.y"
1681 { yyval.op = OpOrEq; ;
1682     break;}
1683 case 109:
1684 #line 379 "grammar.y"
1685 { yyval.op = OpModEq; ;
1686     break;}
1687 case 111:
1688 #line 384 "grammar.y"
1689 { yyval.node = new CommaNode(yyvsp[-2].node, yyvsp[0].node); ;
1690     break;}
1691 case 126:
1692 #line 405 "grammar.y"
1693 { yyval.stat = new BlockNode(0); DBG(yyval.stat, yylsp[0], yylsp[0]); ;
1694     break;}
1695 case 127:
1696 #line 406 "grammar.y"
1697 { yyval.stat = new BlockNode(yyvsp[-1].srcs); DBG(yyval.stat, yylsp[0], yylsp[0]); ;
1698     break;}
1699 case 128:
1700 #line 410 "grammar.y"
1701 { yyval.slist = new StatListNode(yyvsp[0].stat); ;
1702     break;}
1703 case 129:
1704 #line 411 "grammar.y"
1705 { yyval.slist = new StatListNode(yyvsp[-1].slist, yyvsp[0].stat); ;
1706     break;}
1707 case 130:
1708 #line 415 "grammar.y"
1709 { yyval.stat = new VarStatementNode(yyvsp[-1].vlist);
1710                                       DBG(yyval.stat, yylsp[-2], yylsp[0]); ;
1711     break;}
1712 case 131:
1713 #line 417 "grammar.y"
1714 { if (automatic()) {
1715                                           yyval.stat = new VarStatementNode(yyvsp[-1].vlist);
1716                                           DBG(yyval.stat, yylsp[-2], yylsp[-1]);
1717                                         } else {
1718                                           YYABORT;
1719                                         }
1720                                       ;
1721     break;}
1722 case 132:
1723 #line 427 "grammar.y"
1724 { yyval.vlist = new VarDeclListNode(yyvsp[0].decl); ;
1725     break;}
1726 case 133:
1727 #line 429 "grammar.y"
1728 { yyval.vlist = new VarDeclListNode(yyvsp[-2].vlist, yyvsp[0].decl); ;
1729     break;}
1730 case 134:
1731 #line 433 "grammar.y"
1732 { yyval.decl = new VarDeclNode(*yyvsp[0].ident, 0); ;
1733     break;}
1734 case 135:
1735 #line 434 "grammar.y"
1736 { yyval.decl = new VarDeclNode(*yyvsp[-1].ident, yyvsp[0].init); ;
1737     break;}
1738 case 136:
1739 #line 438 "grammar.y"
1740 { yyval.init = new AssignExprNode(yyvsp[0].node); ;
1741     break;}
1742 case 137:
1743 #line 442 "grammar.y"
1744 { yyval.stat = new EmptyStatementNode(); ;
1745     break;}
1746 case 138:
1747 #line 446 "grammar.y"
1748 { yyval.stat = new ExprStatementNode(yyvsp[-1].node);
1749                                      DBG(yyval.stat, yylsp[-1], yylsp[0]); ;
1750     break;}
1751 case 139:
1752 #line 448 "grammar.y"
1753 { if (automatic()) {
1754                                        yyval.stat = new ExprStatementNode(yyvsp[-1].node);
1755                                        DBG(yyval.stat, yylsp[-1], yylsp[-1]);
1756                                      } else
1757                                        YYABORT; ;
1758     break;}
1759 case 140:
1760 #line 456 "grammar.y"
1761 { yyval.stat = new IfNode(yyvsp[-2].node,yyvsp[0].stat,0);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ;
1762     break;}
1763 case 141:
1764 #line 458 "grammar.y"
1765 { yyval.stat = new IfNode(yyvsp[-4].node,yyvsp[-2].stat,yyvsp[0].stat);DBG(yyval.stat,yylsp[-6],yylsp[-3]); ;
1766     break;}
1767 case 142:
1768 #line 462 "grammar.y"
1769 { yyval.stat=new DoWhileNode(yyvsp[-4].stat,yyvsp[-1].node);DBG(yyval.stat,yylsp[-5],yylsp[-3]);;
1770     break;}
1771 case 143:
1772 #line 463 "grammar.y"
1773 { yyval.stat = new WhileNode(yyvsp[-2].node,yyvsp[0].stat);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ;
1774     break;}
1775 case 144:
1776 #line 465 "grammar.y"
1777 { yyval.stat = new ForNode(yyvsp[-6].node,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat);
1778                                      DBG(yyval.stat,yylsp[-8],yylsp[-1]); ;
1779     break;}
1780 case 145:
1781 #line 468 "grammar.y"
1782 { yyval.stat = new ForNode(yyvsp[-6].vlist,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat);
1783                                      DBG(yyval.stat,yylsp[-9],yylsp[-1]); ;
1784     break;}
1785 case 146:
1786 #line 471 "grammar.y"
1787 { yyval.stat = new ForInNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].stat);
1788                                      DBG(yyval.stat,yylsp[-6],yylsp[-1]); ;
1789     break;}
1790 case 147:
1791 #line 474 "grammar.y"
1792 { yyval.stat = new ForInNode(*yyvsp[-4].ident,0,yyvsp[-2].node,yyvsp[0].stat);
1793                                      DBG(yyval.stat,yylsp[-7],yylsp[-1]); ;
1794     break;}
1795 case 148:
1796 #line 477 "grammar.y"
1797 { yyval.stat = new ForInNode(*yyvsp[-5].ident,yyvsp[-4].init,yyvsp[-2].node,yyvsp[0].stat);
1798                                      DBG(yyval.stat,yylsp[-8],yylsp[-1]); ;
1799     break;}
1800 case 149:
1801 #line 482 "grammar.y"
1802 { yyval.node = 0; ;
1803     break;}
1804 case 151:
1805 #line 487 "grammar.y"
1806 { yyval.stat = new ContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
1807     break;}
1808 case 152:
1809 #line 488 "grammar.y"
1810 { if (automatic()) {
1811                                        yyval.stat = new ContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]);
1812                                      } else
1813                                        YYABORT; ;
1814     break;}
1815 case 153:
1816 #line 492 "grammar.y"
1817 { yyval.stat = new ContinueNode(*yyvsp[-1].ident); DBG(yyval.stat,yylsp[-2],yylsp[0]); ;
1818     break;}
1819 case 154:
1820 #line 493 "grammar.y"
1821 { if (automatic()) {
1822                                        yyval.stat = new ContinueNode(*yyvsp[-1].ident);DBG(yyval.stat,yylsp[-2],yylsp[-1]);
1823                                      } else
1824                                        YYABORT; ;
1825     break;}
1826 case 155:
1827 #line 500 "grammar.y"
1828 { yyval.stat = new BreakNode();DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
1829     break;}
1830 case 156:
1831 #line 501 "grammar.y"
1832 { if (automatic()) {
1833                                        yyval.stat = new BreakNode(); DBG(yyval.stat,yylsp[-1],yylsp[-1]);
1834                                      } else
1835                                        YYABORT; ;
1836     break;}
1837 case 157:
1838 #line 505 "grammar.y"
1839 { yyval.stat = new BreakNode(*yyvsp[-1].ident); DBG(yyval.stat,yylsp[-2],yylsp[0]); ;
1840     break;}
1841 case 158:
1842 #line 506 "grammar.y"
1843 { if (automatic()) {
1844                                        yyval.stat = new BreakNode(*yyvsp[-1].ident); DBG(yyval.stat,yylsp[-2],yylsp[-1]);
1845                                      } else
1846                                        YYABORT;
1847                                    ;
1848     break;}
1849 case 159:
1850 #line 514 "grammar.y"
1851 { yyval.stat = new ReturnNode(0); DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
1852     break;}
1853 case 160:
1854 #line 515 "grammar.y"
1855 { if (automatic()) {
1856                                        yyval.stat = new ReturnNode(0); DBG(yyval.stat,yylsp[-1],yylsp[-1]);
1857                                      } else
1858                                        YYABORT; ;
1859     break;}
1860 case 161:
1861 #line 519 "grammar.y"
1862 { yyval.stat = new ReturnNode(yyvsp[-1].node); ;
1863     break;}
1864 case 162:
1865 #line 520 "grammar.y"
1866 { if (automatic())
1867                                        yyval.stat = new ReturnNode(yyvsp[-1].node);
1868                                      else
1869                                        YYABORT; ;
1870     break;}
1871 case 163:
1872 #line 527 "grammar.y"
1873 { yyval.stat = new WithNode(yyvsp[-2].node,yyvsp[0].stat);
1874                                      DBG(yyval.stat, yylsp[-4], yylsp[-1]); ;
1875     break;}
1876 case 164:
1877 #line 532 "grammar.y"
1878 { yyval.stat = new SwitchNode(yyvsp[-2].node, yyvsp[0].cblk);
1879                                      DBG(yyval.stat, yylsp[-4], yylsp[-1]); ;
1880     break;}
1881 case 165:
1882 #line 537 "grammar.y"
1883 { yyval.cblk = new CaseBlockNode(yyvsp[-1].clist, 0, 0); ;
1884     break;}
1885 case 166:
1886 #line 539 "grammar.y"
1887 { yyval.cblk = new CaseBlockNode(yyvsp[-3].clist, yyvsp[-2].ccl, yyvsp[-1].clist); ;
1888     break;}
1889 case 167:
1890 #line 543 "grammar.y"
1891 { yyval.clist = 0; ;
1892     break;}
1893 case 169:
1894 #line 548 "grammar.y"
1895 { yyval.clist = new ClauseListNode(yyvsp[0].ccl); ;
1896     break;}
1897 case 170:
1898 #line 549 "grammar.y"
1899 { yyval.clist = new ClauseListNode(yyvsp[-1].clist, yyvsp[0].ccl); ;
1900     break;}
1901 case 171:
1902 #line 553 "grammar.y"
1903 { yyval.ccl = new CaseClauseNode(yyvsp[-1].node); ;
1904     break;}
1905 case 172:
1906 #line 554 "grammar.y"
1907 { yyval.ccl = new CaseClauseNode(yyvsp[-2].node, yyvsp[0].slist); ;
1908     break;}
1909 case 173:
1910 #line 558 "grammar.y"
1911 { yyval.ccl = new CaseClauseNode(0); ;
1912     break;}
1913 case 174:
1914 #line 559 "grammar.y"
1915 { yyval.ccl = new CaseClauseNode(0, yyvsp[0].slist); ;
1916     break;}
1917 case 175:
1918 #line 563 "grammar.y"
1919 { yyvsp[0].stat->pushLabel(*yyvsp[-2].ident);
1920                                      yyval.stat = new LabelNode(*yyvsp[-2].ident, yyvsp[0].stat); ;
1921     break;}
1922 case 176:
1923 #line 568 "grammar.y"
1924 { yyval.stat = new ThrowNode(yyvsp[-1].node); ;
1925     break;}
1926 case 177:
1927 #line 569 "grammar.y"
1928 { if (automatic()) yyval.stat = new ThrowNode(yyvsp[-1].node); else YYABORT; ;
1929     break;}
1930 case 178:
1931 #line 573 "grammar.y"
1932 { yyval.stat = new TryNode(yyvsp[-1].stat, yyvsp[0].cnode); ;
1933     break;}
1934 case 179:
1935 #line 574 "grammar.y"
1936 { yyval.stat = new TryNode(yyvsp[-1].stat, yyvsp[0].fnode); ;
1937     break;}
1938 case 180:
1939 #line 575 "grammar.y"
1940 { yyval.stat = new TryNode(yyvsp[-2].stat, yyvsp[-1].cnode, yyvsp[0].fnode); ;
1941     break;}
1942 case 181:
1943 #line 579 "grammar.y"
1944 { yyval.cnode = new CatchNode(*yyvsp[-2].ident, yyvsp[0].stat); ;
1945     break;}
1946 case 182:
1947 #line 583 "grammar.y"
1948 { yyval.fnode = new FinallyNode(yyvsp[0].stat); ;
1949     break;}
1950 case 183:
1951 #line 587 "grammar.y"
1952 { yyval.func = new FuncDeclNode(*yyvsp[-3].ident, yyvsp[0].body); ;
1953     break;}
1954 case 184:
1955 #line 589 "grammar.y"
1956 { yyval.func = new FuncDeclNode(*yyvsp[-4].ident, yyvsp[-2].param, yyvsp[0].body); ;
1957     break;}
1958 case 185:
1959 #line 592 "grammar.y"
1960 { yyval.node = new FuncExprNode(yyvsp[0].body); ;
1961     break;}
1962 case 186:
1963 #line 594 "grammar.y"
1964 { yyval.node = new FuncExprNode(yyvsp[-2].param, yyvsp[0].body); ;
1965     break;}
1966 case 187:
1967 #line 599 "grammar.y"
1968 { yyval.param = new ParameterNode(*yyvsp[0].ident); ;
1969     break;}
1970 case 188:
1971 #line 600 "grammar.y"
1972 { yyval.param = new ParameterNode(yyvsp[-2].param, *yyvsp[0].ident); ;
1973     break;}
1974 case 189:
1975 #line 604 "grammar.y"
1976 { yyval.body = new FunctionBodyNode(0);
1977                                      DBG(yyval.body, yylsp[-1], yylsp[0]);;
1978     break;}
1979 case 190:
1980 #line 606 "grammar.y"
1981 { yyval.body = new FunctionBodyNode(yyvsp[-1].srcs);
1982                                      DBG(yyval.body, yylsp[-2], yylsp[0]);;
1983     break;}
1984 case 191:
1985 #line 611 "grammar.y"
1986 { yyval.prog = new ProgramNode(0);
1987                                      Parser::progNode = yyval.prog; ;
1988     break;}
1989 case 192:
1990 #line 613 "grammar.y"
1991 { yyval.prog = new ProgramNode(yyvsp[0].srcs);
1992                                      Parser::progNode = yyval.prog; ;
1993     break;}
1994 case 193:
1995 #line 618 "grammar.y"
1996 { yyval.srcs = new SourceElementsNode(yyvsp[0].stat); ;
1997     break;}
1998 case 194:
1999 #line 619 "grammar.y"
2000 { yyval.srcs = new SourceElementsNode(yyvsp[-1].srcs, yyvsp[0].stat); ;
2001     break;}
2002 case 195:
2003 #line 623 "grammar.y"
2004 { yyval.stat = yyvsp[0].stat; ;
2005     break;}
2006 case 196:
2007 #line 624 "grammar.y"
2008 { yyval.stat = yyvsp[0].func; ;
2009     break;}
2010 }
2011    /* the action file gets copied in in place of this dollarsign */
2012 #line 543 "/usr/share/bison.simple"
2013 \f
2014   yyvsp -= yylen;
2015   yyssp -= yylen;
2016 #ifdef YYLSP_NEEDED
2017   yylsp -= yylen;
2018 #endif
2019
2020 #if YYDEBUG != 0
2021   if (yydebug)
2022     {
2023       short *ssp1 = yyss - 1;
2024       fprintf (stderr, "state stack now");
2025       while (ssp1 != yyssp)
2026         fprintf (stderr, " %d", *++ssp1);
2027       fprintf (stderr, "\n");
2028     }
2029 #endif
2030
2031   *++yyvsp = yyval;
2032
2033 #ifdef YYLSP_NEEDED
2034   yylsp++;
2035   if (yylen == 0)
2036     {
2037       yylsp->first_line = yylloc.first_line;
2038       yylsp->first_column = yylloc.first_column;
2039       yylsp->last_line = (yylsp-1)->last_line;
2040       yylsp->last_column = (yylsp-1)->last_column;
2041       yylsp->text = 0;
2042     }
2043   else
2044     {
2045       yylsp->last_line = (yylsp+yylen-1)->last_line;
2046       yylsp->last_column = (yylsp+yylen-1)->last_column;
2047     }
2048 #endif
2049
2050   /* Now "shift" the result of the reduction.
2051      Determine what state that goes to,
2052      based on the state we popped back to
2053      and the rule number reduced by.  */
2054
2055   yyn = yyr1[yyn];
2056
2057   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
2058   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2059     yystate = yytable[yystate];
2060   else
2061     yystate = yydefgoto[yyn - YYNTBASE];
2062
2063   goto yynewstate;
2064
2065 yyerrlab:   /* here on detecting error */
2066
2067   if (! yyerrstatus)
2068     /* If not already recovering from an error, report this error.  */
2069     {
2070       ++yynerrs;
2071
2072 #ifdef YYERROR_VERBOSE
2073       yyn = yypact[yystate];
2074
2075       if (yyn > YYFLAG && yyn < YYLAST)
2076         {
2077           int size = 0;
2078           char *msg;
2079           int x, count;
2080
2081           count = 0;
2082           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
2083           for (x = (yyn < 0 ? -yyn : 0);
2084                x < (sizeof(yytname) / sizeof(char *)); x++)
2085             if (yycheck[x + yyn] == x)
2086               size += strlen(yytname[x]) + 15, count++;
2087           msg = (char *) malloc(size + 15);
2088           if (msg != 0)
2089             {
2090               strcpy(msg, "parse error");
2091
2092               if (count < 5)
2093                 {
2094                   count = 0;
2095                   for (x = (yyn < 0 ? -yyn : 0);
2096                        x < (sizeof(yytname) / sizeof(char *)); x++)
2097                     if (yycheck[x + yyn] == x)
2098                       {
2099                         strcat(msg, count == 0 ? ", expecting `" : " or `");
2100                         strcat(msg, yytname[x]);
2101                         strcat(msg, "'");
2102                         count++;
2103                       }
2104                 }
2105               yyerror(msg);
2106               free(msg);
2107             }
2108           else
2109             yyerror ("parse error; also virtual memory exceeded");
2110         }
2111       else
2112 #endif /* YYERROR_VERBOSE */
2113         yyerror("parse error");
2114     }
2115
2116   goto yyerrlab1;
2117 yyerrlab1:   /* here on error raised explicitly by an action */
2118
2119   if (yyerrstatus == 3)
2120     {
2121       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
2122
2123       /* return failure if at end of input */
2124       if (yychar == YYEOF)
2125         YYABORT;
2126
2127 #if YYDEBUG != 0
2128       if (yydebug)
2129         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
2130 #endif
2131
2132       yychar = YYEMPTY;
2133     }
2134
2135   /* Else will try to reuse lookahead token
2136      after shifting the error token.  */
2137
2138   yyerrstatus = 3;              /* Each real token shifted decrements this */
2139
2140   goto yyerrhandle;
2141
2142 yyerrdefault:  /* current state does not do anything special for the error token. */
2143
2144 #if 0
2145   /* This is wrong; only states that explicitly want error tokens
2146      should shift them.  */
2147   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
2148   if (yyn) goto yydefault;
2149 #endif
2150
2151 yyerrpop:   /* pop the current state because it cannot handle the error token */
2152
2153   if (yyssp == yyss) YYABORT;
2154   yyvsp--;
2155   yystate = *--yyssp;
2156 #ifdef YYLSP_NEEDED
2157   yylsp--;
2158 #endif
2159
2160 #if YYDEBUG != 0
2161   if (yydebug)
2162     {
2163       short *ssp1 = yyss - 1;
2164       fprintf (stderr, "Error: state stack now");
2165       while (ssp1 != yyssp)
2166         fprintf (stderr, " %d", *++ssp1);
2167       fprintf (stderr, "\n");
2168     }
2169 #endif
2170
2171 yyerrhandle:
2172
2173   yyn = yypact[yystate];
2174   if (yyn == YYFLAG)
2175     goto yyerrdefault;
2176
2177   yyn += YYTERROR;
2178   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
2179     goto yyerrdefault;
2180
2181   yyn = yytable[yyn];
2182   if (yyn < 0)
2183     {
2184       if (yyn == YYFLAG)
2185         goto yyerrpop;
2186       yyn = -yyn;
2187       goto yyreduce;
2188     }
2189   else if (yyn == 0)
2190     goto yyerrpop;
2191
2192   if (yyn == YYFINAL)
2193     YYACCEPT;
2194
2195 #if YYDEBUG != 0
2196   if (yydebug)
2197     fprintf(stderr, "Shifting error token, ");
2198 #endif
2199
2200   *++yyvsp = yylval;
2201 #ifdef YYLSP_NEEDED
2202   *++yylsp = yylloc;
2203 #endif
2204
2205   yystate = yyn;
2206   goto yynewstate;
2207
2208  yyacceptlab:
2209   /* YYACCEPT comes here.  */
2210   if (yyfree_stacks)
2211     {
2212       free (yyss);
2213       free (yyvs);
2214 #ifdef YYLSP_NEEDED
2215       free (yyls);
2216 #endif
2217     }
2218   return 0;
2219
2220  yyabortlab:
2221   /* YYABORT comes here.  */
2222   if (yyfree_stacks)
2223     {
2224       free (yyss);
2225       free (yyvs);
2226 #ifdef YYLSP_NEEDED
2227       free (yyls);
2228 #endif
2229     }
2230   return 1;
2231 }
2232 #line 627 "grammar.y"
2233
2234
2235 int yyerror (const char * /* s */)  /* Called by yyparse on error */
2236 {
2237   // fprintf(stderr, "ERROR: %s at line %d\n",
2238   //      s, KJS::Lexer::curr()->lineNo());
2239   return 1;
2240 }
2241
2242 /* may we automatically insert a semicolon ? */
2243 bool automatic()
2244 {
2245   if (yychar == '}' || yychar == 0)
2246     return true;
2247   else if (Lexer::curr()->prevTerminator())
2248     return true;
2249
2250   return false;
2251 }