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         358
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,   589,
246    595,   598,   604,   611,   616,   622,   624,   628,   631,   635,
247    636,   638,   640,   643,   645
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,    31,   116,   140,     0,    31,
309    116,   141,     0,    31,   116,   140,   141,     0,    32,    62,
310     58,    63,   116,     0,    33,   116,     0,    15,    58,    62,
311     63,   145,     0,    15,    58,    62,   144,    63,   145,     0,
312     15,    62,    63,   145,     0,    15,    62,   144,    63,   145,
313      0,    58,     0,   144,    68,    58,     0,    64,    65,     0,
314     64,   147,    65,     0,     0,   147,     0,   148,     0,   147,
315    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,   571,   573,   574,   577,
340    581,   585,   587,   590,   592,   597,   599,   602,   605,   609,
341    612,   616,   618,   621,   623
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,   139,   139,   139,   140,
392    141,   142,   142,   143,   143,   144,   144,   145,   145,   146,
393    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,     4,     5,
415      2,     5,     6,     4,     5,     1,     3,     2,     3,     0,
416      1,     1,     2,     1,     1
417 };
418
419 static const short yydefact[] = {   190,
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    194,   112,   113,   114,   115,   116,   117,   118,   119,   120,
427    121,   122,   123,   124,   125,   195,    30,   191,   192,   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,   193,   158,   157,     0,    46,   150,     0,    27,    28,
439     26,    13,    33,     0,   135,   131,     0,   130,   154,   153,
440      0,   186,     0,     0,   162,   161,     0,     0,     0,     0,
441      0,   176,   126,     0,     0,   177,   178,   175,    12,    14,
442      0,     0,   127,    16,    20,    15,    18,    23,    40,     0,
443     42,     0,    32,     0,    39,    97,    63,    62,    64,    66,
444     67,    69,    70,    71,    78,    77,    75,    76,    73,    74,
445     80,    81,    82,    83,    85,    87,    89,    91,    93,     0,
446    111,   134,     0,     0,   149,   136,   133,     0,     0,     0,
447    184,     0,     0,     0,     0,     0,     0,     0,     0,   181,
448    179,     0,    24,     0,    41,     0,    31,    38,     0,     0,
449    135,   149,     0,     0,   182,     0,   188,     0,   185,   187,
450    140,     0,   143,   167,   164,   163,     0,     0,    17,    19,
451     43,    95,     0,     0,     0,     0,   149,   183,   189,     0,
452    142,     0,     0,   168,   169,     0,    25,     0,     0,   149,
453    146,     0,   141,     0,     0,   165,   167,   170,   180,   147,
454      0,     0,     0,   171,   173,     0,   148,     0,   144,   128,
455    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,   230,    45,    46,    47,    48,    49,    50,    51,    52,
461     53,    54,    55,    56,    57,    58,    59,   154,    60,    61,
462     62,   351,    63,    90,    91,   195,    64,    65,    66,    67,
463    188,    68,    69,    70,    71,    72,   305,   323,   324,   325,
464    337,    73,    74,    75,   216,   217,    76,    77,   204,   271,
465    356,   124,    79
466 };
467
468 static const short yypact[] = {   779,
469 -32768,-32768,-32768,-32768,-32768,     5,   -28,   111,   -30,     6,
470    -31,   335,  1252,  1252,   -16,-32768,   853,    -5,  1252,     9,
471     57,  1252,   -20,  1252,  1252,-32768,   -21,  1252,  1252,-32768,
472   1252,   409,    -1,  1252,  1252,  1252,  1252,-32768,-32768,-32768,
473 -32768,    42,-32768,    43,   179,-32768,-32768,   -14,    12,   195,
474     82,   118,    72,    85,    93,   151,   -23,-32768,-32768,    11,
475 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
476 -32768,-32768,-32768,-32768,-32768,-32768,-32768,   779,-32768,-32768,
477      7,-32768,   964,   161,-32768,    45,    42,-32768,   136,    17,
478 -32768,-32768,     8,-32768,   198,    24,-32768,-32768,    18,    90,
479 -32768,-32768,  1252,   236,  1252,-32768,  1252,  1252,   -45,   483,
480    219,-32768,-32768,   853,-32768,-32768,    59,   202,   204,   -21,
481    935,   123,   205,   557,-32768,   186,  1036,   197,-32768,-32768,
482 -32768,-32768,  1108,  1252,   217,-32768,  1252,   218,-32768,-32768,
483 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
484 -32768,-32768,-32768,  1252,  1252,  1252,  1252,  1252,  1252,  1252,
485   1252,  1252,  1252,  1252,  1252,  1252,  1252,  1252,  1252,  1252,
486   1252,  1252,  1252,  1252,  1252,  1252,  1252,  1252,-32768,  1252,
487 -32768,-32768,-32768,-32768,   222,    87,   209,   203,-32768,-32768,
488 -32768,-32768,-32768,  1252,-32768,-32768,   -30,-32768,-32768,-32768,
489    105,-32768,   220,   103,-32768,-32768,   113,   223,   115,   116,
490    117,-32768,-32768,   224,   -20,   249,-32768,-32768,-32768,-32768,
491     35,  1252,-32768,-32768,    -1,-32768,-32768,-32768,-32768,   119,
492 -32768,   196,-32768,   200,-32768,-32768,-32768,-32768,-32768,   -14,
493    -14,    12,    12,    12,   195,   195,   195,   195,   195,   195,
494     82,    82,    82,    82,   118,    72,    85,    93,   151,   221,
495 -32768,    -3,   -44,  1252,  1252,-32768,-32768,   220,   126,   631,
496 -32768,   220,   230,   853,  1252,   853,   225,   853,   233,-32768,
497 -32768,   226,-32768,  1180,-32768,  1252,-32768,-32768,  1252,  1252,
498    268,  1252,   127,   210,-32768,   220,-32768,   705,-32768,-32768,
499    270,   157,-32768,   287,-32768,-32768,   234,  1252,-32768,-32768,
500 -32768,-32768,   174,  1252,   214,   853,  1252,-32768,-32768,   853,
501 -32768,  1252,    23,   287,-32768,   -20,-32768,   853,   175,  1252,
502 -32768,   237,-32768,   201,   232,-32768,   287,-32768,-32768,-32768,
503    853,   239,   853,   853,   853,   241,-32768,   853,-32768,-32768,
504    853,   853,-32768,-32768,-32768,   307,   309,-32768
505 };
506
507 static const short yypgoto[] = {-32768,
508 -32768,-32768,-32768,    89,-32768,-32768,    91,   302,   308,-32768,
509    -34,-32768,    41,-32768,     1,   120,    88,   -18,    75,   142,
510    143,   144,   146,   141,-32768,-32768,  -122,-32768,    -9,   -17,
511    -22,   -25,-32768,   138,   128,    67,-32768,-32768,-32768,-32768,
512   -249,-32768,-32768,-32768,-32768,-32768,-32768,    -7,-32768,    13,
513 -32768,-32768,-32768,-32768,-32768,   129,-32768,-32768,   131,  -223,
514 -32768,     2,   -74
515 };
516
517
518 #define YYLAST          1326
519
520
521 static const short yytable[] = {   104,
522    111,    78,    99,   182,   227,    80,    92,   183,   199,   139,
523    231,   179,   109,   101,   102,   294,   177,   196,   205,   106,
524    290,   117,   180,   197,   112,   113,    95,    89,   115,   116,
525     96,   236,   335,    83,   129,   130,   131,   132,   212,   292,
526    189,   190,   315,   110,   295,   103,   155,   114,   299,   182,
527    189,   190,   193,   100,   100,   260,   105,   261,   178,   100,
528    156,   157,    81,    93,   100,   100,   125,   332,   100,   100,
529    107,   266,   318,   187,   100,   100,   100,   100,   180,   194,
530    342,   202,   158,   159,   197,   180,   203,   336,    82,    94,
531    184,   200,   191,   207,   181,   209,   218,   210,   211,   283,
532    198,   206,   191,   133,   133,   163,   164,   134,   137,   192,
533    264,   135,   138,     1,     2,     3,     4,     5,   108,   165,
534    166,   219,     8,   186,   232,    84,   180,   234,   140,   141,
535     16,   140,   141,   142,   143,   144,   145,   146,   147,   148,
536    149,   150,   151,   152,   245,   246,   247,   248,   249,   250,
537    173,   169,   170,   171,   172,   237,   238,   239,   167,   168,
538     26,   310,   202,   311,   174,   272,   312,   268,    85,   153,
539    273,    30,    31,   175,    86,   274,    33,   276,   277,   278,
540    180,   285,   180,   180,   180,   327,   286,   220,   296,   316,
541    221,   176,   280,   273,   180,   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,   194,   321,
544    140,   141,    96,   182,   180,   142,   143,   144,   145,   146,
545    147,   148,   149,   150,   151,   152,   328,   341,   160,   161,
546    162,   180,   180,   251,   252,   253,   254,   242,   243,   244,
547    214,   215,   224,   225,   293,   187,   301,   208,   303,   201,
548    306,   153,   287,   180,   228,   302,   288,   180,   180,   344,
549    -27,   298,   -28,   222,   233,   235,   180,   240,   241,   262,
550    313,   215,   187,   270,   275,   279,   265,   300,   304,   289,
551    307,   314,   320,   317,   308,   322,   326,   330,   331,   343,
552    345,   348,   333,   339,   329,   353,   357,   187,   358,    87,
553    340,   282,   334,   284,   255,    88,   256,   259,   257,   352,
554    187,   258,   263,   347,   267,   349,   350,   350,   291,   346,
555    354,   269,     0,   355,   355,    97,   338,     1,     2,     3,
556      4,     5,     0,     0,   281,     0,     8,     0,     0,    84,
557      0,    13,    14,     0,    16,     0,     0,     0,     0,     0,
558     19,     0,     0,     0,     0,     0,     0,     0,     0,     0,
559      0,     0,     0,     0,     0,     0,    24,    25,     0,     0,
560      0,     0,     0,     0,    26,     0,     0,     0,     0,     0,
561      0,     0,    85,    28,    29,    30,    31,     0,    86,     0,
562     33,     0,     0,     0,     0,    34,    35,    36,    37,     0,
563      0,     1,     2,     3,   118,   119,     6,     0,    98,     7,
564      8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
565     18,     0,     0,     0,    19,    20,    21,     0,    22,    23,
566      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
567     24,    25,     0,     0,     0,     0,     0,     0,    26,     0,
568      0,     0,     0,     0,     0,     0,   120,    28,    29,    30,
569     31,     0,    32,   121,    33,     0,     0,     0,     0,    34,
570     35,    36,    37,     0,     0,     1,     2,     3,     4,     5,
571      6,     0,    38,     7,     8,     9,    10,    11,    12,    13,
572     14,    15,    16,    17,    18,     0,     0,     0,    19,    20,
573     21,     0,    22,    23,     0,     0,     0,     0,     0,     0,
574      0,     0,     0,     0,    24,    25,     0,     0,     0,     0,
575      0,     0,    26,     0,     0,     0,     0,     0,     0,     0,
576     27,    28,    29,    30,    31,     0,    32,   213,    33,     0,
577      0,     0,     0,    34,    35,    36,    37,     0,     0,     1,
578      2,     3,     4,     5,     6,     0,    38,     7,     8,     9,
579     10,    11,    12,    13,    14,    15,    16,    17,    18,     0,
580      0,     0,    19,    20,    21,     0,    22,    23,     0,     0,
581      0,     0,     0,     0,     0,     0,     0,     0,    24,    25,
582      0,     0,     0,     0,     0,     0,    26,     0,     0,     0,
583      0,     0,     0,     0,    27,    28,    29,    30,    31,     0,
584     32,   223,    33,     0,     0,     0,     0,    34,    35,    36,
585     37,     0,     0,     1,     2,     3,     4,     5,     6,     0,
586     38,     7,     8,     9,    10,    11,    12,    13,    14,    15,
587     16,    17,    18,     0,     0,     0,    19,    20,    21,     0,
588     22,    23,     0,     0,     0,     0,     0,     0,     0,     0,
589      0,     0,    24,    25,     0,     0,     0,     0,     0,     0,
590     26,     0,     0,     0,     0,     0,     0,     0,    27,    28,
591     29,    30,    31,     0,    32,   297,    33,     0,     0,     0,
592      0,    34,    35,    36,    37,     0,     0,     1,     2,     3,
593      4,     5,     6,     0,    38,     7,     8,     9,    10,    11,
594     12,    13,    14,    15,    16,    17,    18,     0,     0,     0,
595     19,    20,    21,     0,    22,    23,     0,     0,     0,     0,
596      0,     0,     0,     0,     0,     0,    24,    25,     0,     0,
597      0,     0,     0,     0,    26,     0,     0,     0,     0,     0,
598      0,     0,    27,    28,    29,    30,    31,     0,    32,   319,
599     33,     0,     0,     0,     0,    34,    35,    36,    37,     0,
600      0,     1,     2,     3,     4,     5,     6,     0,    38,     7,
601      8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
602     18,     0,     0,     0,    19,    20,    21,     0,    22,    23,
603      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
604     24,    25,     0,     0,     0,     0,     0,     0,    26,     0,
605      0,     0,     0,     0,     0,     0,    27,    28,    29,    30,
606     31,     0,    32,     0,    33,     0,     0,     0,     0,    34,
607     35,    36,    37,     0,     0,     1,     2,     3,     4,     5,
608      6,     0,    38,     7,     8,     9,    10,    84,    12,    13,
609     14,    15,    16,    17,    18,     0,     0,     0,    19,    20,
610     21,     0,    22,    23,     0,     0,     0,     0,     0,     0,
611      0,     0,     0,     0,    24,    25,     0,     0,     0,     0,
612      0,     0,    26,     0,     0,     0,     0,     0,     0,     0,
613     27,    28,    29,    30,    31,     0,    32,     0,    33,     0,
614      0,     0,     0,    34,    35,    36,    37,     0,     0,     0,
615      0,     0,     0,     0,  -126,     0,    38,  -126,  -126,  -126,
616   -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,
617   -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,     0,     0,
618   -126,  -126,  -126,     0,  -126,  -126,     1,     2,     3,     4,
619      5,     0,     0,     0,     0,     8,   185,     0,    84,     0,
620     13,    14,     0,    16,     0,     0,     0,     0,     0,    19,
621      0,     0,  -126,  -126,  -126,     0,     0,     0,  -126,  -126,
622      0,     0,     0,     0,     0,    24,    25,  -126,  -126,     0,
623      0,     0,     0,    26,     0,     0,     0,     0,     0,     0,
624      0,    85,    28,    29,    30,    31,     0,    86,     0,    33,
625      0,     0,     0,     0,    34,    35,    36,    37,     1,     2,
626      3,     4,     5,     0,     0,     0,     0,     8,     0,     0,
627     84,     0,    13,    14,     0,    16,     0,     0,     0,     0,
628      0,    19,     0,     0,     0,     0,     0,     0,     0,     0,
629      0,     0,     0,     0,     0,     0,     0,    24,    25,     0,
630      0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
631      0,     0,     0,    85,    28,    29,    30,    31,     0,    86,
632      0,    33,   226,     0,     0,     0,    34,    35,    36,    37,
633      1,     2,     3,     4,     5,     0,     0,     0,     0,     8,
634      0,     0,    84,     0,    13,    14,     0,    16,     0,     0,
635      0,     0,     0,    19,     0,     0,     0,     0,     0,     0,
636      0,     0,     0,     0,     0,     0,     0,     0,     0,    24,
637     25,     0,     0,     0,     0,     0,     0,    26,     0,     0,
638      0,     0,     0,     0,     0,    85,    28,    29,    30,    31,
639    229,    86,     0,    33,     0,     0,     0,     0,    34,    35,
640     36,    37,     1,     2,     3,     4,     5,     0,     0,     0,
641      0,     8,     0,     0,    84,     0,    13,    14,     0,    16,
642      0,     0,     0,     0,     0,    19,     0,     0,     0,     0,
643      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
644      0,    24,    25,     0,     0,     0,     0,     0,     0,    26,
645      0,     0,     0,     0,     0,     0,     0,    85,    28,    29,
646     30,    31,     0,    86,     0,    33,   309,     0,     0,     0,
647     34,    35,    36,    37,     1,     2,     3,     4,     5,     0,
648      0,     0,     0,     8,     0,     0,    84,     0,    13,    14,
649      0,    16,     0,     0,     0,     0,     0,    19,     0,     0,
650      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
651      0,     0,     0,    24,    25,     0,     0,     0,     0,     0,
652      0,    26,     0,     0,     0,     0,     0,     0,     0,    85,
653     28,    29,    30,    31,     0,    86,     0,    33,     0,     0,
654      0,     0,    34,    35,    36,    37
655 };
656
657 static const short yycheck[] = {    17,
658     23,     0,    12,    78,   127,     1,     1,     1,     1,    44,
659    133,     1,    22,    13,    14,   265,    40,     1,     1,    19,
660     24,    31,    68,    68,    24,    25,    58,    58,    28,    29,
661     62,   154,    10,    62,    34,    35,    36,    37,    84,    84,
662      6,     7,   292,    64,   268,    62,    61,    69,   272,   124,
663      6,     7,    87,    13,    14,   178,    62,   180,    82,    19,
664     75,    76,    58,    58,    24,    25,    68,   317,    28,    29,
665     62,   194,   296,    83,    34,    35,    36,    37,    68,    83,
666    330,    58,    71,    72,    68,    68,    63,    65,    84,    84,
667     84,    84,    58,   103,    84,   105,   114,   107,   108,   222,
668     84,    84,    58,    62,    62,    24,    25,    66,    66,    65,
669     24,    70,    70,     3,     4,     5,     6,     7,    62,    38,
670     39,    63,    12,    83,   134,    15,    68,   137,    42,    43,
671     20,    42,    43,    47,    48,    49,    50,    51,    52,    53,
672     54,    55,    56,    57,   163,   164,   165,   166,   167,   168,
673     79,    34,    35,    36,    37,   155,   156,   157,    77,    78,
674     50,   284,    58,   286,    80,    63,   289,    63,    58,    83,
675     68,    61,    62,    81,    64,    63,    66,    63,    63,    63,
676     68,    63,    68,    68,    68,   308,    68,    65,    63,    63,
677     68,    41,   215,    68,    68,   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,    83,    63,
680     42,    43,    62,   298,    68,    47,    48,    49,    50,    51,
681     52,    53,    54,    55,    56,    57,    63,    63,    44,    45,
682     46,    68,    68,   169,   170,   171,   172,   160,   161,   162,
683     32,    33,    67,    68,   264,   265,   274,    22,   276,    62,
684    278,    83,    67,    68,    68,   275,    67,    68,    68,    69,
685     69,   270,    69,    69,    58,    58,    68,   158,   159,    58,
686    290,    33,   292,    64,    62,    62,    84,    58,    64,    69,
687     58,    24,    23,    84,    69,     9,    63,    84,   316,    63,
688     69,    63,   320,   326,   314,    65,     0,   317,     0,     8,
689    328,   221,   322,   225,   173,     8,   174,   177,   175,   345,
690    330,   176,   185,   341,   197,   343,   344,   345,   262,   337,
691    348,   201,    -1,   351,   352,     1,   324,     3,     4,     5,
692      6,     7,    -1,    -1,   216,    -1,    12,    -1,    -1,    15,
693     -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,
694     26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
695     -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,
696     -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,
697     -1,    -1,    58,    59,    60,    61,    62,    -1,    64,    -1,
698     66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,    -1,
699     -1,     3,     4,     5,     6,     7,     8,    -1,    84,    11,
700     12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
701     22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,
702     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
703     42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,
704     -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,
705     62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,    71,
706     72,    73,    74,    -1,    -1,     3,     4,     5,     6,     7,
707      8,    -1,    84,    11,    12,    13,    14,    15,    16,    17,
708     18,    19,    20,    21,    22,    -1,    -1,    -1,    26,    27,
709     28,    -1,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
710     -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,
711     -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
712     58,    59,    60,    61,    62,    -1,    64,    65,    66,    -1,
713     -1,    -1,    -1,    71,    72,    73,    74,    -1,    -1,     3,
714      4,     5,     6,     7,     8,    -1,    84,    11,    12,    13,
715     14,    15,    16,    17,    18,    19,    20,    21,    22,    -1,
716     -1,    -1,    26,    27,    28,    -1,    30,    31,    -1,    -1,
717     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,
718     -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,
719     -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,
720     64,    65,    66,    -1,    -1,    -1,    -1,    71,    72,    73,
721     74,    -1,    -1,     3,     4,     5,     6,     7,     8,    -1,
722     84,    11,    12,    13,    14,    15,    16,    17,    18,    19,
723     20,    21,    22,    -1,    -1,    -1,    26,    27,    28,    -1,
724     30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
725     -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,
726     50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,
727     60,    61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,
728     -1,    71,    72,    73,    74,    -1,    -1,     3,     4,     5,
729      6,     7,     8,    -1,    84,    11,    12,    13,    14,    15,
730     16,    17,    18,    19,    20,    21,    22,    -1,    -1,    -1,
731     26,    27,    28,    -1,    30,    31,    -1,    -1,    -1,    -1,
732     -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,
733     -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,
734     -1,    -1,    58,    59,    60,    61,    62,    -1,    64,    65,
735     66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,    -1,
736     -1,     3,     4,     5,     6,     7,     8,    -1,    84,    11,
737     12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
738     22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,
739     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
740     42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,
741     -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,
742     62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,    71,
743     72,    73,    74,    -1,    -1,     3,     4,     5,     6,     7,
744      8,    -1,    84,    11,    12,    13,    14,    15,    16,    17,
745     18,    19,    20,    21,    22,    -1,    -1,    -1,    26,    27,
746     28,    -1,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,
747     -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,
748     -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
749     58,    59,    60,    61,    62,    -1,    64,    -1,    66,    -1,
750     -1,    -1,    -1,    71,    72,    73,    74,    -1,    -1,    -1,
751     -1,    -1,    -1,    -1,     0,    -1,    84,     3,     4,     5,
752      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
753     16,    17,    18,    19,    20,    21,    22,    23,    -1,    -1,
754     26,    27,    28,    -1,    30,    31,     3,     4,     5,     6,
755      7,    -1,    -1,    -1,    -1,    12,    13,    -1,    15,    -1,
756     17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,    26,
757     -1,    -1,    58,    59,    60,    -1,    -1,    -1,    64,    65,
758     -1,    -1,    -1,    -1,    -1,    42,    43,    73,    74,    -1,
759     -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,
760     -1,    58,    59,    60,    61,    62,    -1,    64,    -1,    66,
761     -1,    -1,    -1,    -1,    71,    72,    73,    74,     3,     4,
762      5,     6,     7,    -1,    -1,    -1,    -1,    12,    -1,    -1,
763     15,    -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,
764     -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
765     -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,
766     -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
767     -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,    64,
768     -1,    66,    67,    -1,    -1,    -1,    71,    72,    73,    74,
769      3,     4,     5,     6,     7,    -1,    -1,    -1,    -1,    12,
770     -1,    -1,    15,    -1,    17,    18,    -1,    20,    -1,    -1,
771     -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,
772     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
773     43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,
774     -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,
775     63,    64,    -1,    66,    -1,    -1,    -1,    -1,    71,    72,
776     73,    74,     3,     4,     5,     6,     7,    -1,    -1,    -1,
777     -1,    12,    -1,    -1,    15,    -1,    17,    18,    -1,    20,
778     -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
779     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
780     -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,
781     -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,
782     61,    62,    -1,    64,    -1,    66,    67,    -1,    -1,    -1,
783     71,    72,    73,    74,     3,     4,     5,     6,     7,    -1,
784     -1,    -1,    -1,    12,    -1,    -1,    15,    -1,    17,    18,
785     -1,    20,    -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,
786     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
787     -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,
788     -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
789     59,    60,    61,    62,    -1,    64,    -1,    66,    -1,    -1,
790     -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 572 "grammar.y"
1928 { yyval.stat = new TryNode(yyvsp[-1].stat, yyvsp[0].cnode); ;
1929     break;}
1930 case 178:
1931 #line 573 "grammar.y"
1932 { yyval.stat = new TryNode(yyvsp[-1].stat, yyvsp[0].fnode); ;
1933     break;}
1934 case 179:
1935 #line 574 "grammar.y"
1936 { yyval.stat = new TryNode(yyvsp[-2].stat, yyvsp[-1].cnode, yyvsp[0].fnode); ;
1937     break;}
1938 case 180:
1939 #line 578 "grammar.y"
1940 { yyval.cnode = new CatchNode(*yyvsp[-2].ident, yyvsp[0].stat); ;
1941     break;}
1942 case 181:
1943 #line 582 "grammar.y"
1944 { yyval.fnode = new FinallyNode(yyvsp[0].stat); ;
1945     break;}
1946 case 182:
1947 #line 586 "grammar.y"
1948 { yyval.func = new FuncDeclNode(*yyvsp[-3].ident, yyvsp[0].body); ;
1949     break;}
1950 case 183:
1951 #line 588 "grammar.y"
1952 { yyval.func = new FuncDeclNode(*yyvsp[-4].ident, yyvsp[-2].param, yyvsp[0].body); ;
1953     break;}
1954 case 184:
1955 #line 591 "grammar.y"
1956 { yyval.node = new FuncExprNode(yyvsp[0].body); ;
1957     break;}
1958 case 185:
1959 #line 593 "grammar.y"
1960 { yyval.node = new FuncExprNode(yyvsp[-2].param, yyvsp[0].body); ;
1961     break;}
1962 case 186:
1963 #line 598 "grammar.y"
1964 { yyval.param = new ParameterNode(*yyvsp[0].ident); ;
1965     break;}
1966 case 187:
1967 #line 599 "grammar.y"
1968 { yyval.param = new ParameterNode(yyvsp[-2].param, *yyvsp[0].ident); ;
1969     break;}
1970 case 188:
1971 #line 603 "grammar.y"
1972 { yyval.body = new FunctionBodyNode(0);
1973                                      DBG(yyval.body, yylsp[-1], yylsp[0]);;
1974     break;}
1975 case 189:
1976 #line 605 "grammar.y"
1977 { yyval.body = new FunctionBodyNode(yyvsp[-1].srcs);
1978                                      DBG(yyval.body, yylsp[-2], yylsp[0]);;
1979     break;}
1980 case 190:
1981 #line 610 "grammar.y"
1982 { yyval.prog = new ProgramNode(0);
1983                                      Parser::progNode = yyval.prog; ;
1984     break;}
1985 case 191:
1986 #line 612 "grammar.y"
1987 { yyval.prog = new ProgramNode(yyvsp[0].srcs);
1988                                      Parser::progNode = yyval.prog; ;
1989     break;}
1990 case 192:
1991 #line 617 "grammar.y"
1992 { yyval.srcs = new SourceElementsNode(yyvsp[0].stat); ;
1993     break;}
1994 case 193:
1995 #line 618 "grammar.y"
1996 { yyval.srcs = new SourceElementsNode(yyvsp[-1].srcs, yyvsp[0].stat); ;
1997     break;}
1998 case 194:
1999 #line 622 "grammar.y"
2000 { yyval.stat = yyvsp[0].stat; ;
2001     break;}
2002 case 195:
2003 #line 623 "grammar.y"
2004 { yyval.stat = yyvsp[0].func; ;
2005     break;}
2006 }
2007    /* the action file gets copied in in place of this dollarsign */
2008 #line 543 "/usr/share/bison.simple"
2009 \f
2010   yyvsp -= yylen;
2011   yyssp -= yylen;
2012 #ifdef YYLSP_NEEDED
2013   yylsp -= yylen;
2014 #endif
2015
2016 #if YYDEBUG != 0
2017   if (yydebug)
2018     {
2019       short *ssp1 = yyss - 1;
2020       fprintf (stderr, "state stack now");
2021       while (ssp1 != yyssp)
2022         fprintf (stderr, " %d", *++ssp1);
2023       fprintf (stderr, "\n");
2024     }
2025 #endif
2026
2027   *++yyvsp = yyval;
2028
2029 #ifdef YYLSP_NEEDED
2030   yylsp++;
2031   if (yylen == 0)
2032     {
2033       yylsp->first_line = yylloc.first_line;
2034       yylsp->first_column = yylloc.first_column;
2035       yylsp->last_line = (yylsp-1)->last_line;
2036       yylsp->last_column = (yylsp-1)->last_column;
2037       yylsp->text = 0;
2038     }
2039   else
2040     {
2041       yylsp->last_line = (yylsp+yylen-1)->last_line;
2042       yylsp->last_column = (yylsp+yylen-1)->last_column;
2043     }
2044 #endif
2045
2046   /* Now "shift" the result of the reduction.
2047      Determine what state that goes to,
2048      based on the state we popped back to
2049      and the rule number reduced by.  */
2050
2051   yyn = yyr1[yyn];
2052
2053   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
2054   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2055     yystate = yytable[yystate];
2056   else
2057     yystate = yydefgoto[yyn - YYNTBASE];
2058
2059   goto yynewstate;
2060
2061 yyerrlab:   /* here on detecting error */
2062
2063   if (! yyerrstatus)
2064     /* If not already recovering from an error, report this error.  */
2065     {
2066       ++yynerrs;
2067
2068 #ifdef YYERROR_VERBOSE
2069       yyn = yypact[yystate];
2070
2071       if (yyn > YYFLAG && yyn < YYLAST)
2072         {
2073           int size = 0;
2074           char *msg;
2075           int x, count;
2076
2077           count = 0;
2078           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
2079           for (x = (yyn < 0 ? -yyn : 0);
2080                x < (sizeof(yytname) / sizeof(char *)); x++)
2081             if (yycheck[x + yyn] == x)
2082               size += strlen(yytname[x]) + 15, count++;
2083           msg = (char *) malloc(size + 15);
2084           if (msg != 0)
2085             {
2086               strcpy(msg, "parse error");
2087
2088               if (count < 5)
2089                 {
2090                   count = 0;
2091                   for (x = (yyn < 0 ? -yyn : 0);
2092                        x < (sizeof(yytname) / sizeof(char *)); x++)
2093                     if (yycheck[x + yyn] == x)
2094                       {
2095                         strcat(msg, count == 0 ? ", expecting `" : " or `");
2096                         strcat(msg, yytname[x]);
2097                         strcat(msg, "'");
2098                         count++;
2099                       }
2100                 }
2101               yyerror(msg);
2102               free(msg);
2103             }
2104           else
2105             yyerror ("parse error; also virtual memory exceeded");
2106         }
2107       else
2108 #endif /* YYERROR_VERBOSE */
2109         yyerror("parse error");
2110     }
2111
2112   goto yyerrlab1;
2113 yyerrlab1:   /* here on error raised explicitly by an action */
2114
2115   if (yyerrstatus == 3)
2116     {
2117       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
2118
2119       /* return failure if at end of input */
2120       if (yychar == YYEOF)
2121         YYABORT;
2122
2123 #if YYDEBUG != 0
2124       if (yydebug)
2125         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
2126 #endif
2127
2128       yychar = YYEMPTY;
2129     }
2130
2131   /* Else will try to reuse lookahead token
2132      after shifting the error token.  */
2133
2134   yyerrstatus = 3;              /* Each real token shifted decrements this */
2135
2136   goto yyerrhandle;
2137
2138 yyerrdefault:  /* current state does not do anything special for the error token. */
2139
2140 #if 0
2141   /* This is wrong; only states that explicitly want error tokens
2142      should shift them.  */
2143   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
2144   if (yyn) goto yydefault;
2145 #endif
2146
2147 yyerrpop:   /* pop the current state because it cannot handle the error token */
2148
2149   if (yyssp == yyss) YYABORT;
2150   yyvsp--;
2151   yystate = *--yyssp;
2152 #ifdef YYLSP_NEEDED
2153   yylsp--;
2154 #endif
2155
2156 #if YYDEBUG != 0
2157   if (yydebug)
2158     {
2159       short *ssp1 = yyss - 1;
2160       fprintf (stderr, "Error: state stack now");
2161       while (ssp1 != yyssp)
2162         fprintf (stderr, " %d", *++ssp1);
2163       fprintf (stderr, "\n");
2164     }
2165 #endif
2166
2167 yyerrhandle:
2168
2169   yyn = yypact[yystate];
2170   if (yyn == YYFLAG)
2171     goto yyerrdefault;
2172
2173   yyn += YYTERROR;
2174   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
2175     goto yyerrdefault;
2176
2177   yyn = yytable[yyn];
2178   if (yyn < 0)
2179     {
2180       if (yyn == YYFLAG)
2181         goto yyerrpop;
2182       yyn = -yyn;
2183       goto yyreduce;
2184     }
2185   else if (yyn == 0)
2186     goto yyerrpop;
2187
2188   if (yyn == YYFINAL)
2189     YYACCEPT;
2190
2191 #if YYDEBUG != 0
2192   if (yydebug)
2193     fprintf(stderr, "Shifting error token, ");
2194 #endif
2195
2196   *++yyvsp = yylval;
2197 #ifdef YYLSP_NEEDED
2198   *++yylsp = yylloc;
2199 #endif
2200
2201   yystate = yyn;
2202   goto yynewstate;
2203
2204  yyacceptlab:
2205   /* YYACCEPT comes here.  */
2206   if (yyfree_stacks)
2207     {
2208       free (yyss);
2209       free (yyvs);
2210 #ifdef YYLSP_NEEDED
2211       free (yyls);
2212 #endif
2213     }
2214   return 0;
2215
2216  yyabortlab:
2217   /* YYABORT comes here.  */
2218   if (yyfree_stacks)
2219     {
2220       free (yyss);
2221       free (yyvs);
2222 #ifdef YYLSP_NEEDED
2223       free (yyls);
2224 #endif
2225     }
2226   return 1;
2227 }
2228 #line 626 "grammar.y"
2229
2230
2231 int yyerror (const char * /* s */)  /* Called by yyparse on error */
2232 {
2233   // fprintf(stderr, "ERROR: %s at line %d\n",
2234   //      s, KJS::Lexer::curr()->lineNo());
2235   return 1;
2236 }
2237
2238 /* may we automatically insert a semicolon ? */
2239 bool automatic()
2240 {
2241   if (yychar == '}' || yychar == 0)
2242     return true;
2243   else if (Lexer::curr()->prevTerminator())
2244     return true;
2245
2246   return false;
2247 }