kjs Library API Documentation

grammar.cpp

00001 
00002 /*  A Bison parser, made from grammar.y
00003     by GNU Bison version 1.28  */
00004 
00005 #define YYBISON 1  /* Identify Bison output.  */
00006 
00007 #define yyparse kjsyyparse
00008 #define yylex kjsyylex
00009 #define yyerror kjsyyerror
00010 #define yylval kjsyylval
00011 #define yychar kjsyychar
00012 #define yydebug kjsyydebug
00013 #define yynerrs kjsyynerrs
00014 #define YYLSP_NEEDED
00015 
00016 #define NULLTOKEN       257
00017 #define TRUETOKEN       258
00018 #define FALSETOKEN      259
00019 #define STRING  260
00020 #define NUMBER  261
00021 #define BREAK   262
00022 #define CASE    263
00023 #define DEFAULT 264
00024 #define FOR     265
00025 #define NEW     266
00026 #define VAR     267
00027 #define CONTINUE        268
00028 #define FUNCTION        269
00029 #define RETURN  270
00030 #define VOID    271
00031 #define DELETE  272
00032 #define IF      273
00033 #define THIS    274
00034 #define DO      275
00035 #define WHILE   276
00036 #define ELSE    277
00037 #define IN      278
00038 #define INSTANCEOF      279
00039 #define TYPEOF  280
00040 #define SWITCH  281
00041 #define WITH    282
00042 #define RESERVED        283
00043 #define THROW   284
00044 #define TRY     285
00045 #define CATCH   286
00046 #define FINALLY 287
00047 #define EQEQ    288
00048 #define NE      289
00049 #define STREQ   290
00050 #define STRNEQ  291
00051 #define LE      292
00052 #define GE      293
00053 #define OR      294
00054 #define AND     295
00055 #define PLUSPLUS        296
00056 #define MINUSMINUS      297
00057 #define LSHIFT  298
00058 #define RSHIFT  299
00059 #define URSHIFT 300
00060 #define PLUSEQUAL       301
00061 #define MINUSEQUAL      302
00062 #define MULTEQUAL       303
00063 #define DIVEQUAL        304
00064 #define LSHIFTEQUAL     305
00065 #define RSHIFTEQUAL     306
00066 #define URSHIFTEQUAL    307
00067 #define ANDEQUAL        308
00068 #define MODEQUAL        309
00069 #define XOREQUAL        310
00070 #define OREQUAL 311
00071 #define IDENT   312
00072 #define AUTOPLUSPLUS    313
00073 #define AUTOMINUSMINUS  314
00074 
00075 #line 1 "grammar.y"
00076 
00077 
00078 /*
00079  *  This file is part of the KDE libraries
00080  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
00081  *
00082  *  This library is free software; you can redistribute it and/or
00083  *  modify it under the terms of the GNU Lesser General Public
00084  *  License as published by the Free Software Foundation; either
00085  *  version 2 of the License, or (at your option) any later version.
00086  *
00087  *  This library is distributed in the hope that it will be useful,
00088  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00089  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00090  *  Lesser General Public License for more details.
00091  *
00092  *  You should have received a copy of the GNU Lesser General Public
00093  *  License along with this library; if not, write to the Free Software
00094  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00095  *
00096  *  $Id: grammar.cpp,v 1.32 2002/10/30 11:06:57 faure Exp $
00097  */
00098 
00099 #ifdef HAVE_CONFIG_H
00100 #include <config.h>
00101 #endif
00102 #include <string.h>
00103 #include <stdlib.h>
00104 #include "value.h"
00105 #include "object.h"
00106 #include "types.h"
00107 #include "interpreter.h"
00108 #include "nodes.h"
00109 #include "lexer.h"
00110 #include "internal.h"
00111 
00112 /* default values for bison */
00113 #define YYDEBUG 0
00114 #define YYMAXDEPTH 0
00115 #define YYERROR_VERBOSE
00116 #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::sid); } // location
00117 
00118 extern int yylex();
00119 int yyerror (const char *);
00120 bool automatic();
00121 
00122 using namespace KJS;
00123 
00124 
00125 #line 51 "grammar.y"
00126 typedef union {
00127   int                 ival;
00128   double              dval;
00129   UString             *ustr;
00130   Node                *node;
00131   StatementNode       *stat;
00132   ParameterNode       *param;
00133   FunctionBodyNode    *body;
00134   FuncDeclNode        *func;
00135   ProgramNode         *prog;
00136   AssignExprNode      *init;
00137   SourceElementNode   *src;
00138   SourceElementsNode  *srcs;
00139   StatListNode        *slist;
00140   ArgumentsNode       *args;
00141   ArgumentListNode    *alist;
00142   VarDeclNode         *decl;
00143   VarDeclListNode     *vlist;
00144   CaseBlockNode       *cblk;
00145   ClauseListNode      *clist;
00146   CaseClauseNode      *ccl;
00147   ElementNode         *elm;
00148   ElisionNode         *eli;
00149   Operator            op;
00150 } YYSTYPE;
00151 
00152 #ifndef YYLTYPE
00153 typedef
00154   struct yyltype
00155     {
00156       int timestamp;
00157       int first_line;
00158       int first_column;
00159       int last_line;
00160       int last_column;
00161       char *text;
00162    }
00163   yyltype;
00164 
00165 #define YYLTYPE yyltype
00166 #endif
00167 
00168 #include <stdio.h>
00169 
00170 #ifndef __cplusplus
00171 #ifndef __STDC__
00172 #define const
00173 #endif
00174 #endif
00175 
00176 
00177 
00178 #define YYFINAL         361
00179 #define YYFLAG          -32768
00180 #define YYNTBASE        85
00181 
00182 #define YYTRANSLATE(x) ((unsigned)(x) <= 314 ? yytranslate[x] : 150)
00183 
00184 static const char yytranslate[] = {     0,
00185      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00186      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00187      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00188      2,     2,    74,     2,     2,     2,    76,    79,     2,    62,
00189     63,    75,    71,    68,    72,    70,    61,     2,     2,     2,
00190      2,     2,     2,     2,     2,     2,     2,    69,    84,    77,
00191     83,    78,    82,     2,     2,     2,     2,     2,     2,     2,
00192      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00193      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00194     66,     2,    67,    80,     2,     2,     2,     2,     2,     2,
00195      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00196      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00197      2,     2,    64,    81,    65,    73,     2,     2,     2,     2,
00198      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00199      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00200      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00201      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00202      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00203      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00204      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00205      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00206      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00207      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00208      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00209      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00210      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
00211      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
00212     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
00213     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
00214     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
00215     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
00216     57,    58,    59,    60
00217 };
00218 
00219 #if YYDEBUG != 0
00220 static const short yyprhs[] = {     0,
00221      0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
00222     20,    22,    26,    29,    33,    37,    41,    47,    50,    55,
00223     56,    58,    60,    63,    67,    73,    75,    77,    79,    81,
00224     83,    88,    92,    96,    98,   101,   104,   107,   112,   116,
00225    119,   123,   125,   129,   131,   133,   135,   138,   141,   143,
00226    146,   149,   152,   155,   158,   161,   164,   167,   170,   173,
00227    176,   178,   182,   186,   190,   192,   196,   200,   202,   206,
00228    210,   214,   216,   220,   224,   228,   232,   236,   240,   242,
00229    246,   250,   254,   258,   260,   264,   266,   270,   272,   276,
00230    278,   282,   284,   288,   290,   296,   298,   302,   304,   306,
00231    308,   310,   312,   314,   316,   318,   320,   322,   324,   326,
00232    328,   332,   334,   336,   338,   340,   342,   344,   346,   348,
00233    350,   352,   354,   356,   358,   360,   363,   367,   369,   372,
00234    376,   380,   382,   386,   388,   391,   394,   396,   399,   402,
00235    408,   416,   423,   429,   439,   450,   458,   467,   477,   478,
00236    480,   483,   486,   490,   494,   497,   500,   504,   508,   511,
00237    514,   518,   522,   528,   534,   538,   544,   545,   547,   549,
00238    552,   556,   561,   564,   568,   572,   576,   580,   584,   589,
00239    595,   598,   600,   603,   609,   616,   621,   627,   629,   633,
00240    636,   640,   641,   643,   645,   648,   650
00241 };
00242 
00243 static const short yyrhs[] = {     3,
00244      0,     4,     0,     5,     0,     7,     0,     6,     0,    61,
00245      0,    50,     0,    20,     0,    58,     0,    85,     0,    87,
00246      0,    62,   114,    63,     0,    64,    65,     0,    64,    91,
00247     65,     0,    66,    89,    67,     0,    66,    88,    67,     0,
00248     66,    88,    68,    89,    67,     0,    89,   112,     0,    88,
00249     68,    89,   112,     0,     0,    90,     0,    68,     0,    90,
00250     68,     0,    92,    69,   112,     0,    91,    68,    92,    69,
00251    112,     0,    58,     0,     6,     0,     7,     0,    86,     0,
00252    144,     0,    93,    66,   114,    67,     0,    93,    70,    58,
00253      0,    12,    93,    96,     0,    93,     0,    12,    94,     0,
00254     93,    96,     0,    95,    96,     0,    95,    66,   114,    67,
00255      0,    95,    70,    58,     0,    62,    63,     0,    62,    97,
00256     63,     0,   112,     0,    97,    68,   112,     0,    94,     0,
00257     95,     0,    98,     0,    98,    42,     0,    98,    43,     0,
00258     99,     0,    18,   100,     0,    17,   100,     0,    26,   100,
00259      0,    42,   100,     0,    59,   100,     0,    43,   100,     0,
00260     60,   100,     0,    71,   100,     0,    72,   100,     0,    73,
00261    100,     0,    74,   100,     0,   100,     0,   101,    75,   100,
00262      0,   101,    61,   100,     0,   101,    76,   100,     0,   101,
00263      0,   102,    71,   101,     0,   102,    72,   101,     0,   102,
00264      0,   103,    44,   102,     0,   103,    45,   102,     0,   103,
00265     46,   102,     0,   103,     0,   104,    77,   103,     0,   104,
00266     78,   103,     0,   104,    38,   103,     0,   104,    39,   103,
00267      0,   104,    25,   103,     0,   104,    24,   103,     0,   104,
00268      0,   105,    34,   104,     0,   105,    35,   104,     0,   105,
00269     36,   104,     0,   105,    37,   104,     0,   105,     0,   106,
00270     79,   105,     0,   106,     0,   107,    80,   105,     0,   107,
00271      0,   108,    81,   105,     0,   108,     0,   109,    41,   108,
00272      0,   109,     0,   110,    40,   109,     0,   110,     0,   110,
00273     82,   112,    69,   112,     0,   111,     0,    98,   113,   112,
00274      0,    83,     0,    47,     0,    48,     0,    49,     0,    50,
00275      0,    51,     0,    52,     0,    53,     0,    54,     0,    56,
00276      0,    57,     0,    55,     0,   112,     0,   114,    68,   112,
00277      0,   116,     0,   118,     0,   122,     0,   123,     0,   124,
00278      0,   125,     0,   127,     0,   128,     0,   129,     0,   130,
00279      0,   131,     0,   137,     0,   138,     0,   139,     0,    64,
00280     65,     0,    64,   148,    65,     0,   115,     0,   117,   115,
00281      0,    13,   119,    84,     0,    13,   119,     1,     0,   120,
00282      0,   119,    68,   120,     0,    58,     0,    58,   121,     0,
00283     83,   112,     0,    84,     0,   114,    84,     0,   114,     1,
00284      0,    19,    62,   114,    63,   115,     0,    19,    62,   114,
00285     63,   115,    23,   115,     0,    21,   115,    22,    62,   114,
00286     63,     0,    22,    62,   114,    63,   115,     0,    11,    62,
00287    126,    84,   126,    84,   126,    63,   115,     0,    11,    62,
00288     13,   119,    84,   126,    84,   126,    63,   115,     0,    11,
00289     62,    98,    24,   114,    63,   115,     0,    11,    62,    13,
00290     58,    24,   114,    63,   115,     0,    11,    62,    13,    58,
00291    121,    24,   114,    63,   115,     0,     0,   114,     0,    14,
00292     84,     0,    14,     1,     0,    14,    58,    84,     0,    14,
00293     58,     1,     0,     8,    84,     0,     8,     1,     0,     8,
00294     58,    84,     0,     8,    58,     1,     0,    16,    84,     0,
00295     16,     1,     0,    16,   114,    84,     0,    16,   114,     1,
00296      0,    28,    62,   114,    63,   115,     0,    27,    62,   114,
00297     63,   132,     0,    64,   133,    65,     0,    64,   133,   136,
00298    133,    65,     0,     0,   134,     0,   135,     0,   134,   135,
00299      0,     9,   114,    69,     0,     9,   114,    69,   117,     0,
00300     10,    69,     0,    10,    69,   117,     0,    58,    69,   115,
00301      0,    30,   114,    84,     0,    31,   116,   140,     0,    31,
00302    116,   141,     0,    31,   116,   140,   141,     0,    32,    62,
00303     58,    63,   116,     0,    33,   116,     0,   143,     0,    17,
00304    143,     0,    15,    58,    62,    63,   146,     0,    15,    58,
00305     62,   145,    63,   146,     0,    15,    62,    63,   146,     0,
00306     15,    62,   145,    63,   146,     0,    58,     0,   145,    68,
00307     58,     0,    64,    65,     0,    64,   148,    65,     0,     0,
00308    148,     0,   149,     0,   148,   149,     0,   115,     0,   142,
00309      0
00310 };
00311 
00312 #endif
00313 
00314 #if YYDEBUG != 0
00315 static const short yyrline[] = { 0,
00316    159,   161,   162,   163,   164,   165,   168,   174,   176,   178,
00317    179,   180,   181,   182,   185,   187,   188,   191,   193,   197,
00318    199,   202,   204,   207,   209,   213,   216,   217,   220,   222,
00319    223,   224,   226,   229,   231,   234,   236,   237,   238,   242,
00320    244,   247,   249,   252,   254,   257,   259,   260,   263,   265,
00321    266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
00322    278,   280,   281,   282,   285,   287,   288,   291,   293,   294,
00323    295,   298,   300,   302,   304,   306,   308,   310,   314,   316,
00324    317,   318,   319,   322,   324,   327,   329,   332,   334,   337,
00325    339,   343,   345,   349,   351,   355,   357,   361,   363,   364,
00326    365,   366,   367,   368,   369,   370,   371,   372,   373,   376,
00327    378,   381,   383,   384,   385,   386,   387,   388,   389,   390,
00328    391,   392,   393,   394,   395,   398,   400,   403,   405,   408,
00329    411,   420,   422,   426,   428,   431,   435,   439,   442,   449,
00330    451,   455,   457,   458,   461,   464,   467,   471,   477,   479,
00331    482,   484,   488,   490,   497,   499,   503,   505,   513,   515,
00332    519,   520,   526,   531,   536,   538,   542,   544,   547,   549,
00333    552,   554,   557,   559,   562,   568,   572,   574,   575,   578,
00334    582,   586,   589,   592,   595,   600,   602,   607,   609,   613,
00335    616,   620,   623,   627,   629,   632,   634
00336 };
00337 #endif
00338 
00339 
00340 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
00341 
00342 static const char * const yytname[] = {   "$","error","$undefined.","NULLTOKEN",
00343 "TRUETOKEN","FALSETOKEN","STRING","NUMBER","BREAK","CASE","DEFAULT","FOR","NEW",
00344 "VAR","CONTINUE","FUNCTION","RETURN","VOID","DELETE","IF","THIS","DO","WHILE",
00345 "ELSE","IN","INSTANCEOF","TYPEOF","SWITCH","WITH","RESERVED","THROW","TRY","CATCH",
00346 "FINALLY","EQEQ","NE","STREQ","STRNEQ","LE","GE","OR","AND","PLUSPLUS","MINUSMINUS",
00347 "LSHIFT","RSHIFT","URSHIFT","PLUSEQUAL","MINUSEQUAL","MULTEQUAL","DIVEQUAL",
00348 "LSHIFTEQUAL","RSHIFTEQUAL","URSHIFTEQUAL","ANDEQUAL","MODEQUAL","XOREQUAL",
00349 "OREQUAL","IDENT","AUTOPLUSPLUS","AUTOMINUSMINUS","'/'","'('","')'","'{'","'}'",
00350 "'['","']'","','","':'","'.'","'+'","'-'","'~'","'!'","'*'","'%'","'<'","'>'",
00351 "'&'","'^'","'|'","'?'","'='","';'","Literal","PrimaryExpr","ArrayLiteral","ElementList",
00352 "ElisionOpt","Elision","PropertyNameAndValueList","PropertyName","MemberExpr",
00353 "NewExpr","CallExpr","Arguments","ArgumentList","LeftHandSideExpr","PostfixExpr",
00354 "UnaryExpr","MultiplicativeExpr","AdditiveExpr","ShiftExpr","RelationalExpr",
00355 "EqualityExpr","BitwiseANDExpr","BitwiseXORExpr","BitwiseORExpr","LogicalANDExpr",
00356 "LogicalORExpr","ConditionalExpr","AssignmentExpr","AssignmentOperator","Expr",
00357 "Statement","Block","StatementList","VariableStatement","VariableDeclarationList",
00358 "VariableDeclaration","Initializer","EmptyStatement","ExprStatement","IfStatement",
00359 "IterationStatement","ExprOpt","ContinueStatement","BreakStatement","ReturnStatement",
00360 "WithStatement","SwitchStatement","CaseBlock","CaseClausesOpt","CaseClauses",
00361 "CaseClause","DefaultClause","LabelledStatement","ThrowStatement","TryStatement",
00362 "Catch","Finally","FunctionDeclaration","FunctionDeclarationInternal","FunctionExpr",
00363 "FormalParameterList","FunctionBody","Program","SourceElements","SourceElement", NULL
00364 };
00365 #endif
00366 
00367 static const short yyr1[] = {     0,
00368     85,    85,    85,    85,    85,    85,    85,    86,    86,    86,
00369     86,    86,    86,    86,    87,    87,    87,    88,    88,    89,
00370     89,    90,    90,    91,    91,    92,    92,    92,    93,    93,
00371     93,    93,    93,    94,    94,    95,    95,    95,    95,    96,
00372     96,    97,    97,    98,    98,    99,    99,    99,   100,   100,
00373    100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
00374    101,   101,   101,   101,   102,   102,   102,   103,   103,   103,
00375    103,   104,   104,   104,   104,   104,   104,   104,   105,   105,
00376    105,   105,   105,   106,   106,   107,   107,   108,   108,   109,
00377    109,   110,   110,   111,   111,   112,   112,   113,   113,   113,
00378    113,   113,   113,   113,   113,   113,   113,   113,   113,   114,
00379    114,   115,   115,   115,   115,   115,   115,   115,   115,   115,
00380    115,   115,   115,   115,   115,   116,   116,   117,   117,   118,
00381    118,   119,   119,   120,   120,   121,   122,   123,   123,   124,
00382    124,   125,   125,   125,   125,   125,   125,   125,   126,   126,
00383    127,   127,   127,   127,   128,   128,   128,   128,   129,   129,
00384    129,   129,   130,   131,   132,   132,   133,   133,   134,   134,
00385    135,   135,   136,   136,   137,   138,   139,   139,   139,   140,
00386    141,   142,   142,   143,   143,   144,   144,   145,   145,   146,
00387    146,   147,   147,   148,   148,   149,   149
00388 };
00389 
00390 static const short yyr2[] = {     0,
00391      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00392      1,     3,     2,     3,     3,     3,     5,     2,     4,     0,
00393      1,     1,     2,     3,     5,     1,     1,     1,     1,     1,
00394      4,     3,     3,     1,     2,     2,     2,     4,     3,     2,
00395      3,     1,     3,     1,     1,     1,     2,     2,     1,     2,
00396      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00397      1,     3,     3,     3,     1,     3,     3,     1,     3,     3,
00398      3,     1,     3,     3,     3,     3,     3,     3,     1,     3,
00399      3,     3,     3,     1,     3,     1,     3,     1,     3,     1,
00400      3,     1,     3,     1,     5,     1,     3,     1,     1,     1,
00401      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00402      3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00403      1,     1,     1,     1,     1,     2,     3,     1,     2,     3,
00404      3,     1,     3,     1,     2,     2,     1,     2,     2,     5,
00405      7,     6,     5,     9,    10,     7,     8,     9,     0,     1,
00406      2,     2,     3,     3,     2,     2,     3,     3,     2,     2,
00407      3,     3,     5,     5,     3,     5,     0,     1,     1,     2,
00408      3,     4,     2,     3,     3,     3,     3,     3,     4,     5,
00409      2,     1,     2,     5,     6,     4,     5,     1,     3,     2,
00410      3,     0,     1,     1,     2,     1,     1
00411 };
00412 
00413 static const short yydefact[] = {   192,
00414      1,     2,     3,     5,     4,     0,     0,     0,     0,     0,
00415      0,     0,     0,     0,     0,     8,     0,     0,     0,     0,
00416      0,     0,     0,     0,     0,     7,     9,     0,     0,     6,
00417      0,     0,    20,     0,     0,     0,     0,   137,    10,    29,
00418     11,    34,    44,    45,    46,    49,    61,    65,    68,    72,
00419     79,    84,    86,    88,    90,    92,    94,    96,   110,     0,
00420    196,   112,   113,   114,   115,   116,   117,   118,   119,   120,
00421    121,   122,   123,   124,   125,   197,   182,    30,   193,   194,
00422    156,     0,   155,   149,     0,     9,     0,    34,    35,   134,
00423      0,   132,   152,     0,   151,     0,     0,   160,     0,   159,
00424      0,    46,    51,   183,    50,     0,     0,     0,    52,     0,
00425      0,     0,     0,     0,    53,    55,     0,    54,    56,     0,
00426      5,     4,     9,    13,     0,     0,     0,    22,     0,     0,
00427     21,    57,    58,    59,    60,     0,     0,     0,    36,     0,
00428      0,    37,    47,    48,    99,   100,   101,   102,   103,   104,
00429    105,   106,   109,   107,   108,    98,     0,     0,     0,     0,
00430      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00431      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00432      0,   139,     0,   138,   195,   158,   157,     0,    46,   150,
00433      0,    27,    28,    26,    13,    33,     0,   135,   131,     0,
00434    130,   154,   153,     0,   188,     0,     0,   162,   161,     0,
00435      0,     0,     0,     0,   176,   126,     0,     0,   177,   178,
00436    175,    12,    14,     0,     0,   127,    16,    20,    15,    18,
00437     23,    40,     0,    42,     0,    32,     0,    39,    97,    63,
00438     62,    64,    66,    67,    69,    70,    71,    78,    77,    75,
00439     76,    73,    74,    80,    81,    82,    83,    85,    87,    89,
00440     91,    93,     0,   111,   134,     0,     0,   149,   136,   133,
00441      0,     0,     0,   186,     0,     0,     0,     0,     0,     0,
00442      0,     0,   181,   179,     0,    24,     0,    41,     0,    31,
00443     38,     0,     0,   135,   149,     0,     0,   184,     0,   190,
00444      0,   187,   189,   140,     0,   143,   167,   164,   163,     0,
00445      0,    17,    19,    43,    95,     0,     0,     0,     0,   149,
00446    185,   191,     0,   142,     0,     0,   168,   169,     0,    25,
00447      0,     0,   149,   146,     0,   141,     0,     0,   165,   167,
00448    170,   180,   147,     0,     0,     0,   171,   173,     0,   148,
00449      0,   144,   128,   172,   174,   166,   145,   129,     0,     0,
00450      0
00451 };
00452 
00453 static const short yydefgoto[] = {    39,
00454     40,    41,   129,   130,   131,   125,   126,    42,    43,    44,
00455    139,   233,    45,    46,    47,    48,    49,    50,    51,    52,
00456     53,    54,    55,    56,    57,    58,    59,   157,    60,    61,
00457     62,   354,    63,    91,    92,   198,    64,    65,    66,    67,
00458    191,    68,    69,    70,    71,    72,   308,   326,   327,   328,
00459    340,    73,    74,    75,   219,   220,    76,    77,    78,   207,
00460    274,   359,   127,    80
00461 };
00462 
00463 static const short yypact[] = {   706,
00464 -32768,-32768,-32768,-32768,-32768,     9,   -27,   227,    -4,    29,
00465    120,   115,  1179,  1251,   -19,-32768,   780,     4,  1251,    10,
00466     26,  1251,    39,  1251,  1251,-32768,    25,  1251,  1251,-32768,
00467   1251,   336,    18,  1251,  1251,  1251,  1251,-32768,-32768,-32768,
00468 -32768,   -21,-32768,    -5,   943,-32768,-32768,    50,   112,   102,
00469     85,   201,    36,    56,    72,    64,   -26,-32768,-32768,    22,
00470 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
00471 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   706,-32768,
00472 -32768,    11,-32768,   891,   136,-32768,    31,   -21,-32768,   108,
00473     24,-32768,-32768,    23,-32768,   167,   -16,-32768,  1251,-32768,
00474     30,   127,-32768,-32768,-32768,  1251,   239,  1251,-32768,  1251,
00475   1251,   -36,   410,   195,-32768,-32768,   780,-32768,-32768,    15,
00476    194,   196,    25,   862,   -15,   197,   484,-32768,   173,   963,
00477    199,-32768,-32768,-32768,-32768,  1035,  1251,   210,-32768,  1251,
00478    216,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
00479 -32768,-32768,-32768,-32768,-32768,-32768,  1251,  1251,  1251,  1251,
00480   1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,
00481   1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,  1251,
00482   1251,-32768,  1251,-32768,-32768,-32768,-32768,   218,  1284,   211,
00483    198,-32768,-32768,-32768,-32768,-32768,  1251,-32768,-32768,    -4,
00484 -32768,-32768,-32768,    54,-32768,   214,    71,-32768,-32768,    74,
00485    219,    75,    77,    86,-32768,-32768,   221,    39,   247,-32768,
00486 -32768,-32768,-32768,    27,  1251,-32768,-32768,    18,-32768,-32768,
00487 -32768,-32768,    92,-32768,   176,-32768,   178,-32768,-32768,-32768,
00488 -32768,-32768,    50,    50,   112,   112,   112,   102,   102,   102,
00489    102,   102,   102,    85,    85,    85,    85,   201,   201,   201,
00490     72,    64,   223,-32768,    -6,   -29,  1251,  1251,-32768,-32768,
00491    214,    93,   558,-32768,   214,   229,   780,  1251,   780,   226,
00492    780,   236,-32768,-32768,   228,-32768,  1107,-32768,  1251,-32768,
00493 -32768,  1251,  1251,   271,  1251,    96,   212,-32768,   214,-32768,
00494    632,-32768,-32768,   275,   104,-32768,   290,-32768,-32768,   237,
00495   1251,-32768,-32768,-32768,-32768,   117,  1251,   217,   780,  1251,
00496 -32768,-32768,   780,-32768,  1251,    -2,   290,-32768,    39,-32768,
00497    780,   129,  1251,-32768,   240,-32768,   186,   235,-32768,   290,
00498 -32768,-32768,-32768,   780,   242,   780,   780,   780,   244,-32768,
00499    780,-32768,-32768,   780,   780,-32768,-32768,-32768,   310,   312,
00500 -32768
00501 };
00502 
00503 static const short yypgoto[] = {-32768,
00504 -32768,-32768,-32768,    87,-32768,-32768,    89,   309,   311,-32768,
00505    -37,-32768,    45,-32768,    -8,    95,    37,    82,    98,    17,
00506 -32768,-32768,   139,   140,-32768,-32768,  -121,-32768,    -9,   -17,
00507    -22,   -25,-32768,   133,   122,    60,-32768,-32768,-32768,-32768,
00508   -249,-32768,-32768,-32768,-32768,-32768,-32768,   -14,-32768,     1,
00509 -32768,-32768,-32768,-32768,-32768,   113,-32768,   320,-32768,   131,
00510   -231,-32768,     2,   -75
00511 };
00512 
00513 
00514 #define YYLAST          1367
00515 
00516 
00517 static const short yytable[] = {   107,
00518    114,    79,   101,   185,   103,   105,   142,   338,   230,    81,
00519    109,   186,   112,   180,   234,   115,   116,   293,   297,   118,
00520    119,   120,   182,   202,   199,   132,   133,   134,   135,    93,
00521    208,   183,   192,   193,    84,   239,   192,   193,   200,   298,
00522    136,   205,   106,   302,   137,   318,   206,   215,   138,   223,
00523    196,   185,   224,    90,   295,   181,   136,   102,   102,   263,
00524    140,   264,   339,   102,   141,   108,    82,   321,   102,   102,
00525    335,   110,   102,   102,   190,   269,   197,   222,   102,   102,
00526    102,   102,   183,   345,   194,   128,    94,   111,   194,   183,
00527    103,   200,    83,   117,   187,   195,   210,   183,   212,   221,
00528    213,   214,   113,   286,   179,   184,   203,   201,   166,   167,
00529    158,   205,    95,   209,   176,    98,   271,     1,     2,     3,
00530      4,     5,   168,   169,   159,   160,     8,   235,   189,    85,
00531    237,    99,    14,   275,    16,   177,   277,   279,   276,   280,
00532     19,   183,   183,   102,   183,   163,   164,   165,   281,   240,
00533    241,   242,   178,   183,   288,   299,    24,    25,   319,   289,
00534    276,   170,   171,   183,    26,   313,   324,   314,   143,   144,
00535    315,   183,    86,    28,    29,    30,    31,    96,    87,   331,
00536     33,    97,   161,   162,   183,    34,    35,    36,    37,   330,
00537    197,   344,   258,   259,   260,   283,   183,    97,   100,   245,
00538    246,   247,   102,   102,   102,   102,   102,   102,   102,   102,
00539    102,   102,   102,   102,   102,   102,   102,   102,   102,   102,
00540    102,   102,   102,   102,   102,   185,   217,   218,   204,     1,
00541      2,     3,     4,     5,   172,   173,   174,   175,     8,   227,
00542    228,    85,   290,   183,   291,   183,    16,   248,   249,   250,
00543    251,   252,   253,   183,   347,   243,   244,   296,   190,   304,
00544    211,   306,   -27,   309,   -28,   225,   231,   236,   305,   254,
00545    255,   256,   257,   238,   301,   265,    26,   273,   183,   218,
00546    278,   268,   282,   316,    86,   190,   303,    30,    31,   307,
00547     87,   292,    33,   310,   317,   320,   311,   323,   325,   329,
00548    333,   334,   346,   348,   351,   336,   342,   332,   356,   360,
00549    190,   361,   285,   343,   287,   337,    88,   261,    89,   262,
00550    266,   270,   355,   190,   294,   349,   350,   341,   352,   353,
00551    353,   284,   104,   357,   272,     0,   358,   358,     1,     2,
00552      3,   121,   122,     6,     0,     0,     7,     8,     9,    10,
00553     11,    12,    13,    14,    15,    16,    17,    18,     0,     0,
00554      0,    19,    20,    21,     0,    22,    23,     0,     0,     0,
00555      0,     0,     0,     0,     0,     0,     0,    24,    25,     0,
00556      0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
00557      0,     0,     0,   123,    28,    29,    30,    31,     0,    32,
00558    124,    33,     0,     0,     0,     0,    34,    35,    36,    37,
00559      0,     0,     1,     2,     3,     4,     5,     6,     0,    38,
00560      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
00561     17,    18,     0,     0,     0,    19,    20,    21,     0,    22,
00562     23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00563      0,    24,    25,     0,     0,     0,     0,     0,     0,    26,
00564      0,     0,     0,     0,     0,     0,     0,    27,    28,    29,
00565     30,    31,     0,    32,   216,    33,     0,     0,     0,     0,
00566     34,    35,    36,    37,     0,     0,     1,     2,     3,     4,
00567      5,     6,     0,    38,     7,     8,     9,    10,    11,    12,
00568     13,    14,    15,    16,    17,    18,     0,     0,     0,    19,
00569     20,    21,     0,    22,    23,     0,     0,     0,     0,     0,
00570      0,     0,     0,     0,     0,    24,    25,     0,     0,     0,
00571      0,     0,     0,    26,     0,     0,     0,     0,     0,     0,
00572      0,    27,    28,    29,    30,    31,     0,    32,   226,    33,
00573      0,     0,     0,     0,    34,    35,    36,    37,     0,     0,
00574      1,     2,     3,     4,     5,     6,     0,    38,     7,     8,
00575      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
00576      0,     0,     0,    19,    20,    21,     0,    22,    23,     0,
00577      0,     0,     0,     0,     0,     0,     0,     0,     0,    24,
00578     25,     0,     0,     0,     0,     0,     0,    26,     0,     0,
00579      0,     0,     0,     0,     0,    27,    28,    29,    30,    31,
00580      0,    32,   300,    33,     0,     0,     0,     0,    34,    35,
00581     36,    37,     0,     0,     1,     2,     3,     4,     5,     6,
00582      0,    38,     7,     8,     9,    10,    11,    12,    13,    14,
00583     15,    16,    17,    18,     0,     0,     0,    19,    20,    21,
00584      0,    22,    23,     0,     0,     0,     0,     0,     0,     0,
00585      0,     0,     0,    24,    25,     0,     0,     0,     0,     0,
00586      0,    26,     0,     0,     0,     0,     0,     0,     0,    27,
00587     28,    29,    30,    31,     0,    32,   322,    33,     0,     0,
00588      0,     0,    34,    35,    36,    37,     0,     0,     1,     2,
00589      3,     4,     5,     6,     0,    38,     7,     8,     9,    10,
00590     11,    12,    13,    14,    15,    16,    17,    18,     0,     0,
00591      0,    19,    20,    21,     0,    22,    23,     0,     0,     0,
00592      0,     0,     0,     0,     0,     0,     0,    24,    25,     0,
00593      0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
00594      0,     0,     0,    27,    28,    29,    30,    31,     0,    32,
00595      0,    33,     0,     0,     0,     0,    34,    35,    36,    37,
00596      0,     0,     1,     2,     3,     4,     5,     6,     0,    38,
00597      7,     8,     9,    10,    85,    12,    99,    14,    15,    16,
00598     17,    18,     0,     0,     0,    19,    20,    21,     0,    22,
00599     23,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00600      0,    24,    25,     0,     0,     0,     0,     0,     0,    26,
00601      0,     0,     0,     0,     0,     0,     0,    27,    28,    29,
00602     30,    31,     0,    32,     0,    33,     0,     0,     0,     0,
00603     34,    35,    36,    37,     0,     0,     0,     0,     0,     0,
00604      0,  -126,     0,    38,  -126,  -126,  -126,  -126,  -126,  -126,
00605   -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,  -126,
00606   -126,  -126,  -126,  -126,  -126,     0,     0,  -126,  -126,  -126,
00607      0,  -126,  -126,     1,     2,     3,     4,     5,     0,     0,
00608      0,     0,     8,   188,     0,    85,     0,    99,    14,     0,
00609     16,     0,     0,     0,     0,     0,    19,     0,     0,  -126,
00610   -126,  -126,     0,     0,     0,  -126,  -126,     0,     0,     0,
00611      0,     0,    24,    25,  -126,  -126,     0,     0,     0,     0,
00612     26,     0,     0,     0,     0,     0,     0,     0,    86,    28,
00613     29,    30,    31,     0,    87,     0,    33,     0,     0,     0,
00614      0,    34,    35,    36,    37,     1,     2,     3,     4,     5,
00615      0,     0,     0,     0,     8,     0,     0,    85,     0,    99,
00616     14,     0,    16,     0,   143,   144,     0,     0,    19,   145,
00617    146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
00618      0,     0,     0,     0,    24,    25,     0,     0,     0,     0,
00619      0,     0,    26,     0,     0,     0,     0,     0,     0,     0,
00620     86,    28,    29,    30,    31,   156,    87,     0,    33,   229,
00621      0,     0,     0,    34,    35,    36,    37,     1,     2,     3,
00622      4,     5,     0,     0,     0,     0,     8,     0,     0,    85,
00623      0,    99,    14,     0,    16,     0,     0,     0,     0,     0,
00624     19,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00625      0,     0,     0,     0,     0,     0,    24,    25,     0,     0,
00626      0,     0,     0,     0,    26,     0,     0,     0,     0,     0,
00627      0,     0,    86,    28,    29,    30,    31,   232,    87,     0,
00628     33,     0,     0,     0,     0,    34,    35,    36,    37,     1,
00629      2,     3,     4,     5,     0,     0,     0,     0,     8,     0,
00630      0,    85,     0,    99,    14,     0,    16,     0,     0,     0,
00631      0,     0,    19,     0,     0,     0,     0,     0,     0,     0,
00632      0,     0,     0,     0,     0,     0,     0,     0,    24,    25,
00633      0,     0,     0,     0,     0,     0,    26,     0,     0,     0,
00634      0,     0,     0,     0,    86,    28,    29,    30,    31,     0,
00635     87,     0,    33,   312,     0,     0,     0,    34,    35,    36,
00636     37,     1,     2,     3,     4,     5,     0,     0,     0,     0,
00637      8,     0,     0,    11,     0,    99,    14,     0,    16,     0,
00638      0,     0,     0,     0,    19,     0,     0,     0,     0,     0,
00639      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00640     24,    25,     0,     0,     0,     0,     0,     0,    26,     0,
00641      0,     0,     0,     0,     0,     0,    86,    28,    29,    30,
00642     31,     0,    87,     0,    33,     0,     0,     0,     0,    34,
00643     35,    36,    37,     1,     2,     3,     4,     5,     0,     0,
00644      0,     0,     8,     0,     0,    85,     0,    99,    14,     0,
00645     16,     0,     0,     0,     0,     0,    19,     0,     0,     0,
00646      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00647      0,     0,    24,    25,     0,     0,     0,     0,     0,     0,
00648     26,     0,     0,     0,     0,     0,     0,   267,    86,    28,
00649     29,    30,    31,     0,    87,     0,    33,     0,     0,     0,
00650      0,    34,    35,    36,    37,   143,   144,     0,     0,     0,
00651    145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
00652    155,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00653      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00654      0,     0,     0,     0,     0,     0,   156
00655 };
00656 
00657 static const short yycheck[] = {    17,
00658     23,     0,    12,    79,    13,    14,    44,    10,   130,     1,
00659     19,     1,    22,    40,   136,    24,    25,    24,   268,    28,
00660     29,    31,     1,     1,     1,    34,    35,    36,    37,     1,
00661      1,    68,     6,     7,    62,   157,     6,     7,    68,   271,
00662     62,    58,    62,   275,    66,   295,    63,    84,    70,    65,
00663     88,   127,    68,    58,    84,    82,    62,    13,    14,   181,
00664     66,   183,    65,    19,    70,    62,    58,   299,    24,    25,
00665    320,    62,    28,    29,    84,   197,    83,    63,    34,    35,
00666     36,    37,    68,   333,    58,    68,    58,    62,    58,    68,
00667     99,    68,    84,    69,    84,    65,   106,    68,   108,   117,
00668    110,   111,    64,   225,    41,    84,    84,    84,    24,    25,
00669     61,    58,    84,    84,    79,     1,    63,     3,     4,     5,
00670      6,     7,    38,    39,    75,    76,    12,   137,    84,    15,
00671    140,    17,    18,    63,    20,    80,    63,    63,    68,    63,
00672     26,    68,    68,    99,    68,    44,    45,    46,    63,   158,
00673    159,   160,    81,    68,    63,    63,    42,    43,    63,    68,
00674     68,    77,    78,    68,    50,   287,    63,   289,    42,    43,
00675    292,    68,    58,    59,    60,    61,    62,    58,    64,    63,
00676     66,    62,    71,    72,    68,    71,    72,    73,    74,   311,
00677     83,    63,   176,   177,   178,   218,    68,    62,    84,   163,
00678    164,   165,   158,   159,   160,   161,   162,   163,   164,   165,
00679    166,   167,   168,   169,   170,   171,   172,   173,   174,   175,
00680    176,   177,   178,   179,   180,   301,    32,    33,    62,     3,
00681      4,     5,     6,     7,    34,    35,    36,    37,    12,    67,
00682     68,    15,    67,    68,    67,    68,    20,   166,   167,   168,
00683    169,   170,   171,    68,    69,   161,   162,   267,   268,   277,
00684     22,   279,    69,   281,    69,    69,    68,    58,   278,   172,
00685    173,   174,   175,    58,   273,    58,    50,    64,    68,    33,
00686     62,    84,    62,   293,    58,   295,    58,    61,    62,    64,
00687     64,    69,    66,    58,    24,    84,    69,    23,     9,    63,
00688     84,   319,    63,    69,    63,   323,   329,   317,    65,     0,
00689    320,     0,   224,   331,   228,   325,     8,   179,     8,   180,
00690    188,   200,   348,   333,   265,   340,   344,   327,   346,   347,
00691    348,   219,    13,   351,   204,    -1,   354,   355,     3,     4,
00692      5,     6,     7,     8,    -1,    -1,    11,    12,    13,    14,
00693     15,    16,    17,    18,    19,    20,    21,    22,    -1,    -1,
00694     -1,    26,    27,    28,    -1,    30,    31,    -1,    -1,    -1,
00695     -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,
00696     -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
00697     -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,    64,
00698     65,    66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,
00699     -1,    -1,     3,     4,     5,     6,     7,     8,    -1,    84,
00700     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
00701     21,    22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,
00702     31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00703     -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,
00704     -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,
00705     61,    62,    -1,    64,    65,    66,    -1,    -1,    -1,    -1,
00706     71,    72,    73,    74,    -1,    -1,     3,     4,     5,     6,
00707      7,     8,    -1,    84,    11,    12,    13,    14,    15,    16,
00708     17,    18,    19,    20,    21,    22,    -1,    -1,    -1,    26,
00709     27,    28,    -1,    30,    31,    -1,    -1,    -1,    -1,    -1,
00710     -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,
00711     -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,
00712     -1,    58,    59,    60,    61,    62,    -1,    64,    65,    66,
00713     -1,    -1,    -1,    -1,    71,    72,    73,    74,    -1,    -1,
00714      3,     4,     5,     6,     7,     8,    -1,    84,    11,    12,
00715     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
00716     -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,    -1,
00717     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,
00718     43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,
00719     -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,
00720     -1,    64,    65,    66,    -1,    -1,    -1,    -1,    71,    72,
00721     73,    74,    -1,    -1,     3,     4,     5,     6,     7,     8,
00722     -1,    84,    11,    12,    13,    14,    15,    16,    17,    18,
00723     19,    20,    21,    22,    -1,    -1,    -1,    26,    27,    28,
00724     -1,    30,    31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00725     -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,
00726     -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,
00727     59,    60,    61,    62,    -1,    64,    65,    66,    -1,    -1,
00728     -1,    -1,    71,    72,    73,    74,    -1,    -1,     3,     4,
00729      5,     6,     7,     8,    -1,    84,    11,    12,    13,    14,
00730     15,    16,    17,    18,    19,    20,    21,    22,    -1,    -1,
00731     -1,    26,    27,    28,    -1,    30,    31,    -1,    -1,    -1,
00732     -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,
00733     -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,
00734     -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,    64,
00735     -1,    66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,
00736     -1,    -1,     3,     4,     5,     6,     7,     8,    -1,    84,
00737     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
00738     21,    22,    -1,    -1,    -1,    26,    27,    28,    -1,    30,
00739     31,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00740     -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,
00741     -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,
00742     61,    62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,
00743     71,    72,    73,    74,    -1,    -1,    -1,    -1,    -1,    -1,
00744     -1,     0,    -1,    84,     3,     4,     5,     6,     7,     8,
00745      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
00746     19,    20,    21,    22,    23,    -1,    -1,    26,    27,    28,
00747     -1,    30,    31,     3,     4,     5,     6,     7,    -1,    -1,
00748     -1,    -1,    12,    13,    -1,    15,    -1,    17,    18,    -1,
00749     20,    -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    58,
00750     59,    60,    -1,    -1,    -1,    64,    65,    -1,    -1,    -1,
00751     -1,    -1,    42,    43,    73,    74,    -1,    -1,    -1,    -1,
00752     50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,
00753     60,    61,    62,    -1,    64,    -1,    66,    -1,    -1,    -1,
00754     -1,    71,    72,    73,    74,     3,     4,     5,     6,     7,
00755     -1,    -1,    -1,    -1,    12,    -1,    -1,    15,    -1,    17,
00756     18,    -1,    20,    -1,    42,    43,    -1,    -1,    26,    47,
00757     48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
00758     -1,    -1,    -1,    -1,    42,    43,    -1,    -1,    -1,    -1,
00759     -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00760     58,    59,    60,    61,    62,    83,    64,    -1,    66,    67,
00761     -1,    -1,    -1,    71,    72,    73,    74,     3,     4,     5,
00762      6,     7,    -1,    -1,    -1,    -1,    12,    -1,    -1,    15,
00763     -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,
00764     26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00765     -1,    -1,    -1,    -1,    -1,    -1,    42,    43,    -1,    -1,
00766     -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,
00767     -1,    -1,    58,    59,    60,    61,    62,    63,    64,    -1,
00768     66,    -1,    -1,    -1,    -1,    71,    72,    73,    74,     3,
00769      4,     5,     6,     7,    -1,    -1,    -1,    -1,    12,    -1,
00770     -1,    15,    -1,    17,    18,    -1,    20,    -1,    -1,    -1,
00771     -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00772     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    42,    43,
00773     -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,    -1,    -1,
00774     -1,    -1,    -1,    -1,    58,    59,    60,    61,    62,    -1,
00775     64,    -1,    66,    67,    -1,    -1,    -1,    71,    72,    73,
00776     74,     3,     4,     5,     6,     7,    -1,    -1,    -1,    -1,
00777     12,    -1,    -1,    15,    -1,    17,    18,    -1,    20,    -1,
00778     -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,
00779     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00780     42,    43,    -1,    -1,    -1,    -1,    -1,    -1,    50,    -1,
00781     -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    60,    61,
00782     62,    -1,    64,    -1,    66,    -1,    -1,    -1,    -1,    71,
00783     72,    73,    74,     3,     4,     5,     6,     7,    -1,    -1,
00784     -1,    -1,    12,    -1,    -1,    15,    -1,    17,    18,    -1,
00785     20,    -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,
00786     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00787     -1,    -1,    42,    43,    -1,    -1,    -1,    -1,    -1,    -1,
00788     50,    -1,    -1,    -1,    -1,    -1,    -1,    24,    58,    59,
00789     60,    61,    62,    -1,    64,    -1,    66,    -1,    -1,    -1,
00790     -1,    71,    72,    73,    74,    42,    43,    -1,    -1,    -1,
00791     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
00792     57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00793     -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00794     -1,    -1,    -1,    -1,    -1,    -1,    83
00795 };
00796 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
00797 #line 3 "/usr/lib/bison.simple"
00798 /* This file comes from bison-1.28.  */
00799 
00800 /* Skeleton output parser for bison,
00801    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
00802 
00803    This program is free software; you can redistribute it and/or modify
00804    it under the terms of the GNU General Public License as published by
00805    the Free Software Foundation; either version 2, or (at your option)
00806    any later version.
00807 
00808    This program is distributed in the hope that it will be useful,
00809    but WITHOUT ANY WARRANTY; without even the implied warranty of
00810    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00811    GNU General Public License for more details.
00812 
00813    You should have received a copy of the GNU General Public License
00814    along with this program; if not, write to the Free Software
00815    Foundation, Inc., 59 Temple Place - Suite 330,
00816    Boston, MA 02111-1307, USA.  */
00817 
00818 /* As a special exception, when this file is copied by Bison into a
00819    Bison output file, you may use that output file without restriction.
00820    This special exception was added by the Free Software Foundation
00821    in version 1.24 of Bison.  */
00822 
00823 /* This is the parser code that is written into each bison parser
00824   when the %semantic_parser declaration is not specified in the grammar.
00825   It was written by Richard Stallman by simplifying the hairy parser
00826   used when %semantic_parser is specified.  */
00827 
00828 #ifndef YYSTACK_USE_ALLOCA
00829 #ifdef alloca
00830 #define YYSTACK_USE_ALLOCA
00831 #else /* alloca not defined */
00832 #ifdef __GNUC__
00833 #define YYSTACK_USE_ALLOCA
00834 #define alloca __builtin_alloca
00835 #else /* not GNU C.  */
00836 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
00837 #define YYSTACK_USE_ALLOCA
00838 #include <alloca.h>
00839 #else /* not sparc */
00840 /* We think this test detects Watcom and Microsoft C.  */
00841 /* This used to test MSDOS, but that is a bad idea
00842    since that symbol is in the user namespace.  */
00843 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
00844 #if 0 /* No need for malloc.h, which pollutes the namespace;
00845          instead, just don't use alloca.  */
00846 #include <malloc.h>
00847 #endif
00848 #else /* not MSDOS, or __TURBOC__ */
00849 #if defined(_AIX)
00850 /* I don't know what this was needed for, but it pollutes the namespace.
00851    So I turned it off.   rms, 2 May 1997.  */
00852 /* #include <malloc.h>  */
00853  #pragma alloca
00854 #define YYSTACK_USE_ALLOCA
00855 #else /* not MSDOS, or __TURBOC__, or _AIX */
00856 #if 0
00857 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
00858                  and on HPUX 10.  Eventually we can turn this on.  */
00859 #define YYSTACK_USE_ALLOCA
00860 #define alloca __builtin_alloca
00861 #endif /* __hpux */
00862 #endif
00863 #endif /* not _AIX */
00864 #endif /* not MSDOS, or __TURBOC__ */
00865 #endif /* not sparc */
00866 #endif /* not GNU C */
00867 #endif /* alloca not defined */
00868 #endif /* YYSTACK_USE_ALLOCA not defined */
00869 
00870 #ifdef YYSTACK_USE_ALLOCA
00871 #define YYSTACK_ALLOC alloca
00872 #else
00873 #define YYSTACK_ALLOC malloc
00874 #endif
00875 
00876 /* Note: there must be only one dollar sign in this file.
00877    It is replaced by the list of actions, each action
00878    as one case of the switch.  */
00879 
00880 #define yyerrok         (yyerrstatus = 0)
00881 #define yyclearin       (yychar = YYEMPTY)
00882 #define YYEMPTY         -2
00883 #define YYEOF           0
00884 #define YYACCEPT        goto yyacceptlab
00885 #define YYABORT         goto yyabortlab
00886 #define YYERROR         goto yyerrlab1
00887 /* Like YYERROR except do call yyerror.
00888    This remains here temporarily to ease the
00889    transition to the new meaning of YYERROR, for GCC.
00890    Once GCC version 2 has supplanted version 1, this can go.  */
00891 #define YYFAIL          goto yyerrlab
00892 #define YYRECOVERING()  (!!yyerrstatus)
00893 #define YYBACKUP(token, value) \
00894 do                                                              \
00895   if (yychar == YYEMPTY && yylen == 1)                          \
00896     { yychar = (token), yylval = (value);                       \
00897       yychar1 = YYTRANSLATE (yychar);                           \
00898       YYPOPSTACK;                                               \
00899       goto yybackup;                                            \
00900     }                                                           \
00901   else                                                          \
00902     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
00903 while (0)
00904 
00905 #define YYTERROR        1
00906 #define YYERRCODE       256
00907 
00908 #ifndef YYPURE
00909 #define YYLEX           yylex()
00910 #endif
00911 
00912 #ifdef YYPURE
00913 #ifdef YYLSP_NEEDED
00914 #ifdef YYLEX_PARAM
00915 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
00916 #else
00917 #define YYLEX           yylex(&yylval, &yylloc)
00918 #endif
00919 #else /* not YYLSP_NEEDED */
00920 #ifdef YYLEX_PARAM
00921 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
00922 #else
00923 #define YYLEX           yylex(&yylval)
00924 #endif
00925 #endif /* not YYLSP_NEEDED */
00926 #endif
00927 
00928 /* If nonreentrant, generate the variables here */
00929 
00930 #ifndef YYPURE
00931 
00932 int     yychar;                 /*  the lookahead symbol                */
00933 YYSTYPE yylval;                 /*  the semantic value of the           */
00934                                 /*  lookahead symbol                    */
00935 
00936 #ifdef YYLSP_NEEDED
00937 YYLTYPE yylloc;                 /*  location data for the lookahead     */
00938                                 /*  symbol                              */
00939 #endif
00940 
00941 int yynerrs;                    /*  number of parse errors so far       */
00942 #endif  /* not YYPURE */
00943 
00944 #if YYDEBUG != 0
00945 int yydebug;                    /*  nonzero means print parse trace     */
00946 /* Since this is uninitialized, it does not stop multiple parsers
00947    from coexisting.  */
00948 #endif
00949 
00950 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
00951 
00952 #ifndef YYINITDEPTH
00953 #define YYINITDEPTH 200
00954 #endif
00955 
00956 /*  YYMAXDEPTH is the maximum size the stacks can grow to
00957     (effective only if the built-in stack extension method is used).  */
00958 
00959 #if YYMAXDEPTH == 0
00960 #undef YYMAXDEPTH
00961 #endif
00962 
00963 #ifndef YYMAXDEPTH
00964 #define YYMAXDEPTH 10000
00965 #endif
00966 
00967 /* Define __yy_memcpy.  Note that the size argument
00968    should be passed with type unsigned int, because that is what the non-GCC
00969    definitions require.  With GCC, __builtin_memcpy takes an arg
00970    of type size_t, but it can handle unsigned int.  */
00971 
00972 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
00973 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
00974 #else                           /* not GNU C or C++ */
00975 #ifndef __cplusplus
00976 
00977 /* This is the most reliable way to avoid incompatibilities
00978    in available built-in functions on various systems.  */
00979 static void
00980 __yy_memcpy (to, from, count)
00981      char *to;
00982      char *from;
00983      unsigned int count;
00984 {
00985   register char *f = from;
00986   register char *t = to;
00987   register int i = count;
00988 
00989   while (i-- > 0)
00990     *t++ = *f++;
00991 }
00992 
00993 #else /* __cplusplus */
00994 
00995 /* This is the most reliable way to avoid incompatibilities
00996    in available built-in functions on various systems.  */
00997 static void
00998 __yy_memcpy (char *to, char *from, unsigned int count)
00999 {
01000   register char *t = to;
01001   register char *f = from;
01002   register int i = count;
01003 
01004   while (i-- > 0)
01005     *t++ = *f++;
01006 }
01007 
01008 #endif
01009 #endif
01010 
01011 #line 217 "/usr/lib/bison.simple"
01012 
01013 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
01014    into yyparse.  The argument should have type void *.
01015    It should actually point to an object.
01016    Grammar actions can access the variable by casting it
01017    to the proper pointer type.  */
01018 
01019 #ifdef YYPARSE_PARAM
01020 #ifdef __cplusplus
01021 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
01022 #define YYPARSE_PARAM_DECL
01023 #else /* not __cplusplus */
01024 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
01025 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
01026 #endif /* not __cplusplus */
01027 #else /* not YYPARSE_PARAM */
01028 #define YYPARSE_PARAM_ARG
01029 #define YYPARSE_PARAM_DECL
01030 #endif /* not YYPARSE_PARAM */
01031 
01032 /* Prevent warning if -Wstrict-prototypes.  */
01033 #ifdef __GNUC__
01034 #ifdef YYPARSE_PARAM
01035 int yyparse (void *);
01036 #else
01037 int yyparse (void);
01038 #endif
01039 #endif
01040 
01041 int
01042 yyparse(YYPARSE_PARAM_ARG)
01043      YYPARSE_PARAM_DECL
01044 {
01045   register int yystate;
01046   register int yyn;
01047   register short *yyssp;
01048   register YYSTYPE *yyvsp;
01049   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
01050   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
01051 
01052   short yyssa[YYINITDEPTH];     /*  the state stack                     */
01053   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
01054 
01055   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
01056   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
01057 
01058 #ifdef YYLSP_NEEDED
01059   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
01060   YYLTYPE *yyls = yylsa;
01061   YYLTYPE *yylsp;
01062 
01063 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
01064 #else
01065 #define YYPOPSTACK   (yyvsp--, yyssp--)
01066 #endif
01067 
01068   int yystacksize = YYINITDEPTH;
01069   int yyfree_stacks = 0;
01070 
01071 #ifdef YYPURE
01072   int yychar;
01073   YYSTYPE yylval;
01074   int yynerrs;
01075 #ifdef YYLSP_NEEDED
01076   YYLTYPE yylloc;
01077 #endif
01078 #endif
01079 
01080   YYSTYPE yyval;                /*  the variable used to return         */
01081                                 /*  semantic values from the action     */
01082                                 /*  routines                            */
01083 
01084   int yylen;
01085 
01086 #if YYDEBUG != 0
01087   if (yydebug)
01088     fprintf(stderr, "Starting parse\n");
01089 #endif
01090 
01091   yystate = 0;
01092   yyerrstatus = 0;
01093   yynerrs = 0;
01094   yychar = YYEMPTY;             /* Cause a token to be read.  */
01095 
01096   /* Initialize stack pointers.
01097      Waste one element of value and location stack
01098      so that they stay on the same level as the state stack.
01099      The wasted elements are never initialized.  */
01100 
01101   yyssp = yyss - 1;
01102   yyvsp = yyvs;
01103 #ifdef YYLSP_NEEDED
01104   yylsp = yyls;
01105 #endif
01106 
01107 /* Push a new state, which is found in  yystate  .  */
01108 /* In all cases, when you get here, the value and location stacks
01109    have just been pushed. so pushing a state here evens the stacks.  */
01110 yynewstate:
01111 
01112   *++yyssp = yystate;
01113 
01114   if (yyssp >= yyss + yystacksize - 1)
01115     {
01116       /* Give user a chance to reallocate the stack */
01117       /* Use copies of these so that the &'s don't force the real ones into memory. */
01118       YYSTYPE *yyvs1 = yyvs;
01119       short *yyss1 = yyss;
01120 #ifdef YYLSP_NEEDED
01121       YYLTYPE *yyls1 = yyls;
01122 #endif
01123 
01124       /* Get the current used size of the three stacks, in elements.  */
01125       int size = yyssp - yyss + 1;
01126 
01127 #ifdef yyoverflow
01128       /* Each stack pointer address is followed by the size of
01129          the data in use in that stack, in bytes.  */
01130 #ifdef YYLSP_NEEDED
01131       /* This used to be a conditional around just the two extra args,
01132          but that might be undefined if yyoverflow is a macro.  */
01133       yyoverflow("parser stack overflow",
01134                  &yyss1, size * sizeof (*yyssp),
01135                  &yyvs1, size * sizeof (*yyvsp),
01136                  &yyls1, size * sizeof (*yylsp),
01137                  &yystacksize);
01138 #else
01139       yyoverflow("parser stack overflow",
01140                  &yyss1, size * sizeof (*yyssp),
01141                  &yyvs1, size * sizeof (*yyvsp),
01142                  &yystacksize);
01143 #endif
01144 
01145       yyss = yyss1; yyvs = yyvs1;
01146 #ifdef YYLSP_NEEDED
01147       yyls = yyls1;
01148 #endif
01149 #else /* no yyoverflow */
01150       /* Extend the stack our own way.  */
01151       if (yystacksize >= YYMAXDEPTH)
01152         {
01153           yyerror("parser stack overflow");
01154           if (yyfree_stacks)
01155             {
01156               free (yyss);
01157               free (yyvs);
01158 #ifdef YYLSP_NEEDED
01159               free (yyls);
01160 #endif
01161             }
01162           return 2;
01163         }
01164       yystacksize *= 2;
01165       if (yystacksize > YYMAXDEPTH)
01166         yystacksize = YYMAXDEPTH;
01167 #ifndef YYSTACK_USE_ALLOCA
01168       yyfree_stacks = 1;
01169 #endif
01170       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
01171       __yy_memcpy ((char *)yyss, (char *)yyss1,
01172                    size * (unsigned int) sizeof (*yyssp));
01173       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
01174       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
01175                    size * (unsigned int) sizeof (*yyvsp));
01176 #ifdef YYLSP_NEEDED
01177       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
01178       __yy_memcpy ((char *)yyls, (char *)yyls1,
01179                    size * (unsigned int) sizeof (*yylsp));
01180 #endif
01181 #endif /* no yyoverflow */
01182 
01183       yyssp = yyss + size - 1;
01184       yyvsp = yyvs + size - 1;
01185 #ifdef YYLSP_NEEDED
01186       yylsp = yyls + size - 1;
01187 #endif
01188 
01189 #if YYDEBUG != 0
01190       if (yydebug)
01191         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
01192 #endif
01193 
01194       if (yyssp >= yyss + yystacksize - 1)
01195         YYABORT;
01196     }
01197 
01198 #if YYDEBUG != 0
01199   if (yydebug)
01200     fprintf(stderr, "Entering state %d\n", yystate);
01201 #endif
01202 
01203   goto yybackup;
01204  yybackup:
01205 
01206 /* Do appropriate processing given the current state.  */
01207 /* Read a lookahead token if we need one and don't already have one.  */
01208 /* yyresume: */
01209 
01210   /* First try to decide what to do without reference to lookahead token.  */
01211 
01212   yyn = yypact[yystate];
01213   if (yyn == YYFLAG)
01214     goto yydefault;
01215 
01216   /* Not known => get a lookahead token if don't already have one.  */
01217 
01218   /* yychar is either YYEMPTY or YYEOF
01219      or a valid token in external form.  */
01220 
01221   if (yychar == YYEMPTY)
01222     {
01223 #if YYDEBUG != 0
01224       if (yydebug)
01225         fprintf(stderr, "Reading a token: ");
01226 #endif
01227       yychar = YYLEX;
01228     }
01229 
01230   /* Convert token to internal form (in yychar1) for indexing tables with */
01231 
01232   if (yychar <= 0)              /* This means end of input. */
01233     {
01234       yychar1 = 0;
01235       yychar = YYEOF;           /* Don't call YYLEX any more */
01236 
01237 #if YYDEBUG != 0
01238       if (yydebug)
01239         fprintf(stderr, "Now at end of input.\n");
01240 #endif
01241     }
01242   else
01243     {
01244       yychar1 = YYTRANSLATE(yychar);
01245 
01246 #if YYDEBUG != 0
01247       if (yydebug)
01248         {
01249           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
01250           /* Give the individual parser a way to print the precise meaning
01251              of a token, for further debugging info.  */
01252 #ifdef YYPRINT
01253           YYPRINT (stderr, yychar, yylval);
01254 #endif
01255           fprintf (stderr, ")\n");
01256         }
01257 #endif
01258     }
01259 
01260   yyn += yychar1;
01261   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
01262     goto yydefault;
01263 
01264   yyn = yytable[yyn];
01265 
01266   /* yyn is what to do for this token type in this state.
01267      Negative => reduce, -yyn is rule number.
01268      Positive => shift, yyn is new state.
01269        New state is final state => don't bother to shift,
01270        just return success.
01271      0, or most negative number => error.  */
01272 
01273   if (yyn < 0)
01274     {
01275       if (yyn == YYFLAG)
01276         goto yyerrlab;
01277       yyn = -yyn;
01278       goto yyreduce;
01279     }
01280   else if (yyn == 0)
01281     goto yyerrlab;
01282 
01283   if (yyn == YYFINAL)
01284     YYACCEPT;
01285 
01286   /* Shift the lookahead token.  */
01287 
01288 #if YYDEBUG != 0
01289   if (yydebug)
01290     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
01291 #endif
01292 
01293   /* Discard the token being shifted unless it is eof.  */
01294   if (yychar != YYEOF)
01295     yychar = YYEMPTY;
01296 
01297   *++yyvsp = yylval;
01298 #ifdef YYLSP_NEEDED
01299   *++yylsp = yylloc;
01300 #endif
01301 
01302   /* count tokens shifted since error; after three, turn off error status.  */
01303   if (yyerrstatus) yyerrstatus--;
01304 
01305   yystate = yyn;
01306   goto yynewstate;
01307 
01308 /* Do the default action for the current state.  */
01309 yydefault:
01310 
01311   yyn = yydefact[yystate];
01312   if (yyn == 0)
01313     goto yyerrlab;
01314 
01315 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
01316 yyreduce:
01317   yylen = yyr2[yyn];
01318   if (yylen > 0)
01319     yyval = yyvsp[1-yylen]; /* implement default value of the action */
01320 
01321 #if YYDEBUG != 0
01322   if (yydebug)
01323     {
01324       int i;
01325 
01326       fprintf (stderr, "Reducing via rule %d (line %d), ",
01327                yyn, yyrline[yyn]);
01328 
01329       /* Print the symbols being reduced, and their result.  */
01330       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
01331         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
01332       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
01333     }
01334 #endif
01335 
01336 
01337   switch (yyn) {
01338 
01339 case 1:
01340 #line 160 "grammar.y"
01341 { yyval.node = new NullNode(); ;
01342     break;}
01343 case 2:
01344 #line 161 "grammar.y"
01345 { yyval.node = new BooleanNode(true); ;
01346     break;}
01347 case 3:
01348 #line 162 "grammar.y"
01349 { yyval.node = new BooleanNode(false); ;
01350     break;}
01351 case 4:
01352 #line 163 "grammar.y"
01353 { yyval.node = new NumberNode(yyvsp[0].dval); ;
01354     break;}
01355 case 5:
01356 #line 164 "grammar.y"
01357 { yyval.node = new StringNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ;
01358     break;}
01359 case 6:
01360 #line 165 "grammar.y"
01361 { Lexer *l = Lexer::curr();
01362                                      if (!l->scanRegExp()) YYABORT;
01363                                      yyval.node = new RegExpNode(l->pattern,l->flags);;
01364     break;}
01365 case 7:
01366 #line 169 "grammar.y"
01367 { Lexer *l = Lexer::curr();
01368                                      if (!l->scanRegExp()) YYABORT;
01369                                      yyval.node = new RegExpNode(UString('=')+l->pattern,l->flags);;
01370     break;}
01371 case 8:
01372 #line 175 "grammar.y"
01373 { yyval.node = new ThisNode(); ;
01374     break;}
01375 case 9:
01376 #line 176 "grammar.y"
01377 { yyval.node = new ResolveNode(yyvsp[0].ustr);
01378                                      delete yyvsp[0].ustr; ;
01379     break;}
01380 case 12:
01381 #line 180 "grammar.y"
01382 { yyval.node = new GroupNode(yyvsp[-1].node); ;
01383     break;}
01384 case 13:
01385 #line 181 "grammar.y"
01386 { yyval.node = new ObjectLiteralNode(0L); ;
01387     break;}
01388 case 14:
01389 #line 182 "grammar.y"
01390 { yyval.node = new ObjectLiteralNode(yyvsp[-1].node); ;
01391     break;}
01392 case 15:
01393 #line 186 "grammar.y"
01394 { yyval.node = new ArrayNode(yyvsp[-1].eli); ;
01395     break;}
01396 case 16:
01397 #line 187 "grammar.y"
01398 { yyval.node = new ArrayNode(yyvsp[-1].elm); ;
01399     break;}
01400 case 17:
01401 #line 188 "grammar.y"
01402 { yyval.node = new ArrayNode(yyvsp[-1].eli, yyvsp[-3].elm); ;
01403     break;}
01404 case 18:
01405 #line 192 "grammar.y"
01406 { yyval.elm = new ElementNode(yyvsp[-1].eli, yyvsp[0].node); ;
01407     break;}
01408 case 19:
01409 #line 194 "grammar.y"
01410 { yyval.elm = new ElementNode(yyvsp[-3].elm, yyvsp[-1].eli, yyvsp[0].node); ;
01411     break;}
01412 case 20:
01413 #line 198 "grammar.y"
01414 { yyval.eli = 0L; ;
01415     break;}
01416 case 22:
01417 #line 203 "grammar.y"
01418 { yyval.eli = new ElisionNode(0L); ;
01419     break;}
01420 case 23:
01421 #line 204 "grammar.y"
01422 { yyval.eli = new ElisionNode(yyvsp[-1].eli); ;
01423     break;}
01424 case 24:
01425 #line 208 "grammar.y"
01426 { yyval.node = new PropertyValueNode(yyvsp[-2].node, yyvsp[0].node); ;
01427     break;}
01428 case 25:
01429 #line 210 "grammar.y"
01430 { yyval.node = new PropertyValueNode(yyvsp[-2].node, yyvsp[0].node, yyvsp[-4].node); ;
01431     break;}
01432 case 26:
01433 #line 214 "grammar.y"
01434 { yyval.node = new PropertyNode(yyvsp[0].ustr);
01435                                      delete yyvsp[0].ustr; ;
01436     break;}
01437 case 27:
01438 #line 216 "grammar.y"
01439 { yyval.node = new PropertyNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ;
01440     break;}
01441 case 28:
01442 #line 217 "grammar.y"
01443 { yyval.node = new PropertyNode(yyvsp[0].dval); ;
01444     break;}
01445 case 31:
01446 #line 223 "grammar.y"
01447 { yyval.node = new AccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ;
01448     break;}
01449 case 32:
01450 #line 224 "grammar.y"
01451 { yyval.node = new AccessorNode2(yyvsp[-2].node, yyvsp[0].ustr);
01452                                      delete yyvsp[0].ustr; ;
01453     break;}
01454 case 33:
01455 #line 226 "grammar.y"
01456 { yyval.node = new NewExprNode(yyvsp[-1].node, yyvsp[0].args); ;
01457     break;}
01458 case 35:
01459 #line 231 "grammar.y"
01460 { yyval.node = new NewExprNode(yyvsp[0].node); ;
01461     break;}
01462 case 36:
01463 #line 235 "grammar.y"
01464 { yyval.node = new FunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ;
01465     break;}
01466 case 37:
01467 #line 236 "grammar.y"
01468 { yyval.node = new FunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ;
01469     break;}
01470 case 38:
01471 #line 237 "grammar.y"
01472 { yyval.node = new AccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ;
01473     break;}
01474 case 39:
01475 #line 238 "grammar.y"
01476 { yyval.node = new AccessorNode2(yyvsp[-2].node, yyvsp[0].ustr);
01477                                      delete yyvsp[0].ustr; ;
01478     break;}
01479 case 40:
01480 #line 243 "grammar.y"
01481 { yyval.args = new ArgumentsNode(0L); ;
01482     break;}
01483 case 41:
01484 #line 244 "grammar.y"
01485 { yyval.args = new ArgumentsNode(yyvsp[-1].alist); ;
01486     break;}
01487 case 42:
01488 #line 248 "grammar.y"
01489 { yyval.alist = new ArgumentListNode(yyvsp[0].node); ;
01490     break;}
01491 case 43:
01492 #line 249 "grammar.y"
01493 { yyval.alist = new ArgumentListNode(yyvsp[-2].alist, yyvsp[0].node); ;
01494     break;}
01495 case 47:
01496 #line 259 "grammar.y"
01497 { yyval.node = new PostfixNode(yyvsp[-1].node, OpPlusPlus); ;
01498     break;}
01499 case 48:
01500 #line 260 "grammar.y"
01501 { yyval.node = new PostfixNode(yyvsp[-1].node, OpMinusMinus); ;
01502     break;}
01503 case 50:
01504 #line 265 "grammar.y"
01505 { yyval.node = new DeleteNode(yyvsp[0].node); ;
01506     break;}
01507 case 51:
01508 #line 266 "grammar.y"
01509 { yyval.node = new VoidNode(yyvsp[0].node); ;
01510     break;}
01511 case 52:
01512 #line 267 "grammar.y"
01513 { yyval.node = new TypeOfNode(yyvsp[0].node); ;
01514     break;}
01515 case 53:
01516 #line 268 "grammar.y"
01517 { yyval.node = new PrefixNode(OpPlusPlus, yyvsp[0].node); ;
01518     break;}
01519 case 54:
01520 #line 269 "grammar.y"
01521 { yyval.node = new PrefixNode(OpPlusPlus, yyvsp[0].node); ;
01522     break;}
01523 case 55:
01524 #line 270 "grammar.y"
01525 { yyval.node = new PrefixNode(OpMinusMinus, yyvsp[0].node); ;
01526     break;}
01527 case 56:
01528 #line 271 "grammar.y"
01529 { yyval.node = new PrefixNode(OpMinusMinus, yyvsp[0].node); ;
01530     break;}
01531 case 57:
01532 #line 272 "grammar.y"
01533 { yyval.node = new UnaryPlusNode(yyvsp[0].node); ;
01534     break;}
01535 case 58:
01536 #line 273 "grammar.y"
01537 { yyval.node = new NegateNode(yyvsp[0].node); ;
01538     break;}
01539 case 59:
01540 #line 274 "grammar.y"
01541 { yyval.node = new BitwiseNotNode(yyvsp[0].node); ;
01542     break;}
01543 case 60:
01544 #line 275 "grammar.y"
01545 { yyval.node = new LogicalNotNode(yyvsp[0].node); ;
01546     break;}
01547 case 62:
01548 #line 280 "grammar.y"
01549 { yyval.node = new MultNode(yyvsp[-2].node, yyvsp[0].node, '*'); ;
01550     break;}
01551 case 63:
01552 #line 281 "grammar.y"
01553 { yyval.node = new MultNode(yyvsp[-2].node, yyvsp[0].node, '/'); ;
01554     break;}
01555 case 64:
01556 #line 282 "grammar.y"
01557 { yyval.node = new MultNode(yyvsp[-2].node,yyvsp[0].node,'%'); ;
01558     break;}
01559 case 66:
01560 #line 287 "grammar.y"
01561 { yyval.node = new AddNode(yyvsp[-2].node, yyvsp[0].node, '+'); ;
01562     break;}
01563 case 67:
01564 #line 288 "grammar.y"
01565 { yyval.node = new AddNode(yyvsp[-2].node, yyvsp[0].node, '-'); ;
01566     break;}
01567 case 69:
01568 #line 293 "grammar.y"
01569 { yyval.node = new ShiftNode(yyvsp[-2].node, OpLShift, yyvsp[0].node); ;
01570     break;}
01571 case 70:
01572 #line 294 "grammar.y"
01573 { yyval.node = new ShiftNode(yyvsp[-2].node, OpRShift, yyvsp[0].node); ;
01574     break;}
01575 case 71:
01576 #line 295 "grammar.y"
01577 { yyval.node = new ShiftNode(yyvsp[-2].node, OpURShift, yyvsp[0].node); ;
01578     break;}
01579 case 73:
01580 #line 301 "grammar.y"
01581 { yyval.node = new RelationalNode(yyvsp[-2].node, OpLess, yyvsp[0].node); ;
01582     break;}
01583 case 74:
01584 #line 303 "grammar.y"
01585 { yyval.node = new RelationalNode(yyvsp[-2].node, OpGreater, yyvsp[0].node); ;
01586     break;}
01587 case 75:
01588 #line 305 "grammar.y"
01589 { yyval.node = new RelationalNode(yyvsp[-2].node, OpLessEq, yyvsp[0].node); ;
01590     break;}
01591 case 76:
01592 #line 307 "grammar.y"
01593 { yyval.node = new RelationalNode(yyvsp[-2].node, OpGreaterEq, yyvsp[0].node); ;
01594     break;}
01595 case 77:
01596 #line 309 "grammar.y"
01597 { yyval.node = new RelationalNode(yyvsp[-2].node, OpInstanceOf, yyvsp[0].node); ;
01598     break;}
01599 case 78:
01600 #line 311 "grammar.y"
01601 { yyval.node = new RelationalNode(yyvsp[-2].node, OpIn, yyvsp[0].node); ;
01602     break;}
01603 case 80:
01604 #line 316 "grammar.y"
01605 { yyval.node = new EqualNode(yyvsp[-2].node, OpEqEq, yyvsp[0].node); ;
01606     break;}
01607 case 81:
01608 #line 317 "grammar.y"
01609 { yyval.node = new EqualNode(yyvsp[-2].node, OpNotEq, yyvsp[0].node); ;
01610     break;}
01611 case 82:
01612 #line 318 "grammar.y"
01613 { yyval.node = new EqualNode(yyvsp[-2].node, OpStrEq, yyvsp[0].node); ;
01614     break;}
01615 case 83:
01616 #line 319 "grammar.y"
01617 { yyval.node = new EqualNode(yyvsp[-2].node, OpStrNEq, yyvsp[0].node);;
01618     break;}
01619 case 85:
01620 #line 324 "grammar.y"
01621 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitAnd, yyvsp[0].node); ;
01622     break;}
01623 case 87:
01624 #line 329 "grammar.y"
01625 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitXOr, yyvsp[0].node); ;
01626     break;}
01627 case 89:
01628 #line 334 "grammar.y"
01629 { yyval.node = new BitOperNode(yyvsp[-2].node, OpBitOr, yyvsp[0].node); ;
01630     break;}
01631 case 91:
01632 #line 340 "grammar.y"
01633 { yyval.node = new BinaryLogicalNode(yyvsp[-2].node, OpAnd, yyvsp[0].node); ;
01634     break;}
01635 case 93:
01636 #line 346 "grammar.y"
01637 { yyval.node = new BinaryLogicalNode(yyvsp[-2].node, OpOr, yyvsp[0].node); ;
01638     break;}
01639 case 95:
01640 #line 352 "grammar.y"
01641 { yyval.node = new ConditionalNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ;
01642     break;}
01643 case 97:
01644 #line 358 "grammar.y"
01645 { yyval.node = new AssignNode(yyvsp[-2].node, yyvsp[-1].op, yyvsp[0].node);;
01646     break;}
01647 case 98:
01648 #line 362 "grammar.y"
01649 { yyval.op = OpEqual; ;
01650     break;}
01651 case 99:
01652 #line 363 "grammar.y"
01653 { yyval.op = OpPlusEq; ;
01654     break;}
01655 case 100:
01656 #line 364 "grammar.y"
01657 { yyval.op = OpMinusEq; ;
01658     break;}
01659 case 101:
01660 #line 365 "grammar.y"
01661 { yyval.op = OpMultEq; ;
01662     break;}
01663 case 102:
01664 #line 366 "grammar.y"
01665 { yyval.op = OpDivEq; ;
01666     break;}
01667 case 103:
01668 #line 367 "grammar.y"
01669 { yyval.op = OpLShift; ;
01670     break;}
01671 case 104:
01672 #line 368 "grammar.y"
01673 { yyval.op = OpRShift; ;
01674     break;}
01675 case 105:
01676 #line 369 "grammar.y"
01677 { yyval.op = OpURShift; ;
01678     break;}
01679 case 106:
01680 #line 370 "grammar.y"
01681 { yyval.op = OpAndEq; ;
01682     break;}
01683 case 107:
01684 #line 371 "grammar.y"
01685 { yyval.op = OpXOrEq; ;
01686     break;}
01687 case 108:
01688 #line 372 "grammar.y"
01689 { yyval.op = OpOrEq; ;
01690     break;}
01691 case 109:
01692 #line 373 "grammar.y"
01693 { yyval.op = OpModEq; ;
01694     break;}
01695 case 111:
01696 #line 378 "grammar.y"
01697 { yyval.node = new CommaNode(yyvsp[-2].node, yyvsp[0].node); ;
01698     break;}
01699 case 126:
01700 #line 399 "grammar.y"
01701 { yyval.stat = new BlockNode(0L); DBG(yyval.stat, yylsp[0], yylsp[0]); ;
01702     break;}
01703 case 127:
01704 #line 400 "grammar.y"
01705 { yyval.stat = new BlockNode(yyvsp[-1].srcs); DBG(yyval.stat, yylsp[0], yylsp[0]); ;
01706     break;}
01707 case 128:
01708 #line 404 "grammar.y"
01709 { yyval.slist = new StatListNode(yyvsp[0].stat); ;
01710     break;}
01711 case 129:
01712 #line 405 "grammar.y"
01713 { yyval.slist = new StatListNode(yyvsp[-1].slist, yyvsp[0].stat); ;
01714     break;}
01715 case 130:
01716 #line 409 "grammar.y"
01717 { yyval.stat = new VarStatementNode(yyvsp[-1].vlist);
01718                                       DBG(yyval.stat, yylsp[-2], yylsp[0]); ;
01719     break;}
01720 case 131:
01721 #line 411 "grammar.y"
01722 { if (automatic()) {
01723                                           yyval.stat = new VarStatementNode(yyvsp[-1].vlist);
01724                                           DBG(yyval.stat, yylsp[-2], yylsp[-1]);
01725                                         } else {
01726                                           YYABORT;
01727                                         }
01728                                       ;
01729     break;}
01730 case 132:
01731 #line 421 "grammar.y"
01732 { yyval.vlist = new VarDeclListNode(yyvsp[0].decl); ;
01733     break;}
01734 case 133:
01735 #line 423 "grammar.y"
01736 { yyval.vlist = new VarDeclListNode(yyvsp[-2].vlist, yyvsp[0].decl); ;
01737     break;}
01738 case 134:
01739 #line 427 "grammar.y"
01740 { yyval.decl = new VarDeclNode(yyvsp[0].ustr, 0); delete yyvsp[0].ustr; ;
01741     break;}
01742 case 135:
01743 #line 428 "grammar.y"
01744 { yyval.decl = new VarDeclNode(yyvsp[-1].ustr, yyvsp[0].init); delete yyvsp[-1].ustr; ;
01745     break;}
01746 case 136:
01747 #line 432 "grammar.y"
01748 { yyval.init = new AssignExprNode(yyvsp[0].node); ;
01749     break;}
01750 case 137:
01751 #line 436 "grammar.y"
01752 { yyval.stat = new EmptyStatementNode(); ;
01753     break;}
01754 case 138:
01755 #line 440 "grammar.y"
01756 { yyval.stat = new ExprStatementNode(yyvsp[-1].node);
01757                                      DBG(yyval.stat, yylsp[-1], yylsp[0]); ;
01758     break;}
01759 case 139:
01760 #line 442 "grammar.y"
01761 { if (automatic()) {
01762                                        yyval.stat = new ExprStatementNode(yyvsp[-1].node);
01763                                        DBG(yyval.stat, yylsp[-1], yylsp[-1]);
01764                                      } else
01765                                        YYABORT; ;
01766     break;}
01767 case 140:
01768 #line 450 "grammar.y"
01769 { yyval.stat = new IfNode(yyvsp[-2].node,yyvsp[0].stat,0L);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ;
01770     break;}
01771 case 141:
01772 #line 452 "grammar.y"
01773 { yyval.stat = new IfNode(yyvsp[-4].node,yyvsp[-2].stat,yyvsp[0].stat);DBG(yyval.stat,yylsp[-6],yylsp[-3]); ;
01774     break;}
01775 case 142:
01776 #line 456 "grammar.y"
01777 { yyval.stat=new DoWhileNode(yyvsp[-4].stat,yyvsp[-1].node);DBG(yyval.stat,yylsp[-5],yylsp[-3]);;
01778     break;}
01779 case 143:
01780 #line 457 "grammar.y"
01781 { yyval.stat = new WhileNode(yyvsp[-2].node,yyvsp[0].stat);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ;
01782     break;}
01783 case 144:
01784 #line 459 "grammar.y"
01785 { yyval.stat = new ForNode(yyvsp[-6].node,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat);
01786                                      DBG(yyval.stat,yylsp[-8],yylsp[-1]); ;
01787     break;}
01788 case 145:
01789 #line 462 "grammar.y"
01790 { yyval.stat = new ForNode(yyvsp[-6].vlist,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat);
01791                                      DBG(yyval.stat,yylsp[-9],yylsp[-1]); ;
01792     break;}
01793 case 146:
01794 #line 465 "grammar.y"
01795 { yyval.stat = new ForInNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].stat);
01796                                      DBG(yyval.stat,yylsp[-6],yylsp[-1]); ;
01797     break;}
01798 case 147:
01799 #line 468 "grammar.y"
01800 { yyval.stat = new ForInNode(yyvsp[-4].ustr,0L,yyvsp[-2].node,yyvsp[0].stat);
01801                                      DBG(yyval.stat,yylsp[-7],yylsp[-1]);
01802                                      delete yyvsp[-4].ustr; ;
01803     break;}
01804 case 148:
01805 #line 472 "grammar.y"
01806 { yyval.stat = new ForInNode(yyvsp[-5].ustr,yyvsp[-4].init,yyvsp[-2].node,yyvsp[0].stat);
01807                                      DBG(yyval.stat,yylsp[-8],yylsp[-1]);
01808                                      delete yyvsp[-5].ustr; ;
01809     break;}
01810 case 149:
01811 #line 478 "grammar.y"
01812 { yyval.node = 0L; ;
01813     break;}
01814 case 151:
01815 #line 483 "grammar.y"
01816 { yyval.stat = new ContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
01817     break;}
01818 case 152:
01819 #line 484 "grammar.y"
01820 { if (automatic()) {
01821                                        yyval.stat = new ContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]);
01822                                      } else
01823                                        YYABORT; ;
01824     break;}
01825 case 153:
01826 #line 488 "grammar.y"
01827 { yyval.stat = new ContinueNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[0]);
01828                                      delete yyvsp[-1].ustr; ;
01829     break;}
01830 case 154:
01831 #line 490 "grammar.y"
01832 { if (automatic()) {
01833                                        yyval.stat = new ContinueNode(yyvsp[-1].ustr);DBG(yyval.stat,yylsp[-2],yylsp[-1]);
01834                                        delete yyvsp[-1].ustr;
01835                                      } else
01836                                        YYABORT; ;
01837     break;}
01838 case 155:
01839 #line 498 "grammar.y"
01840 { yyval.stat = new BreakNode();DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
01841     break;}
01842 case 156:
01843 #line 499 "grammar.y"
01844 { if (automatic()) {
01845                                        yyval.stat = new BreakNode(); DBG(yyval.stat,yylsp[-1],yylsp[-1]);
01846                                      } else
01847                                        YYABORT; ;
01848     break;}
01849 case 157:
01850 #line 503 "grammar.y"
01851 { yyval.stat = new BreakNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[0]);
01852                                      delete yyvsp[-1].ustr; ;
01853     break;}
01854 case 158:
01855 #line 505 "grammar.y"
01856 { if (automatic()) {
01857                                        yyval.stat = new BreakNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[-1]);
01858                                        delete yyvsp[-1].ustr;
01859                                      } else
01860                                        YYABORT;
01861                                    ;
01862     break;}
01863 case 159:
01864 #line 514 "grammar.y"
01865 { yyval.stat = new ReturnNode(0L); DBG(yyval.stat,yylsp[-1],yylsp[0]); ;
01866     break;}
01867 case 160:
01868 #line 515 "grammar.y"
01869 { if (automatic()) {
01870                                        yyval.stat = new ReturnNode(0L); DBG(yyval.stat,yylsp[-1],yylsp[-1]);
01871                                      } else
01872                                        YYABORT; ;
01873     break;}
01874 case 161:
01875 #line 519 "grammar.y"
01876 { yyval.stat = new ReturnNode(yyvsp[-1].node); ;
01877     break;}
01878 case 162:
01879 #line 520 "grammar.y"
01880 { if (automatic())
01881                                        yyval.stat = new ReturnNode(yyvsp[-1].node);
01882                                      else
01883                                        YYABORT; ;
01884     break;}
01885 case 163:
01886 #line 527 "grammar.y"
01887 { yyval.stat = new WithNode(yyvsp[-2].node,yyvsp[0].stat);
01888                                      DBG(yyval.stat, yylsp[-4], yylsp[-1]); ;
01889     break;}
01890 case 164:
01891 #line 532 "grammar.y"
01892 { yyval.stat = new SwitchNode(yyvsp[-2].node, yyvsp[0].cblk);
01893                                      DBG(yyval.stat, yylsp[-4], yylsp[-1]); ;
01894     break;}
01895 case 165:
01896 #line 537 "grammar.y"
01897 { yyval.cblk = new CaseBlockNode(yyvsp[-1].clist, 0L, 0L); ;
01898     break;}
01899 case 166:
01900 #line 539 "grammar.y"
01901 { yyval.cblk = new CaseBlockNode(yyvsp[-3].clist, yyvsp[-2].ccl, yyvsp[-1].clist); ;
01902     break;}
01903 case 167:
01904 #line 543 "grammar.y"
01905 { yyval.clist = 0L; ;
01906     break;}
01907 case 169:
01908 #line 548 "grammar.y"
01909 { yyval.clist = new ClauseListNode(yyvsp[0].ccl); ;
01910     break;}
01911 case 170:
01912 #line 549 "grammar.y"
01913 { yyval.clist = yyvsp[-1].clist->append(yyvsp[0].ccl); ;
01914     break;}
01915 case 171:
01916 #line 553 "grammar.y"
01917 { yyval.ccl = new CaseClauseNode(yyvsp[-1].node, 0L); ;
01918     break;}
01919 case 172:
01920 #line 554 "grammar.y"
01921 { yyval.ccl = new CaseClauseNode(yyvsp[-2].node, yyvsp[0].slist); ;
01922     break;}
01923 case 173:
01924 #line 558 "grammar.y"
01925 { yyval.ccl = new CaseClauseNode(0L, 0L);; ;
01926     break;}
01927 case 174:
01928 #line 559 "grammar.y"
01929 { yyval.ccl = new CaseClauseNode(0L, yyvsp[0].slist); ;
01930     break;}
01931 case 175:
01932 #line 563 "grammar.y"
01933 { yyvsp[0].stat->pushLabel(yyvsp[-2].ustr);
01934                                      yyval.stat = new LabelNode(yyvsp[-2].ustr, yyvsp[0].stat);
01935                                      delete yyvsp[-2].ustr; ;
01936     break;}
01937 case 176:
01938 #line 569 "grammar.y"
01939 { yyval.stat = new ThrowNode(yyvsp[-1].node); ;
01940     break;}
01941 case 177:
01942 #line 573 "grammar.y"
01943 { yyval.stat = new TryNode(yyvsp[-1].stat, yyvsp[0].node); ;
01944     break;}
01945 case 178:
01946 #line 574 "grammar.y"
01947 { yyval.stat = new TryNode(yyvsp[-1].stat, 0L, yyvsp[0].node); ;
01948     break;}
01949 case 179:
01950 #line 575 "grammar.y"
01951 { yyval.stat = new TryNode(yyvsp[-2].stat, yyvsp[-1].node, yyvsp[0].node); ;
01952     break;}
01953 case 180:
01954 #line 579 "grammar.y"
01955 { yyval.node = new CatchNode(yyvsp[-2].ustr, yyvsp[0].stat); delete yyvsp[-2].ustr; ;
01956     break;}
01957 case 181:
01958 #line 583 "grammar.y"
01959 { yyval.node = new FinallyNode(yyvsp[0].stat); ;
01960     break;}
01961 case 183:
01962 #line 589 "grammar.y"
01963 { yyval.func = yyvsp[0].func; ;
01964     break;}
01965 case 184:
01966 #line 593 "grammar.y"
01967 { yyval.func = new FuncDeclNode(yyvsp[-3].ustr, 0L, yyvsp[0].body);
01968                                              delete yyvsp[-3].ustr; ;
01969     break;}
01970 case 185:
01971 #line 596 "grammar.y"
01972 { yyval.func = new FuncDeclNode(yyvsp[-4].ustr, yyvsp[-2].param, yyvsp[0].body);
01973                                      delete yyvsp[-4].ustr; ;
01974     break;}
01975 case 186:
01976 #line 601 "grammar.y"
01977 { yyval.node = new FuncExprNode(0L, yyvsp[0].body); ;
01978     break;}
01979 case 187:
01980 #line 603 "grammar.y"
01981 { yyval.node = new FuncExprNode(yyvsp[-2].param, yyvsp[0].body); ;
01982     break;}
01983 case 188:
01984 #line 608 "grammar.y"
01985 { yyval.param = new ParameterNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ;
01986     break;}
01987 case 189:
01988 #line 609 "grammar.y"
01989 { yyval.param = yyvsp[-2].param->append(yyvsp[0].ustr);
01990                                      delete yyvsp[0].ustr; ;
01991     break;}
01992 case 190:
01993 #line 614 "grammar.y"
01994 { yyval.body = new FunctionBodyNode(0L);
01995                                      DBG(yyval.body, yylsp[-1], yylsp[0]);;
01996     break;}
01997 case 191:
01998 #line 616 "grammar.y"
01999 { yyval.body = new FunctionBodyNode(yyvsp[-1].srcs);
02000                                      DBG(yyval.body, yylsp[-2], yylsp[0]);;
02001     break;}
02002 case 192:
02003 #line 621 "grammar.y"
02004 { yyval.prog = new ProgramNode(0L);
02005                                      Parser::progNode = yyval.prog; ;
02006     break;}
02007 case 193:
02008 #line 623 "grammar.y"
02009 { yyval.prog = new ProgramNode(yyvsp[0].srcs);
02010                                      Parser::progNode = yyval.prog; ;
02011     break;}
02012 case 194:
02013 #line 628 "grammar.y"
02014 { yyval.srcs = new SourceElementsNode(yyvsp[0].src); ;
02015     break;}
02016 case 195:
02017 #line 629 "grammar.y"
02018 { yyval.srcs = new SourceElementsNode(yyvsp[-1].srcs, yyvsp[0].src); ;
02019     break;}
02020 case 196:
02021 #line 633 "grammar.y"
02022 { yyval.src = new SourceElementNode(yyvsp[0].stat); ;
02023     break;}
02024 case 197:
02025 #line 634 "grammar.y"
02026 { yyval.src = new SourceElementNode(yyvsp[0].func); ;
02027     break;}
02028 }
02029    /* the action file gets copied in in place of this dollarsign */
02030 #line 543 "/usr/lib/bison.simple"
02031 
02032   yyvsp -= yylen;
02033   yyssp -= yylen;
02034 #ifdef YYLSP_NEEDED
02035   yylsp -= yylen;
02036 #endif
02037 
02038 #if YYDEBUG != 0
02039   if (yydebug)
02040     {
02041       short *ssp1 = yyss - 1;
02042       fprintf (stderr, "state stack now");
02043       while (ssp1 != yyssp)
02044         fprintf (stderr, " %d", *++ssp1);
02045       fprintf (stderr, "\n");
02046     }
02047 #endif
02048 
02049   *++yyvsp = yyval;
02050 
02051 #ifdef YYLSP_NEEDED
02052   yylsp++;
02053   if (yylen == 0)
02054     {
02055       yylsp->first_line = yylloc.first_line;
02056       yylsp->first_column = yylloc.first_column;
02057       yylsp->last_line = (yylsp-1)->last_line;
02058       yylsp->last_column = (yylsp-1)->last_column;
02059       yylsp->text = 0;
02060     }
02061   else
02062     {
02063       yylsp->last_line = (yylsp+yylen-1)->last_line;
02064       yylsp->last_column = (yylsp+yylen-1)->last_column;
02065     }
02066 #endif
02067 
02068   /* Now "shift" the result of the reduction.
02069      Determine what state that goes to,
02070      based on the state we popped back to
02071      and the rule number reduced by.  */
02072 
02073   yyn = yyr1[yyn];
02074 
02075   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
02076   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02077     yystate = yytable[yystate];
02078   else
02079     yystate = yydefgoto[yyn - YYNTBASE];
02080 
02081   goto yynewstate;
02082 
02083 yyerrlab:   /* here on detecting error */
02084 
02085   if (! yyerrstatus)
02086     /* If not already recovering from an error, report this error.  */
02087     {
02088       ++yynerrs;
02089 
02090 #ifdef YYERROR_VERBOSE
02091       yyn = yypact[yystate];
02092 
02093       if (yyn > YYFLAG && yyn < YYLAST)
02094         {
02095           int size = 0;
02096           char *msg;
02097           int x, count;
02098 
02099           count = 0;
02100           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
02101           for (x = (yyn < 0 ? -yyn : 0);
02102                x < (sizeof(yytname) / sizeof(char *)); x++)
02103             if (yycheck[x + yyn] == x)
02104               size += strlen(yytname[x]) + 15, count++;
02105           msg = (char *) malloc(size + 15);
02106           if (msg != 0)
02107             {
02108               strcpy(msg, "parse error");
02109 
02110               if (count < 5)
02111                 {
02112                   count = 0;
02113                   for (x = (yyn < 0 ? -yyn : 0);
02114                        x < (sizeof(yytname) / sizeof(char *)); x++)
02115                     if (yycheck[x + yyn] == x)
02116                       {
02117                         strcat(msg, count == 0 ? ", expecting `" : " or `");
02118                         strcat(msg, yytname[x]);
02119                         strcat(msg, "'");
02120                         count++;
02121                       }
02122                 }
02123               yyerror(msg);
02124               free(msg);
02125             }
02126           else
02127             yyerror ("parse error; also virtual memory exceeded");
02128         }
02129       else
02130 #endif /* YYERROR_VERBOSE */
02131         yyerror("parse error");
02132     }
02133 
02134   goto yyerrlab1;
02135 yyerrlab1:   /* here on error raised explicitly by an action */
02136 
02137   if (yyerrstatus == 3)
02138     {
02139       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
02140 
02141       /* return failure if at end of input */
02142       if (yychar == YYEOF)
02143         YYABORT;
02144 
02145 #if YYDEBUG != 0
02146       if (yydebug)
02147         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
02148 #endif
02149 
02150       yychar = YYEMPTY;
02151     }
02152 
02153   /* Else will try to reuse lookahead token
02154      after shifting the error token.  */
02155 
02156   yyerrstatus = 3;              /* Each real token shifted decrements this */
02157 
02158   goto yyerrhandle;
02159 
02160 yyerrdefault:  /* current state does not do anything special for the error token. */
02161 
02162 #if 0
02163   /* This is wrong; only states that explicitly want error tokens
02164      should shift them.  */
02165   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
02166   if (yyn) goto yydefault;
02167 #endif
02168 
02169 yyerrpop:   /* pop the current state because it cannot handle the error token */
02170 
02171   if (yyssp == yyss) YYABORT;
02172   yyvsp--;
02173   yystate = *--yyssp;
02174 #ifdef YYLSP_NEEDED
02175   yylsp--;
02176 #endif
02177 
02178 #if YYDEBUG != 0
02179   if (yydebug)
02180     {
02181       short *ssp1 = yyss - 1;
02182       fprintf (stderr, "Error: state stack now");
02183       while (ssp1 != yyssp)
02184         fprintf (stderr, " %d", *++ssp1);
02185       fprintf (stderr, "\n");
02186     }
02187 #endif
02188 
02189 yyerrhandle:
02190 
02191   yyn = yypact[yystate];
02192   if (yyn == YYFLAG)
02193     goto yyerrdefault;
02194 
02195   yyn += YYTERROR;
02196   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
02197     goto yyerrdefault;
02198 
02199   yyn = yytable[yyn];
02200   if (yyn < 0)
02201     {
02202       if (yyn == YYFLAG)
02203         goto yyerrpop;
02204       yyn = -yyn;
02205       goto yyreduce;
02206     }
02207   else if (yyn == 0)
02208     goto yyerrpop;
02209 
02210   if (yyn == YYFINAL)
02211     YYACCEPT;
02212 
02213 #if YYDEBUG != 0
02214   if (yydebug)
02215     fprintf(stderr, "Shifting error token, ");
02216 #endif
02217 
02218   *++yyvsp = yylval;
02219 #ifdef YYLSP_NEEDED
02220   *++yylsp = yylloc;
02221 #endif
02222 
02223   yystate = yyn;
02224   goto yynewstate;
02225 
02226  yyacceptlab:
02227   /* YYACCEPT comes here.  */
02228   if (yyfree_stacks)
02229     {
02230       free (yyss);
02231       free (yyvs);
02232 #ifdef YYLSP_NEEDED
02233       free (yyls);
02234 #endif
02235     }
02236   return 0;
02237 
02238  yyabortlab:
02239   /* YYABORT comes here.  */
02240   if (yyfree_stacks)
02241     {
02242       free (yyss);
02243       free (yyvs);
02244 #ifdef YYLSP_NEEDED
02245       free (yyls);
02246 #endif
02247     }
02248   return 1;
02249 }
02250 #line 637 "grammar.y"
02251 
02252 
02253 int yyerror (const char *)  /* Called by yyparse on error */
02254 {
02255 //  fprintf(stderr, "ERROR: %s at line %d\n",
02256 //        s, KJScript::lexer()->lineNo());
02257   return 1;
02258 }
02259 
02260 /* may we automatically insert a semicolon ? */
02261 bool automatic()
02262 {
02263   if (yychar == '}' || yychar == 0)
02264     return true;
02265   else if (Lexer::curr()->prevTerminator())
02266     return true;
02267 
02268   return false;
02269 }
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:08:24 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001