grammar.cpp

00001 /* A Bison parser, made by GNU Bison 2.1.  */
00002 
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019    Boston, MA 02110-1301, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with yy or YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define YYBISON 1
00038 
00039 /* Bison version.  */
00040 #define YYBISON_VERSION "2.1"
00041 
00042 /* Skeleton name.  */
00043 #define YYSKELETON_NAME "yacc.c"
00044 
00045 /* Pure parsers.  */
00046 #define YYPURE 0
00047 
00048 /* Using locations.  */
00049 #define YYLSP_NEEDED 1
00050 
00051 /* Substitute the variable and function names.  */
00052 #define yyparse kjsyyparse
00053 #define yylex   kjsyylex
00054 #define yyerror kjsyyerror
00055 #define yylval  kjsyylval
00056 #define yychar  kjsyychar
00057 #define yydebug kjsyydebug
00058 #define yynerrs kjsyynerrs
00059 #define yylloc kjsyylloc
00060 
00061 /* Tokens.  */
00062 #ifndef YYTOKENTYPE
00063 # define YYTOKENTYPE
00064    /* Put the tokens into the symbol table, so that GDB and other debuggers
00065       know about them.  */
00066    enum yytokentype {
00067      NULLTOKEN = 258,
00068      TRUETOKEN = 259,
00069      FALSETOKEN = 260,
00070      STRING = 261,
00071      NUMBER = 262,
00072      BREAK = 263,
00073      CASE = 264,
00074      DEFAULT = 265,
00075      FOR = 266,
00076      NEW = 267,
00077      VAR = 268,
00078      CONST = 269,
00079      CONTINUE = 270,
00080      FUNCTION = 271,
00081      RETURN = 272,
00082      VOID = 273,
00083      DELETE = 274,
00084      IF = 275,
00085      THIS = 276,
00086      DO = 277,
00087      WHILE = 278,
00088      ELSE = 279,
00089      IN = 280,
00090      INSTANCEOF = 281,
00091      TYPEOF = 282,
00092      SWITCH = 283,
00093      WITH = 284,
00094      RESERVED = 285,
00095      THROW = 286,
00096      TRY = 287,
00097      CATCH = 288,
00098      FINALLY = 289,
00099      EQEQ = 290,
00100      NE = 291,
00101      STREQ = 292,
00102      STRNEQ = 293,
00103      LE = 294,
00104      GE = 295,
00105      OR = 296,
00106      AND = 297,
00107      PLUSPLUS = 298,
00108      MINUSMINUS = 299,
00109      LSHIFT = 300,
00110      RSHIFT = 301,
00111      URSHIFT = 302,
00112      PLUSEQUAL = 303,
00113      MINUSEQUAL = 304,
00114      MULTEQUAL = 305,
00115      DIVEQUAL = 306,
00116      LSHIFTEQUAL = 307,
00117      RSHIFTEQUAL = 308,
00118      URSHIFTEQUAL = 309,
00119      ANDEQUAL = 310,
00120      MODEQUAL = 311,
00121      XOREQUAL = 312,
00122      OREQUAL = 313,
00123      IDENT = 314,
00124      AUTOPLUSPLUS = 315,
00125      AUTOMINUSMINUS = 316
00126    };
00127 #endif
00128 /* Tokens.  */
00129 #define NULLTOKEN 258
00130 #define TRUETOKEN 259
00131 #define FALSETOKEN 260
00132 #define STRING 261
00133 #define NUMBER 262
00134 #define BREAK 263
00135 #define CASE 264
00136 #define DEFAULT 265
00137 #define FOR 266
00138 #define NEW 267
00139 #define VAR 268
00140 #define CONST 269
00141 #define CONTINUE 270
00142 #define FUNCTION 271
00143 #define RETURN 272
00144 #define VOID 273
00145 #define DELETE 274
00146 #define IF 275
00147 #define THIS 276
00148 #define DO 277
00149 #define WHILE 278
00150 #define ELSE 279
00151 #define IN 280
00152 #define INSTANCEOF 281
00153 #define TYPEOF 282
00154 #define SWITCH 283
00155 #define WITH 284
00156 #define RESERVED 285
00157 #define THROW 286
00158 #define TRY 287
00159 #define CATCH 288
00160 #define FINALLY 289
00161 #define EQEQ 290
00162 #define NE 291
00163 #define STREQ 292
00164 #define STRNEQ 293
00165 #define LE 294
00166 #define GE 295
00167 #define OR 296
00168 #define AND 297
00169 #define PLUSPLUS 298
00170 #define MINUSMINUS 299
00171 #define LSHIFT 300
00172 #define RSHIFT 301
00173 #define URSHIFT 302
00174 #define PLUSEQUAL 303
00175 #define MINUSEQUAL 304
00176 #define MULTEQUAL 305
00177 #define DIVEQUAL 306
00178 #define LSHIFTEQUAL 307
00179 #define RSHIFTEQUAL 308
00180 #define URSHIFTEQUAL 309
00181 #define ANDEQUAL 310
00182 #define MODEQUAL 311
00183 #define XOREQUAL 312
00184 #define OREQUAL 313
00185 #define IDENT 314
00186 #define AUTOPLUSPLUS 315
00187 #define AUTOMINUSMINUS 316
00188 
00189 
00190 
00191 
00192 /* Copy the first part of user declarations.  */
00193 #line 1 "grammar.y"
00194 
00195 
00196 /*
00197  *  This file is part of the KDE libraries
00198  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
00199  *
00200  *  This library is free software; you can redistribute it and/or
00201  *  modify it under the terms of the GNU Lesser General Public
00202  *  License as published by the Free Software Foundation; either
00203  *  version 2 of the License, or (at your option) any later version.
00204  *
00205  *  This library is distributed in the hope that it will be useful,
00206  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00207  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00208  *  Lesser General Public License for more details.
00209  *
00210  *  You should have received a copy of the GNU Lesser General Public
00211  *  License along with this library; if not, write to the Free Software
00212  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00213  *
00214  */
00215 
00216 #ifdef HAVE_CONFIG_H
00217 #include <config.h>
00218 #endif
00219 #include <string.h>
00220 #include <stdlib.h>
00221 #include "value.h"
00222 #include "object.h"
00223 #include "types.h"
00224 #include "interpreter.h"
00225 #include "nodes.h"
00226 #include "lexer.h"
00227 #include "internal.h"
00228 
00229 /* default values for bison */
00230 #define YYDEBUG 0
00231 #ifdef YYMAXDEPTH
00232 #undef YYMAXDEPTH
00233 #endif
00234 #define YYERROR_VERBOSE
00235 #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::source); } // location
00236 
00237 extern int yylex();
00238 static int yyerror (const char *);
00239 static bool automatic();
00240 
00241 using namespace KJS;
00242 
00243 
00244 
00245 /* Enabling traces.  */
00246 #ifndef YYDEBUG
00247 # define YYDEBUG 0
00248 #endif
00249 
00250 /* Enabling verbose error messages.  */
00251 #ifdef YYERROR_VERBOSE
00252 # undef YYERROR_VERBOSE
00253 # define YYERROR_VERBOSE 1
00254 #else
00255 # define YYERROR_VERBOSE 0
00256 #endif
00257 
00258 /* Enabling the token table.  */
00259 #ifndef YYTOKEN_TABLE
00260 # define YYTOKEN_TABLE 0
00261 #endif
00262 
00263 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00264 #line 52 "grammar.y"
00265 typedef union YYSTYPE {
00266   int                 ival;
00267   double              dval;
00268   UString             *ustr;
00269   Identifier          *ident;
00270   Node                *node;
00271   StatementNode       *stat;
00272   ParameterNode       *param;
00273   FunctionBodyNode    *body;
00274   FuncDeclNode        *func;
00275   FunctionBodyNode    *prog;
00276   AssignExprNode      *init;
00277   SourceElementsNode  *srcs;
00278   StatListNode        *slist;
00279   ArgumentsNode       *args;
00280   ArgumentListNode    *alist;
00281   VarDeclNode         *decl;
00282   VarDeclListNode     *vlist;
00283   CaseBlockNode       *cblk;
00284   ClauseListNode      *clist;
00285   CaseClauseNode      *ccl;
00286   ElementNode         *elm;
00287   Operator            op;
00288   PropertyValueNode   *plist;
00289   PropertyNode        *pnode;
00290   CatchNode           *cnode;
00291   FinallyNode         *fnode;
00292 } YYSTYPE;
00293 /* Line 196 of yacc.c.  */
00294 #line 295 "grammar.tab.c"
00295 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00296 # define YYSTYPE_IS_DECLARED 1
00297 # define YYSTYPE_IS_TRIVIAL 1
00298 #endif
00299 
00300 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
00301 typedef struct YYLTYPE
00302 {
00303   int first_line;
00304   int first_column;
00305   int last_line;
00306   int last_column;
00307 } YYLTYPE;
00308 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
00309 # define YYLTYPE_IS_DECLARED 1
00310 # define YYLTYPE_IS_TRIVIAL 1
00311 #endif
00312 
00313 
00314 /* Copy the second part of user declarations.  */
00315 
00316 
00317 /* Line 219 of yacc.c.  */
00318 #line 319 "grammar.tab.c"
00319 
00320 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00321 # define YYSIZE_T __SIZE_TYPE__
00322 #endif
00323 #if ! defined (YYSIZE_T) && defined (size_t)
00324 # define YYSIZE_T size_t
00325 #endif
00326 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
00327 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00328 # define YYSIZE_T size_t
00329 #endif
00330 #if ! defined (YYSIZE_T)
00331 # define YYSIZE_T unsigned int
00332 #endif
00333 
00334 #ifndef YY_
00335 # if YYENABLE_NLS
00336 #  if ENABLE_NLS
00337 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00338 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00339 #  endif
00340 # endif
00341 # ifndef YY_
00342 #  define YY_(msgid) msgid
00343 # endif
00344 #endif
00345 
00346 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00347 
00348 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00349 
00350 # ifdef YYSTACK_USE_ALLOCA
00351 #  if YYSTACK_USE_ALLOCA
00352 #   ifdef __GNUC__
00353 #    define YYSTACK_ALLOC __builtin_alloca
00354 #   else
00355 #    define YYSTACK_ALLOC alloca
00356 #    if defined (__STDC__) || defined (__cplusplus)
00357 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00358 #     define YYINCLUDED_STDLIB_H
00359 #    endif
00360 #   endif
00361 #  endif
00362 # endif
00363 
00364 # ifdef YYSTACK_ALLOC
00365    /* Pacify GCC's `empty if-body' warning. */
00366 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00367 #  ifndef YYSTACK_ALLOC_MAXIMUM
00368     /* The OS might guarantee only one guard page at the bottom of the stack,
00369        and a page size can be as small as 4096 bytes.  So we cannot safely
00370        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00371        to allow for a few compiler-allocated temporary stack slots.  */
00372 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
00373 #  endif
00374 # else
00375 #  define YYSTACK_ALLOC YYMALLOC
00376 #  define YYSTACK_FREE YYFREE
00377 #  ifndef YYSTACK_ALLOC_MAXIMUM
00378 #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
00379 #  endif
00380 #  ifdef __cplusplus
00381 extern "C" {
00382 #  endif
00383 #  ifndef YYMALLOC
00384 #   define YYMALLOC malloc
00385 #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
00386     && (defined (__STDC__) || defined (__cplusplus)))
00387 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00388 #   endif
00389 #  endif
00390 #  ifndef YYFREE
00391 #   define YYFREE free
00392 #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
00393     && (defined (__STDC__) || defined (__cplusplus)))
00394 void free (void *); /* INFRINGES ON USER NAME SPACE */
00395 #   endif
00396 #  endif
00397 #  ifdef __cplusplus
00398 }
00399 #  endif
00400 # endif
00401 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
00402 
00403 
00404 #if (! defined (yyoverflow) \
00405      && (! defined (__cplusplus) \
00406      || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
00407              && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
00408 
00409 /* A type that is properly aligned for any stack member.  */
00410 union yyalloc
00411 {
00412   short int yyss;
00413   YYSTYPE yyvs;
00414     YYLTYPE yyls;
00415 };
00416 
00417 /* The size of the maximum gap between one aligned stack and the next.  */
00418 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00419 
00420 /* The size of an array large to enough to hold all stacks, each with
00421    N elements.  */
00422 # define YYSTACK_BYTES(N) \
00423      ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE))  \
00424       + 2 * YYSTACK_GAP_MAXIMUM)
00425 
00426 /* Copy COUNT objects from FROM to TO.  The source and destination do
00427    not overlap.  */
00428 # ifndef YYCOPY
00429 #  if defined (__GNUC__) && 1 < __GNUC__
00430 #   define YYCOPY(To, From, Count) \
00431       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00432 #  else
00433 #   define YYCOPY(To, From, Count)      \
00434       do                    \
00435     {                   \
00436       YYSIZE_T yyi;             \
00437       for (yyi = 0; yyi < (Count); yyi++)   \
00438         (To)[yyi] = (From)[yyi];        \
00439     }                   \
00440       while (0)
00441 #  endif
00442 # endif
00443 
00444 /* Relocate STACK from its old location to the new one.  The
00445    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00446    elements in the stack, and YYPTR gives the new location of the
00447    stack.  Advance YYPTR to a properly aligned location for the next
00448    stack.  */
00449 # define YYSTACK_RELOCATE(Stack)                    \
00450     do                                  \
00451       {                                 \
00452     YYSIZE_T yynewbytes;                        \
00453     YYCOPY (&yyptr->Stack, Stack, yysize);              \
00454     Stack = &yyptr->Stack;                      \
00455     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00456     yyptr += yynewbytes / sizeof (*yyptr);              \
00457       }                                 \
00458     while (0)
00459 
00460 #endif
00461 
00462 #if defined (__STDC__) || defined (__cplusplus)
00463    typedef signed char yysigned_char;
00464 #else
00465    typedef short int yysigned_char;
00466 #endif
00467 
00468 /* YYFINAL -- State number of the termination state. */
00469 #define YYFINAL  191
00470 /* YYLAST -- Last index in YYTABLE.  */
00471 #define YYLAST   1387
00472 
00473 /* YYNTOKENS -- Number of terminals. */
00474 #define YYNTOKENS  86
00475 /* YYNNTS -- Number of nonterminals. */
00476 #define YYNNTS  69
00477 /* YYNRULES -- Number of rules. */
00478 #define YYNRULES  207
00479 /* YYNRULES -- Number of states. */
00480 #define YYNSTATES  373
00481 
00482 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00483 #define YYUNDEFTOK  2
00484 #define YYMAXUTOK   316
00485 
00486 #define YYTRANSLATE(YYX)                        \
00487   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00488 
00489 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00490 static const unsigned char yytranslate[] =
00491 {
00492        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00493        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00494        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00495        2,     2,     2,    75,     2,     2,     2,    77,    80,     2,
00496       63,    64,    76,    72,    67,    73,    71,    62,     2,     2,
00497        2,     2,     2,     2,     2,     2,     2,     2,    70,    85,
00498       78,    84,    79,    83,     2,     2,     2,     2,     2,     2,
00499        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00500        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00501        2,    68,     2,    69,    81,     2,     2,     2,     2,     2,
00502        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00503        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00504        2,     2,     2,    65,    82,    66,    74,     2,     2,     2,
00505        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00506        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00507        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00508        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00509        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00510        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00511        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00512        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00513        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00514        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00515        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00516        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00517        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00518        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00519       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00520       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00521       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
00522       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
00523       55,    56,    57,    58,    59,    60,    61
00524 };
00525 
00526 #if YYDEBUG
00527 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00528    YYRHS.  */
00529 static const unsigned short int yyprhs[] =
00530 {
00531        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
00532       19,    21,    23,    25,    29,    32,    36,    41,    45,    49,
00533       55,    58,    63,    64,    66,    68,    71,    75,    81,    83,
00534       85,    87,    89,    91,    96,   100,   104,   106,   109,   112,
00535      115,   120,   124,   127,   131,   133,   137,   139,   141,   143,
00536      146,   149,   151,   154,   157,   160,   163,   166,   169,   172,
00537      175,   178,   181,   184,   186,   190,   194,   198,   200,   204,
00538      208,   210,   214,   218,   222,   224,   228,   232,   236,   240,
00539      244,   248,   250,   254,   258,   262,   266,   268,   272,   274,
00540      278,   280,   284,   286,   290,   292,   296,   298,   304,   306,
00541      310,   312,   314,   316,   318,   320,   322,   324,   326,   328,
00542      330,   332,   334,   336,   340,   342,   344,   346,   348,   350,
00543      352,   354,   356,   358,   360,   362,   364,   366,   368,   370,
00544      373,   377,   379,   382,   386,   390,   392,   396,   398,   401,
00545      405,   409,   411,   415,   417,   420,   423,   425,   428,   431,
00546      437,   445,   452,   458,   468,   479,   487,   496,   506,   507,
00547      509,   512,   515,   519,   523,   526,   529,   533,   537,   540,
00548      543,   547,   551,   557,   563,   567,   573,   574,   576,   578,
00549      581,   585,   590,   593,   597,   601,   605,   609,   613,   617,
00550      622,   628,   631,   633,   636,   642,   649,   654,   660,   662,
00551      666,   669,   673,   674,   676,   678,   681,   683
00552 };
00553 
00554 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
00555 static const short int yyrhs[] =
00556 {
00557      152,     0,    -1,     3,    -1,     4,    -1,     5,    -1,     7,
00558       -1,     6,    -1,    62,    -1,    51,    -1,    21,    -1,    59,
00559       -1,    87,    -1,    89,    -1,    63,   116,    64,    -1,    65,
00560       66,    -1,    65,    93,    66,    -1,    65,    93,    67,    66,
00561       -1,    68,    91,    69,    -1,    68,    90,    69,    -1,    68,
00562       90,    67,    91,    69,    -1,    91,   114,    -1,    90,    67,
00563       91,   114,    -1,    -1,    92,    -1,    67,    -1,    92,    67,
00564       -1,    94,    70,   114,    -1,    93,    67,    94,    70,   114,
00565       -1,    59,    -1,     6,    -1,     7,    -1,    88,    -1,   149,
00566       -1,    95,    68,   116,    69,    -1,    95,    71,    59,    -1,
00567       12,    95,    98,    -1,    95,    -1,    12,    96,    -1,    95,
00568       98,    -1,    97,    98,    -1,    97,    68,   116,    69,    -1,
00569       97,    71,    59,    -1,    63,    64,    -1,    63,    99,    64,
00570       -1,   114,    -1,    99,    67,   114,    -1,    96,    -1,    97,
00571       -1,   100,    -1,   100,    43,    -1,   100,    44,    -1,   101,
00572       -1,    19,   102,    -1,    18,   102,    -1,    27,   102,    -1,
00573       43,   102,    -1,    60,   102,    -1,    44,   102,    -1,    61,
00574      102,    -1,    72,   102,    -1,    73,   102,    -1,    74,   102,
00575       -1,    75,   102,    -1,   102,    -1,   103,    76,   102,    -1,
00576      103,    62,   102,    -1,   103,    77,   102,    -1,   103,    -1,
00577      104,    72,   103,    -1,   104,    73,   103,    -1,   104,    -1,
00578      105,    45,   104,    -1,   105,    46,   104,    -1,   105,    47,
00579      104,    -1,   105,    -1,   106,    78,   105,    -1,   106,    79,
00580      105,    -1,   106,    39,   105,    -1,   106,    40,   105,    -1,
00581      106,    26,   105,    -1,   106,    25,   105,    -1,   106,    -1,
00582      107,    35,   106,    -1,   107,    36,   106,    -1,   107,    37,
00583      106,    -1,   107,    38,   106,    -1,   107,    -1,   108,    80,
00584      107,    -1,   108,    -1,   109,    81,   108,    -1,   109,    -1,
00585      110,    82,   109,    -1,   110,    -1,   111,    42,   110,    -1,
00586      111,    -1,   112,    41,   111,    -1,   112,    -1,   112,    83,
00587      114,    70,   114,    -1,   113,    -1,   100,   115,   114,    -1,
00588       84,    -1,    48,    -1,    49,    -1,    50,    -1,    51,    -1,
00589       52,    -1,    53,    -1,    54,    -1,    55,    -1,    57,    -1,
00590       58,    -1,    56,    -1,   114,    -1,   116,    67,   114,    -1,
00591      118,    -1,   120,    -1,   123,    -1,   127,    -1,   128,    -1,
00592      129,    -1,   130,    -1,   132,    -1,   133,    -1,   134,    -1,
00593      135,    -1,   136,    -1,   142,    -1,   143,    -1,   144,    -1,
00594       65,    66,    -1,    65,   153,    66,    -1,   117,    -1,   119,
00595      117,    -1,    13,   121,    85,    -1,    13,   121,     1,    -1,
00596      122,    -1,   121,    67,   122,    -1,    59,    -1,    59,   126,
00597       -1,    14,   124,    85,    -1,    14,   124,     1,    -1,   125,
00598       -1,   124,    67,   122,    -1,    59,    -1,    59,   126,    -1,
00599       84,   114,    -1,    85,    -1,   116,    85,    -1,   116,     1,
00600       -1,    20,    63,   116,    64,   117,    -1,    20,    63,   116,
00601       64,   117,    24,   117,    -1,    22,   117,    23,    63,   116,
00602       64,    -1,    23,    63,   116,    64,   117,    -1,    11,    63,
00603      131,    85,   131,    85,   131,    64,   117,    -1,    11,    63,
00604       13,   121,    85,   131,    85,   131,    64,   117,    -1,    11,
00605       63,   100,    25,   116,    64,   117,    -1,    11,    63,    13,
00606       59,    25,   116,    64,   117,    -1,    11,    63,    13,    59,
00607      126,    25,   116,    64,   117,    -1,    -1,   116,    -1,    15,
00608       85,    -1,    15,     1,    -1,    15,    59,    85,    -1,    15,
00609       59,     1,    -1,     8,    85,    -1,     8,     1,    -1,     8,
00610       59,    85,    -1,     8,    59,     1,    -1,    17,    85,    -1,
00611       17,     1,    -1,    17,   116,    85,    -1,    17,   116,     1,
00612       -1,    29,    63,   116,    64,   117,    -1,    28,    63,   116,
00613       64,   137,    -1,    65,   138,    66,    -1,    65,   138,   141,
00614      138,    66,    -1,    -1,   139,    -1,   140,    -1,   139,   140,
00615       -1,     9,   116,    70,    -1,     9,   116,    70,   119,    -1,
00616       10,    70,    -1,    10,    70,   119,    -1,    59,    70,   117,
00617       -1,    31,   116,    85,    -1,    31,   116,     1,    -1,    32,
00618      118,   145,    -1,    32,   118,   146,    -1,    32,   118,   145,
00619      146,    -1,    33,    63,    59,    64,   118,    -1,    34,   118,
00620       -1,   148,    -1,    18,   148,    -1,    16,    59,    63,    64,
00621      151,    -1,    16,    59,    63,   150,    64,   151,    -1,    16,
00622       63,    64,   151,    -1,    16,    63,   150,    64,   151,    -1,
00623       59,    -1,   150,    67,    59,    -1,    65,    66,    -1,    65,
00624      153,    66,    -1,    -1,   153,    -1,   154,    -1,   153,   154,
00625       -1,   117,    -1,   147,    -1
00626 };
00627 
00628 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00629 static const unsigned short int yyrline[] =
00630 {
00631        0,   167,   167,   168,   169,   170,   171,   172,   175,   182,
00632      183,   184,   185,   186,   187,   188,   189,   193,   194,   195,
00633      199,   200,   205,   206,   210,   211,   215,   216,   221,   222,
00634      223,   227,   228,   229,   230,   231,   235,   236,   240,   241,
00635      242,   243,   247,   248,   252,   253,   257,   258,   262,   263,
00636      264,   268,   269,   270,   271,   272,   273,   274,   275,   276,
00637      277,   278,   279,   283,   284,   285,   286,   290,   291,   292,
00638      296,   297,   298,   299,   303,   304,   306,   308,   310,   312,
00639      314,   319,   320,   321,   322,   323,   327,   328,   332,   333,
00640      337,   338,   342,   343,   348,   349,   354,   355,   360,   361,
00641      366,   367,   368,   369,   370,   371,   372,   373,   374,   375,
00642      376,   377,   381,   382,   386,   387,   388,   389,   390,   391,
00643      392,   393,   394,   395,   396,   397,   398,   399,   400,   404,
00644      405,   409,   410,   414,   416,   426,   427,   432,   433,   437,
00645      439,   449,   450,   455,   456,   460,   464,   468,   470,   478,
00646      479,   484,   485,   486,   489,   492,   495,   498,   504,   505,
00647      509,   510,   514,   515,   522,   523,   527,   528,   536,   537,
00648      541,   542,   550,   555,   560,   561,   566,   567,   571,   572,
00649      576,   577,   581,   582,   586,   591,   592,   599,   600,   601,
00650      605,   610,   614,   616,   620,   621,   626,   627,   633,   634,
00651      638,   640,   645,   648,   653,   654,   658,   659
00652 };
00653 #endif
00654 
00655 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00656 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00657    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
00658 static const char *const yytname[] =
00659 {
00660   "$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN",
00661   "STRING", "NUMBER", "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR",
00662   "CONST", "CONTINUE", "FUNCTION", "RETURN", "VOID", "DELETE", "IF",
00663   "THIS", "DO", "WHILE", "ELSE", "IN", "INSTANCEOF", "TYPEOF", "SWITCH",
00664   "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "EQEQ", "NE",
00665   "STREQ", "STRNEQ", "LE", "GE", "OR", "AND", "PLUSPLUS", "MINUSMINUS",
00666   "LSHIFT", "RSHIFT", "URSHIFT", "PLUSEQUAL", "MINUSEQUAL", "MULTEQUAL",
00667   "DIVEQUAL", "LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL", "ANDEQUAL",
00668   "MODEQUAL", "XOREQUAL", "OREQUAL", "IDENT", "AUTOPLUSPLUS",
00669   "AUTOMINUSMINUS", "'/'", "'('", "')'", "'{'", "'}'", "','", "'['", "']'",
00670   "':'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", "'%'", "'<'", "'>'",
00671   "'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept", "Literal",
00672   "PrimaryExpr", "ArrayLiteral", "ElementList", "ElisionOpt", "Elision",
00673   "PropertyNameAndValueList", "PropertyName", "MemberExpr", "NewExpr",
00674   "CallExpr", "Arguments", "ArgumentList", "LeftHandSideExpr",
00675   "PostfixExpr", "UnaryExpr", "MultiplicativeExpr", "AdditiveExpr",
00676   "ShiftExpr", "RelationalExpr", "EqualityExpr", "BitwiseANDExpr",
00677   "BitwiseXORExpr", "BitwiseORExpr", "LogicalANDExpr", "LogicalORExpr",
00678   "ConditionalExpr", "AssignmentExpr", "AssignmentOperator", "Expr",
00679   "Statement", "Block", "StatementList", "VariableStatement",
00680   "VariableDeclarationList", "VariableDeclaration", "ConstStatement",
00681   "ConstDeclarationList", "ConstDeclaration", "Initializer",
00682   "EmptyStatement", "ExprStatement", "IfStatement", "IterationStatement",
00683   "ExprOpt", "ContinueStatement", "BreakStatement", "ReturnStatement",
00684   "WithStatement", "SwitchStatement", "CaseBlock", "CaseClausesOpt",
00685   "CaseClauses", "CaseClause", "DefaultClause", "LabelledStatement",
00686   "ThrowStatement", "TryStatement", "Catch", "Finally",
00687   "FunctionDeclaration", "FunctionDeclarationInternal", "FunctionExpr",
00688   "FormalParameterList", "FunctionBody", "Program", "SourceElements",
00689   "SourceElement", 0
00690 };
00691 #endif
00692 
00693 # ifdef YYPRINT
00694 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00695    token YYLEX-NUM.  */
00696 static const unsigned short int yytoknum[] =
00697 {
00698        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00699      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00700      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00701      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00702      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
00703      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
00704      315,   316,    47,    40,    41,   123,   125,    44,    91,    93,
00705       58,    46,    43,    45,   126,    33,    42,    37,    60,    62,
00706       38,    94,   124,    63,    61,    59
00707 };
00708 # endif
00709 
00710 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00711 static const unsigned char yyr1[] =
00712 {
00713        0,    86,    87,    87,    87,    87,    87,    87,    87,    88,
00714       88,    88,    88,    88,    88,    88,    88,    89,    89,    89,
00715       90,    90,    91,    91,    92,    92,    93,    93,    94,    94,
00716       94,    95,    95,    95,    95,    95,    96,    96,    97,    97,
00717       97,    97,    98,    98,    99,    99,   100,   100,   101,   101,
00718      101,   102,   102,   102,   102,   102,   102,   102,   102,   102,
00719      102,   102,   102,   103,   103,   103,   103,   104,   104,   104,
00720      105,   105,   105,   105,   106,   106,   106,   106,   106,   106,
00721      106,   107,   107,   107,   107,   107,   108,   108,   109,   109,
00722      110,   110,   111,   111,   112,   112,   113,   113,   114,   114,
00723      115,   115,   115,   115,   115,   115,   115,   115,   115,   115,
00724      115,   115,   116,   116,   117,   117,   117,   117,   117,   117,
00725      117,   117,   117,   117,   117,   117,   117,   117,   117,   118,
00726      118,   119,   119,   120,   120,   121,   121,   122,   122,   123,
00727      123,   124,   124,   125,   125,   126,   127,   128,   128,   129,
00728      129,   130,   130,   130,   130,   130,   130,   130,   131,   131,
00729      132,   132,   132,   132,   133,   133,   133,   133,   134,   134,
00730      134,   134,   135,   136,   137,   137,   138,   138,   139,   139,
00731      140,   140,   141,   141,   142,   143,   143,   144,   144,   144,
00732      145,   146,   147,   147,   148,   148,   149,   149,   150,   150,
00733      151,   151,   152,   152,   153,   153,   154,   154
00734 };
00735 
00736 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00737 static const unsigned char yyr2[] =
00738 {
00739        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
00740        1,     1,     1,     3,     2,     3,     4,     3,     3,     5,
00741        2,     4,     0,     1,     1,     2,     3,     5,     1,     1,
00742        1,     1,     1,     4,     3,     3,     1,     2,     2,     2,
00743        4,     3,     2,     3,     1,     3,     1,     1,     1,     2,
00744        2,     1,     2,     2,     2,     2,     2,     2,     2,     2,
00745        2,     2,     2,     1,     3,     3,     3,     1,     3,     3,
00746        1,     3,     3,     3,     1,     3,     3,     3,     3,     3,
00747        3,     1,     3,     3,     3,     3,     1,     3,     1,     3,
00748        1,     3,     1,     3,     1,     3,     1,     5,     1,     3,
00749        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00750        1,     1,     1,     3,     1,     1,     1,     1,     1,     1,
00751        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
00752        3,     1,     2,     3,     3,     1,     3,     1,     2,     3,
00753        3,     1,     3,     1,     2,     2,     1,     2,     2,     5,
00754        7,     6,     5,     9,    10,     7,     8,     9,     0,     1,
00755        2,     2,     3,     3,     2,     2,     3,     3,     2,     2,
00756        3,     3,     5,     5,     3,     5,     0,     1,     1,     2,
00757        3,     4,     2,     3,     3,     3,     3,     3,     3,     4,
00758        5,     2,     1,     2,     5,     6,     4,     5,     1,     3,
00759        2,     3,     0,     1,     1,     2,     1,     1
00760 };
00761 
00762 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00763    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00764    means the default is an error.  */
00765 static const unsigned char yydefact[] =
00766 {
00767      202,     2,     3,     4,     6,     5,     0,     0,     0,     0,
00768        0,     0,     0,     0,     0,     0,     0,     9,     0,     0,
00769        0,     0,     0,     0,     0,     0,     0,     8,    10,     0,
00770        0,     7,     0,     0,    22,     0,     0,     0,     0,   146,
00771       11,    31,    12,    36,    46,    47,    48,    51,    63,    67,
00772       70,    74,    81,    86,    88,    90,    92,    94,    96,    98,
00773      112,     0,   206,   114,   115,   116,   117,   118,   119,   120,
00774      121,   122,   123,   124,   125,   126,   127,   128,   207,   192,
00775       32,     0,   203,   204,   165,     0,   164,   158,     0,    10,
00776        0,    36,    37,   137,     0,   135,   143,     0,   141,   161,
00777        0,   160,     0,     0,   169,     0,   168,     0,    48,    53,
00778      193,    52,     0,     0,     0,    54,     0,     0,     0,     0,
00779        0,    55,    57,     0,    56,    58,     0,     6,     5,    10,
00780       14,     0,     0,     0,    24,     0,     0,    23,    59,    60,
00781       61,    62,     0,     0,     0,    38,     0,     0,    39,    49,
00782       50,   101,   102,   103,   104,   105,   106,   107,   108,   111,
00783      109,   110,   100,     0,     0,     0,     0,     0,     0,     0,
00784        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00785        0,     0,     0,     0,     0,     0,     0,     0,   148,     0,
00786      147,     1,   205,   167,   166,     0,    48,   159,     0,    29,
00787       30,    28,    14,    35,     0,   138,   134,     0,   133,   144,
00788      140,     0,   139,   163,   162,     0,   198,     0,     0,   171,
00789      170,     0,     0,     0,     0,     0,   186,   185,   129,     0,
00790        0,   187,   188,   184,    13,    15,     0,     0,   130,    22,
00791       18,    17,    20,    25,    42,     0,    44,     0,    34,     0,
00792       41,    99,    65,    64,    66,    68,    69,    71,    72,    73,
00793       80,    79,    77,    78,    75,    76,    82,    83,    84,    85,
00794       87,    89,    91,    93,    95,     0,   113,   137,     0,     0,
00795      158,   145,   136,   142,     0,     0,     0,   196,     0,     0,
00796        0,     0,     0,     0,     0,     0,   191,   189,    16,     0,
00797       26,     0,    43,     0,    33,    40,     0,     0,   138,   158,
00798        0,     0,   194,     0,   200,     0,   197,   199,   149,     0,
00799      152,   176,   173,   172,     0,     0,    19,    21,    45,    97,
00800        0,     0,     0,     0,   158,   195,   201,     0,   151,     0,
00801        0,   177,   178,     0,    27,     0,     0,   158,   155,     0,
00802      150,     0,     0,   174,   176,   179,   190,   156,     0,     0,
00803        0,   180,   182,     0,   157,     0,   153,   131,   181,   183,
00804      175,   154,   132
00805 };
00806 
00807 /* YYDEFGOTO[NTERM-NUM]. */
00808 static const short int yydefgoto[] =
00809 {
00810       -1,    40,    41,    42,   135,   136,   137,   131,   132,    43,
00811       44,    45,   145,   245,    46,    47,    48,    49,    50,    51,
00812       52,    53,    54,    55,    56,    57,    58,    59,    60,   163,
00813       61,    62,    63,   368,    64,    94,    95,    65,    97,    98,
00814      205,    66,    67,    68,    69,   198,    70,    71,    72,    73,
00815       74,   322,   340,   341,   342,   354,    75,    76,    77,   231,
00816      232,    78,    79,    80,   218,   287,    81,   133,    83
00817 };
00818 
00819 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00820    STATE-NUM.  */
00821 #define YYPACT_NINF -233
00822 static const short int yypact[] =
00823 {
00824      747,  -233,  -233,  -233,  -233,  -233,     5,   -44,  1280,   -33,
00825      -25,     6,    34,    67,  1188,  1261,     3,  -233,   822,    45,
00826     1261,    54,    60,  1261,    -7,  1261,  1261,  -233,    55,  1261,
00827     1261,  -233,  1261,   372,    31,  1261,  1261,  1261,  1261,  -233,
00828     -233,  -233,  -233,   -20,  -233,   -14,   876,  -233,  -233,   -35,
00829      139,   154,   131,     9,    51,   -21,    85,    96,    -3,  -233,
00830     -233,    11,  -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,
00831     -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,
00832     -233,   233,   747,  -233,  -233,    16,  -233,   896,   109,  -233,
00833       33,   -20,  -233,   150,    28,  -233,   150,    36,  -233,  -233,
00834       27,  -233,   173,    23,  -233,  1261,  -233,    49,   172,  -233,
00835     -233,  -233,  1261,   237,  1261,  -233,  1261,  1261,    52,   447,
00836      194,  -233,  -233,   822,  -233,  -233,    86,   191,   195,    55,
00837      235,   163,   198,   522,  -233,   127,   969,   204,  -233,  -233,
00838     -233,  -233,  1042,  1261,   214,  -233,  1261,   218,  -233,  -233,
00839     -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,  -233,
00840     -233,  -233,  -233,  1261,  1261,  1261,  1261,  1261,  1261,  1261,
00841     1261,  1261,  1261,  1261,  1261,  1261,  1261,  1261,  1261,  1261,
00842     1261,  1261,  1261,  1261,  1261,  1261,  1261,  1261,  -233,  1261,
00843     -233,  -233,  -233,  -233,  -233,   219,  1303,   212,   197,  -233,
00844     -233,  -233,  -233,  -233,  1261,  -233,  -233,   -33,  -233,  -233,
00845     -233,   -33,  -233,  -233,  -233,    25,  -233,   215,    87,  -233,
00846     -233,    91,   220,   102,   110,   112,  -233,  -233,  -233,   221,
00847       -7,   251,  -233,  -233,  -233,  -233,    56,  1261,  -233,    31,
00848     -233,  -233,  -233,  -233,  -233,   116,  -233,   152,  -233,   153,
00849     -233,  -233,  -233,  -233,  -233,   -35,   -35,   139,   139,   139,
00850      154,   154,   154,   154,   154,   154,   131,   131,   131,   131,
00851        9,    51,   -21,    85,    96,   216,  -233,    -9,   -49,  1261,
00852     1261,  -233,  -233,  -233,   215,   118,   597,  -233,   215,   228,
00853      822,  1261,   822,   224,   822,   231,  -233,  -233,  -233,   222,
00854     -233,  1115,  -233,  1261,  -233,  -233,  1261,  1261,   266,  1261,
00855      120,   213,  -233,   215,  -233,   672,  -233,  -233,   278,   124,
00856     -233,   294,  -233,  -233,   240,  1261,  -233,  -233,  -233,  -233,
00857      125,  1261,   223,   822,  1261,  -233,  -233,   822,  -233,  1261,
00858        1,   294,  -233,    -7,  -233,   822,   126,  1261,  -233,   241,
00859     -233,   128,   236,  -233,   294,  -233,  -233,  -233,   822,   243,
00860      822,   822,   822,   245,  -233,   822,  -233,  -233,   822,   822,
00861     -233,  -233,  -233
00862 };
00863 
00864 /* YYPGOTO[NTERM-NUM].  */
00865 static const short int yypgoto[] =
00866 {
00867     -233,  -233,  -233,  -233,  -233,    73,  -233,  -233,    77,   306,
00868      308,  -233,   -22,  -233,   188,  -233,    -5,    64,    35,   -28,
00869      -16,   135,   140,   134,   137,   142,  -233,  -233,  -128,  -233,
00870      -10,   -18,   -23,   -37,  -233,   136,   -87,  -233,  -233,  -233,
00871      -91,  -233,  -233,  -233,  -233,  -166,  -233,  -233,  -233,  -233,
00872     -233,  -233,   -24,  -233,   -15,  -233,  -233,  -233,  -233,  -233,
00873      101,  -233,   319,  -233,   119,  -232,  -233,     2,   -78
00874 };
00875 
00876 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00877    positive, shift that token.  If negative, reduce the rule which
00878    number is the opposite.  If zero, do what YYDEFACT says.
00879    If YYTABLE_NINF, syntax error.  */
00880 #define YYTABLE_NINF -130
00881 static const short int yytable[] =
00882 {
00883      113,   120,    82,   107,   192,   209,    84,    99,   242,   109,
00884      111,   352,   188,   118,   246,   115,   307,   193,   207,    87,
00885      121,   122,   126,   148,   124,   125,    93,   164,   213,   206,
00886      138,   139,   140,   141,    96,   251,   309,   210,   186,   199,
00887      200,   165,   166,   142,   178,   179,   180,   181,   143,   142,
00888      219,   144,   312,   226,   146,   192,   316,   147,   119,   275,
00889      183,   276,   199,   200,    85,   100,   112,   353,   104,   203,
00890        1,     2,     3,     4,     5,   204,   281,   197,   189,     8,
00891      187,   335,   216,    88,   216,   105,    15,   217,    17,   284,
00892       86,   101,   201,   102,    20,   207,   190,   103,   134,   202,
00893      109,   194,   221,   211,   223,   233,   224,   225,   114,   300,
00894       25,    26,   214,   208,   311,   201,   189,   116,    27,   189,
00895      282,   212,   298,   117,   283,   123,    89,    29,    30,    31,
00896       32,   182,    90,   247,   220,    34,   249,   227,   185,    35,
00897       36,    37,    38,   332,   260,   261,   262,   263,   264,   265,
00898      234,   288,   106,   189,   289,   290,   172,   173,   189,   252,
00899      253,   254,   266,   267,   268,   269,   292,   184,   349,   189,
00900      174,   175,   103,   327,   293,   328,   294,   189,   329,   189,
00901      302,   359,   313,   303,   333,   289,   308,   189,   338,   345,
00902      358,   189,   189,   189,   239,   189,   240,   344,   361,   169,
00903      170,   171,   108,   108,   257,   258,   259,   296,   108,   176,
00904      177,   167,   168,   108,   108,   149,   150,   108,   108,   189,
00905      189,   304,   305,   108,   108,   108,   108,   229,   230,   235,
00906      236,   255,   256,   191,   204,  -129,   215,   192,  -129,  -129,
00907     -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,
00908     -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,  -129,
00909      222,   -29,  -129,  -129,  -129,   -30,  -129,  -129,   237,   310,
00910      197,   243,   318,   248,   320,   196,   323,   250,   277,   189,
00911      286,   319,   280,   291,   295,   230,   306,   317,   315,   321,
00912      324,   331,   325,   108,  -129,  -129,  -129,   330,   334,   197,
00913     -129,  -129,   337,   339,   343,   360,   362,   365,   347,  -129,
00914     -129,   370,   301,   299,    91,   348,    92,   270,   272,   350,
00915      356,   346,   273,   271,   197,   369,   355,   357,   274,   351,
00916      363,   278,   297,   110,   285,     0,     0,   197,     0,     0,
00917      364,     0,   366,   367,   367,     0,     0,   371,     0,     0,
00918      372,   372,   108,   108,   108,   108,   108,   108,   108,   108,
00919      108,   108,   108,   108,   108,   108,   108,   108,   108,   108,
00920      108,   108,   108,   108,   108,     1,     2,     3,   127,   128,
00921        6,     0,     0,     7,     8,     9,    10,    11,    12,    13,
00922       14,    15,    16,    17,    18,    19,     0,     0,     0,    20,
00923       21,    22,     0,    23,    24,     0,     0,     0,     0,     0,
00924        0,     0,     0,     0,     0,    25,    26,     0,     0,     0,
00925        0,     0,     0,    27,     0,     0,     0,     0,     0,     0,
00926        0,   129,    29,    30,    31,    32,     0,    33,   130,     0,
00927       34,     0,     0,     0,    35,    36,    37,    38,     0,     0,
00928        1,     2,     3,     4,     5,     6,     0,    39,     7,     8,
00929        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
00930       19,     0,     0,     0,    20,    21,    22,     0,    23,    24,
00931        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00932       25,    26,     0,     0,     0,     0,     0,     0,    27,     0,
00933        0,     0,     0,     0,     0,     0,    28,    29,    30,    31,
00934       32,     0,    33,   228,     0,    34,     0,     0,     0,    35,
00935       36,    37,    38,     0,     0,     1,     2,     3,     4,     5,
00936        6,     0,    39,     7,     8,     9,    10,    11,    12,    13,
00937       14,    15,    16,    17,    18,    19,     0,     0,     0,    20,
00938       21,    22,     0,    23,    24,     0,     0,     0,     0,     0,
00939        0,     0,     0,     0,     0,    25,    26,     0,     0,     0,
00940        0,     0,     0,    27,     0,     0,     0,     0,     0,     0,
00941        0,    28,    29,    30,    31,    32,     0,    33,   238,     0,
00942       34,     0,     0,     0,    35,    36,    37,    38,     0,     0,
00943        1,     2,     3,     4,     5,     6,     0,    39,     7,     8,
00944        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
00945       19,     0,     0,     0,    20,    21,    22,     0,    23,    24,
00946        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00947       25,    26,     0,     0,     0,     0,     0,     0,    27,     0,
00948        0,     0,     0,     0,     0,     0,    28,    29,    30,    31,
00949       32,     0,    33,   314,     0,    34,     0,     0,     0,    35,
00950       36,    37,    38,     0,     0,     1,     2,     3,     4,     5,
00951        6,     0,    39,     7,     8,     9,    10,    11,    12,    13,
00952       14,    15,    16,    17,    18,    19,     0,     0,     0,    20,
00953       21,    22,     0,    23,    24,     0,     0,     0,     0,     0,
00954        0,     0,     0,     0,     0,    25,    26,     0,     0,     0,
00955        0,     0,     0,    27,     0,     0,     0,     0,     0,     0,
00956        0,    28,    29,    30,    31,    32,     0,    33,   336,     0,
00957       34,     0,     0,     0,    35,    36,    37,    38,     0,     0,
00958        1,     2,     3,     4,     5,     6,     0,    39,     7,     8,
00959        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
00960       19,     0,     0,     0,    20,    21,    22,     0,    23,    24,
00961        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00962       25,    26,     0,     0,     0,     0,     0,     0,    27,     0,
00963        0,     0,     0,     0,     0,     0,    28,    29,    30,    31,
00964       32,     0,    33,     0,     0,    34,     0,     0,     0,    35,
00965       36,    37,    38,     0,     0,     1,     2,     3,     4,     5,
00966        6,     0,    39,     7,     8,     9,    10,    11,    88,    13,
00967      105,    15,    16,    17,    18,    19,     0,     0,     0,    20,
00968       21,    22,     0,    23,    24,     0,     0,     0,     0,     0,
00969        0,     0,     0,     0,     0,    25,    26,     0,     0,     0,
00970        0,     0,     0,    27,     0,     0,     0,     0,     0,     0,
00971        0,    28,    29,    30,    31,    32,     0,    33,     0,     0,
00972       34,     0,     0,     0,    35,    36,    37,    38,     0,     1,
00973        2,     3,     4,     5,     0,     0,     0,    39,     8,   195,
00974        0,     0,    88,     0,   105,    15,     0,    17,     0,   149,
00975      150,     0,     0,    20,   151,   152,   153,   154,   155,   156,
00976      157,   158,   159,   160,   161,     0,     0,     0,     0,    25,
00977       26,     0,     0,     0,     0,     0,     0,    27,     0,     0,
00978        0,     0,     0,     0,     0,    89,    29,    30,    31,    32,
00979      162,    90,     0,     0,    34,     0,     0,     0,    35,    36,
00980       37,    38,     1,     2,     3,     4,     5,     0,     0,     0,
00981        0,     8,     0,     0,     0,    88,     0,   105,    15,     0,
00982       17,     0,     0,     0,     0,     0,    20,     0,     0,     0,
00983        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00984        0,     0,    25,    26,     0,     0,     0,     0,     0,     0,
00985       27,     0,     0,     0,     0,     0,     0,     0,    89,    29,
00986       30,    31,    32,     0,    90,     0,     0,    34,   241,     0,
00987        0,    35,    36,    37,    38,     1,     2,     3,     4,     5,
00988        0,     0,     0,     0,     8,     0,     0,     0,    88,     0,
00989      105,    15,     0,    17,     0,     0,     0,     0,     0,    20,
00990        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00991        0,     0,     0,     0,     0,    25,    26,     0,     0,     0,
00992        0,     0,     0,    27,     0,     0,     0,     0,     0,     0,
00993        0,    89,    29,    30,    31,    32,   244,    90,     0,     0,
00994       34,     0,     0,     0,    35,    36,    37,    38,     1,     2,
00995        3,     4,     5,     0,     0,     0,     0,     8,     0,     0,
00996        0,    88,     0,   105,    15,     0,    17,     0,     0,     0,
00997        0,     0,    20,     0,     0,     0,     0,     0,     0,     0,
00998        0,     0,     0,     0,     0,     0,     0,     0,    25,    26,
00999        0,     0,     0,     0,     0,     0,    27,     0,     0,     0,
01000        0,     0,     0,     0,    89,    29,    30,    31,    32,     0,
01001       90,     0,     0,    34,   326,     0,     0,    35,    36,    37,
01002       38,     1,     2,     3,     4,     5,     0,     0,     0,     0,
01003        8,     0,     0,     0,    12,     0,   105,    15,     0,    17,
01004        0,     0,     0,     0,     0,    20,     0,     0,     0,     0,
01005        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01006        0,    25,    26,     0,     0,     0,     0,     0,     0,    27,
01007        0,     0,     0,     0,     0,     0,     0,    89,    29,    30,
01008       31,    32,     0,    90,     0,     0,    34,     0,     0,     0,
01009       35,    36,    37,    38,     1,     2,     3,     4,     5,     0,
01010        0,     0,     0,     8,     0,     0,     0,    88,     0,   105,
01011       15,     0,    17,     1,     2,     3,     4,     5,    20,     0,
01012        0,     0,     8,     0,     0,     0,    88,     0,     0,     0,
01013        0,    17,     0,     0,    25,    26,     0,     0,     0,     0,
01014        0,     0,    27,     0,     0,     0,     0,     0,     0,     0,
01015       89,    29,    30,    31,    32,     0,    90,     0,   279,    34,
01016        0,    27,     0,    35,    36,    37,    38,     0,     0,    89,
01017        0,     0,    31,    32,     0,    90,   149,   150,    34,     0,
01018        0,   151,   152,   153,   154,   155,   156,   157,   158,   159,
01019      160,   161,     0,     0,     0,     0,     0,     0,     0,     0,
01020        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01021        0,     0,     0,     0,     0,     0,     0,   162
01022 };
01023 
01024 static const short int yycheck[] =
01025 {
01026       18,    24,     0,    13,    82,    96,     1,     1,   136,    14,
01027       15,    10,     1,    23,   142,    20,    25,     1,    67,    63,
01028       25,    26,    32,    45,    29,    30,    59,    62,     1,     1,
01029       35,    36,    37,    38,    59,   163,    85,     1,    41,     6,
01030        7,    76,    77,    63,    35,    36,    37,    38,    68,    63,
01031        1,    71,   284,     1,    68,   133,   288,    71,    65,   187,
01032       81,   189,     6,     7,    59,    59,    63,    66,     1,    91,
01033        3,     4,     5,     6,     7,    84,   204,    87,    67,    12,
01034       83,   313,    59,    16,    59,    18,    19,    64,    21,    64,
01035       85,    85,    59,    59,    27,    67,    85,    63,    67,    66,
01036      105,    85,   112,    67,   114,   123,   116,   117,    63,   237,
01037       43,    44,    85,    85,   280,    59,    67,    63,    51,    67,
01038      207,    85,    66,    63,   211,    70,    59,    60,    61,    62,
01039       63,    80,    65,   143,    85,    68,   146,    85,    42,    72,
01040       73,    74,    75,   309,   172,   173,   174,   175,   176,   177,
01041       64,    64,    85,    67,    67,    64,    25,    26,    67,   164,
01042      165,   166,   178,   179,   180,   181,    64,    82,   334,    67,
01043       39,    40,    63,   301,    64,   303,    64,    67,   306,    67,
01044       64,   347,    64,    67,    64,    67,   277,    67,    64,    64,
01045       64,    67,    67,    67,    67,    67,    69,   325,    70,    45,
01046       46,    47,    14,    15,   169,   170,   171,   230,    20,    78,
01047       79,    72,    73,    25,    26,    43,    44,    29,    30,    67,
01048       67,    69,    69,    35,    36,    37,    38,    33,    34,    66,
01049       67,   167,   168,     0,    84,     0,    63,   315,     3,     4,
01050        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01051       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01052       23,    70,    27,    28,    29,    70,    31,    32,    70,   279,
01053      280,    67,   290,    59,   292,    87,   294,    59,    59,    67,
01054       65,   291,    85,    63,    63,    34,    70,    59,   286,    65,
01055       59,    25,    70,   105,    59,    60,    61,   307,    85,   309,
01056       65,    66,    24,     9,    64,    64,    70,    64,    85,    74,
01057       75,    66,   239,   236,     8,   333,     8,   182,   184,   337,
01058      343,   331,   185,   183,   334,   362,   341,   345,   186,   339,
01059      354,   195,   231,    14,   215,    -1,    -1,   347,    -1,    -1,
01060      358,    -1,   360,   361,   362,    -1,    -1,   365,    -1,    -1,
01061      368,   369,   164,   165,   166,   167,   168,   169,   170,   171,
01062      172,   173,   174,   175,   176,   177,   178,   179,   180,   181,
01063      182,   183,   184,   185,   186,     3,     4,     5,     6,     7,
01064        8,    -1,    -1,    11,    12,    13,    14,    15,    16,    17,
01065       18,    19,    20,    21,    22,    23,    -1,    -1,    -1,    27,
01066       28,    29,    -1,    31,    32,    -1,    -1,    -1,    -1,    -1,
01067       -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,
01068       -1,    -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,
01069       -1,    59,    60,    61,    62,    63,    -1,    65,    66,    -1,
01070       68,    -1,    -1,    -1,    72,    73,    74,    75,    -1,    -1,
01071        3,     4,     5,     6,     7,     8,    -1,    85,    11,    12,
01072       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
01073       23,    -1,    -1,    -1,    27,    28,    29,    -1,    31,    32,
01074       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01075       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,
01076       -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    61,    62,
01077       63,    -1,    65,    66,    -1,    68,    -1,    -1,    -1,    72,
01078       73,    74,    75,    -1,    -1,     3,     4,     5,     6,     7,
01079        8,    -1,    85,    11,    12,    13,    14,    15,    16,    17,
01080       18,    19,    20,    21,    22,    23,    -1,    -1,    -1,    27,
01081       28,    29,    -1,    31,    32,    -1,    -1,    -1,    -1,    -1,
01082       -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,
01083       -1,    -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,
01084       -1,    59,    60,    61,    62,    63,    -1,    65,    66,    -1,
01085       68,    -1,    -1,    -1,    72,    73,    74,    75,    -1,    -1,
01086        3,     4,     5,     6,     7,     8,    -1,    85,    11,    12,
01087       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
01088       23,    -1,    -1,    -1,    27,    28,    29,    -1,    31,    32,
01089       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01090       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,
01091       -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    61,    62,
01092       63,    -1,    65,    66,    -1,    68,    -1,    -1,    -1,    72,
01093       73,    74,    75,    -1,    -1,     3,     4,     5,     6,     7,
01094        8,    -1,    85,    11,    12,    13,    14,    15,    16,    17,
01095       18,    19,    20,    21,    22,    23,    -1,    -1,    -1,    27,
01096       28,    29,    -1,    31,    32,    -1,    -1,    -1,    -1,    -1,
01097       -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,
01098       -1,    -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,
01099       -1,    59,    60,    61,    62,    63,    -1,    65,    66,    -1,
01100       68,    -1,    -1,    -1,    72,    73,    74,    75,    -1,    -1,
01101        3,     4,     5,     6,     7,     8,    -1,    85,    11,    12,
01102       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
01103       23,    -1,    -1,    -1,    27,    28,    29,    -1,    31,    32,
01104       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01105       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,
01106       -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    61,    62,
01107       63,    -1,    65,    -1,    -1,    68,    -1,    -1,    -1,    72,
01108       73,    74,    75,    -1,    -1,     3,     4,     5,     6,     7,
01109        8,    -1,    85,    11,    12,    13,    14,    15,    16,    17,
01110       18,    19,    20,    21,    22,    23,    -1,    -1,    -1,    27,
01111       28,    29,    -1,    31,    32,    -1,    -1,    -1,    -1,    -1,
01112       -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,
01113       -1,    -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,
01114       -1,    59,    60,    61,    62,    63,    -1,    65,    -1,    -1,
01115       68,    -1,    -1,    -1,    72,    73,    74,    75,    -1,     3,
01116        4,     5,     6,     7,    -1,    -1,    -1,    85,    12,    13,
01117       -1,    -1,    16,    -1,    18,    19,    -1,    21,    -1,    43,
01118       44,    -1,    -1,    27,    48,    49,    50,    51,    52,    53,
01119       54,    55,    56,    57,    58,    -1,    -1,    -1,    -1,    43,
01120       44,    -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,    -1,
01121       -1,    -1,    -1,    -1,    -1,    59,    60,    61,    62,    63,
01122       84,    65,    -1,    -1,    68,    -1,    -1,    -1,    72,    73,
01123       74,    75,     3,     4,     5,     6,     7,    -1,    -1,    -1,
01124       -1,    12,    -1,    -1,    -1,    16,    -1,    18,    19,    -1,
01125       21,    -1,    -1,    -1,    -1,    -1,    27,    -1,    -1,    -1,
01126       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01127       -1,    -1,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
01128       51,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,    60,
01129       61,    62,    63,    -1,    65,    -1,    -1,    68,    69,    -1,
01130       -1,    72,    73,    74,    75,     3,     4,     5,     6,     7,
01131       -1,    -1,    -1,    -1,    12,    -1,    -1,    -1,    16,    -1,
01132       18,    19,    -1,    21,    -1,    -1,    -1,    -1,    -1,    27,
01133       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01134       -1,    -1,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,
01135       -1,    -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,
01136       -1,    59,    60,    61,    62,    63,    64,    65,    -1,    -1,
01137       68,    -1,    -1,    -1,    72,    73,    74,    75,     3,     4,
01138        5,     6,     7,    -1,    -1,    -1,    -1,    12,    -1,    -1,
01139       -1,    16,    -1,    18,    19,    -1,    21,    -1,    -1,    -1,
01140       -1,    -1,    27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01141       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    43,    44,
01142       -1,    -1,    -1,    -1,    -1,    -1,    51,    -1,    -1,    -1,
01143       -1,    -1,    -1,    -1,    59,    60,    61,    62,    63,    -1,
01144       65,    -1,    -1,    68,    69,    -1,    -1,    72,    73,    74,
01145       75,     3,     4,     5,     6,     7,    -1,    -1,    -1,    -1,
01146       12,    -1,    -1,    -1,    16,    -1,    18,    19,    -1,    21,
01147       -1,    -1,    -1,    -1,    -1,    27,    -1,    -1,    -1,    -1,
01148       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01149       -1,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    51,
01150       -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,    60,    61,
01151       62,    63,    -1,    65,    -1,    -1,    68,    -1,    -1,    -1,
01152       72,    73,    74,    75,     3,     4,     5,     6,     7,    -1,
01153       -1,    -1,    -1,    12,    -1,    -1,    -1,    16,    -1,    18,
01154       19,    -1,    21,     3,     4,     5,     6,     7,    27,    -1,
01155       -1,    -1,    12,    -1,    -1,    -1,    16,    -1,    -1,    -1,
01156       -1,    21,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,
01157       -1,    -1,    51,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01158       59,    60,    61,    62,    63,    -1,    65,    -1,    25,    68,
01159       -1,    51,    -1,    72,    73,    74,    75,    -1,    -1,    59,
01160       -1,    -1,    62,    63,    -1,    65,    43,    44,    68,    -1,
01161       -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
01162       57,    58,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01163       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
01164       -1,    -1,    -1,    -1,    -1,    -1,    -1,    84
01165 };
01166 
01167 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
01168    symbol of state STATE-NUM.  */
01169 static const unsigned char yystos[] =
01170 {
01171        0,     3,     4,     5,     6,     7,     8,    11,    12,    13,
01172       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
01173       27,    28,    29,    31,    32,    43,    44,    51,    59,    60,
01174       61,    62,    63,    65,    68,    72,    73,    74,    75,    85,
01175       87,    88,    89,    95,    96,    97,   100,   101,   102,   103,
01176      104,   105,   106,   107,   108,   109,   110,   111,   112,   113,
01177      114,   116,   117,   118,   120,   123,   127,   128,   129,   130,
01178      132,   133,   134,   135,   136,   142,   143,   144,   147,   148,
01179      149,   152,   153,   154,     1,    59,    85,    63,    16,    59,
01180       65,    95,    96,    59,   121,   122,    59,   124,   125,     1,
01181       59,    85,    59,    63,     1,    18,    85,   116,   100,   102,
01182      148,   102,    63,   117,    63,   102,    63,    63,   116,    65,
01183      118,   102,   102,    70,   102,   102,   116,     6,     7,    59,
01184       66,    93,    94,   153,    67,    90,    91,    92,   102,   102,
01185      102,   102,    63,    68,    71,    98,    68,    71,    98,    43,
01186       44,    48,    49,    50,    51,    52,    53,    54,    55,    56,
01187       57,    58,    84,   115,    62,    76,    77,    72,    73,    45,
01188       46,    47,    25,    26,    39,    40,    78,    79,    35,    36,
01189       37,    38,    80,    81,    82,    42,    41,    83,     1,    67,
01190       85,     0,   154,     1,    85,    13,   100,   116,   131,     6,
01191        7,    59,    66,    98,    84,   126,     1,    67,    85,   126,
01192        1,    67,    85,     1,    85,    63,    59,    64,   150,     1,
01193       85,   116,    23,   116,   116,   116,     1,    85,    66,    33,
01194       34,   145,   146,   117,    64,    66,    67,    70,    66,    67,
01195       69,    69,   114,    67,    64,    99,   114,   116,    59,   116,
01196       59,   114,   102,   102,   102,   103,   103,   104,   104,   104,
01197      105,   105,   105,   105,   105,   105,   106,   106,   106,   106,
01198      107,   108,   109,   110,   111,   114,   114,    59,   121,    25,
01199       85,   114,   122,   122,    64,   150,    65,   151,    64,    67,
01200       64,    63,    64,    64,    64,    63,   118,   146,    66,    94,
01201      114,    91,    64,    67,    69,    69,    70,    25,   126,    85,
01202      116,   131,   151,    64,    66,   153,   151,    59,   117,   116,
01203      117,    65,   137,   117,    59,    70,    69,   114,   114,   114,
01204      116,    25,   131,    64,    85,   151,    66,    24,    64,     9,
01205      138,   139,   140,    64,   114,    64,   116,    85,   117,   131,
01206      117,   116,    10,    66,   141,   140,   118,   117,    64,   131,
01207       64,    70,    70,   138,   117,    64,   117,   117,   119,   119,
01208       66,   117,   117
01209 };
01210 
01211 #define yyerrok     (yyerrstatus = 0)
01212 #define yyclearin   (yychar = YYEMPTY)
01213 #define YYEMPTY     (-2)
01214 #define YYEOF       0
01215 
01216 #define YYACCEPT    goto yyacceptlab
01217 #define YYABORT     goto yyabortlab
01218 #define YYERROR     goto yyerrorlab
01219 
01220 
01221 /* Like YYERROR except do call yyerror.  This remains here temporarily
01222    to ease the transition to the new meaning of YYERROR, for GCC.
01223    Once GCC version 2 has supplanted version 1, this can go.  */
01224 
01225 #define YYFAIL      goto yyerrlab
01226 
01227 #define YYRECOVERING()  (!!yyerrstatus)
01228 
01229 #define YYBACKUP(Token, Value)                  \
01230 do                              \
01231   if (yychar == YYEMPTY && yylen == 1)              \
01232     {                               \
01233       yychar = (Token);                     \
01234       yylval = (Value);                     \
01235       yytoken = YYTRANSLATE (yychar);               \
01236       YYPOPSTACK;                       \
01237       goto yybackup;                        \
01238     }                               \
01239   else                              \
01240     {                               \
01241       yyerror (YY_("syntax error: cannot back up")); \
01242       YYERROR;                          \
01243     }                               \
01244 while (0)
01245 
01246 
01247 #define YYTERROR    1
01248 #define YYERRCODE   256
01249 
01250 
01251 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
01252    If N is 0, then set CURRENT to the empty location which ends
01253    the previous symbol: RHS[0] (always defined).  */
01254 
01255 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
01256 #ifndef YYLLOC_DEFAULT
01257 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
01258     do                                  \
01259       if (N)                                \
01260     {                               \
01261       (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
01262       (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
01263       (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
01264       (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
01265     }                               \
01266       else                              \
01267     {                               \
01268       (Current).first_line   = (Current).last_line   =      \
01269         YYRHSLOC (Rhs, 0).last_line;                \
01270       (Current).first_column = (Current).last_column =      \
01271         YYRHSLOC (Rhs, 0).last_column;              \
01272     }                               \
01273     while (0)
01274 #endif
01275 
01276 
01277 /* YY_LOCATION_PRINT -- Print the location on the stream.
01278    This macro was not mandated originally: define only if we know
01279    we won't break user code: when these are the locations we know.  */
01280 
01281 #ifndef YY_LOCATION_PRINT
01282 # if YYLTYPE_IS_TRIVIAL
01283 #  define YY_LOCATION_PRINT(File, Loc)          \
01284      fprintf (File, "%d.%d-%d.%d",          \
01285               (Loc).first_line, (Loc).first_column, \
01286               (Loc).last_line,  (Loc).last_column)
01287 # else
01288 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
01289 # endif
01290 #endif
01291 
01292 
01293 /* YYLEX -- calling `yylex' with the right arguments.  */
01294 
01295 #ifdef YYLEX_PARAM
01296 # define YYLEX yylex (YYLEX_PARAM)
01297 #else
01298 # define YYLEX yylex ()
01299 #endif
01300 
01301 /* Enable debugging if requested.  */
01302 #if YYDEBUG
01303 
01304 # ifndef YYFPRINTF
01305 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
01306 #  define YYFPRINTF fprintf
01307 # endif
01308 
01309 # define YYDPRINTF(Args)            \
01310 do {                        \
01311   if (yydebug)                  \
01312     YYFPRINTF Args;             \
01313 } while (0)
01314 
01315 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)      \
01316 do {                                \
01317   if (yydebug)                          \
01318     {                               \
01319       YYFPRINTF (stderr, "%s ", Title);             \
01320       yysymprint (stderr,                   \
01321                   Type, Value, Location);   \
01322       YYFPRINTF (stderr, "\n");                 \
01323     }                               \
01324 } while (0)
01325 
01326 /*------------------------------------------------------------------.
01327 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01328 | TOP (included).                                                   |
01329 `------------------------------------------------------------------*/
01330 
01331 #if defined (__STDC__) || defined (__cplusplus)
01332 static void
01333 yy_stack_print (short int *bottom, short int *top)
01334 #else
01335 static void
01336 yy_stack_print (bottom, top)
01337     short int *bottom;
01338     short int *top;
01339 #endif
01340 {
01341   YYFPRINTF (stderr, "Stack now");
01342   for (/* Nothing. */; bottom <= top; ++bottom)
01343     YYFPRINTF (stderr, " %d", *bottom);
01344   YYFPRINTF (stderr, "\n");
01345 }
01346 
01347 # define YY_STACK_PRINT(Bottom, Top)                \
01348 do {                                \
01349   if (yydebug)                          \
01350     yy_stack_print ((Bottom), (Top));               \
01351 } while (0)
01352 
01353 
01354 /*------------------------------------------------.
01355 | Report that the YYRULE is going to be reduced.  |
01356 `------------------------------------------------*/
01357 
01358 #if defined (__STDC__) || defined (__cplusplus)
01359 static void
01360 yy_reduce_print (int yyrule)
01361 #else
01362 static void
01363 yy_reduce_print (yyrule)
01364     int yyrule;
01365 #endif
01366 {
01367   int yyi;
01368   unsigned long int yylno = yyrline[yyrule];
01369   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
01370              yyrule - 1, yylno);
01371   /* Print the symbols being reduced, and their result.  */
01372   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
01373     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
01374   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
01375 }
01376 
01377 # define YY_REDUCE_PRINT(Rule)      \
01378 do {                    \
01379   if (yydebug)              \
01380     yy_reduce_print (Rule);     \
01381 } while (0)
01382 
01383 /* Nonzero means print parse trace.  It is left uninitialized so that
01384    multiple parsers can coexist.  */
01385 int yydebug;
01386 #else /* !YYDEBUG */
01387 # define YYDPRINTF(Args)
01388 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01389 # define YY_STACK_PRINT(Bottom, Top)
01390 # define YY_REDUCE_PRINT(Rule)
01391 #endif /* !YYDEBUG */
01392 
01393 
01394 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01395 #ifndef YYINITDEPTH
01396 # define YYINITDEPTH 200
01397 #endif
01398 
01399 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01400    if the built-in stack extension method is used).
01401 
01402    Do not make this value too large; the results are undefined if
01403    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01404    evaluated with infinite-precision integer arithmetic.  */
01405 
01406 #ifndef YYMAXDEPTH
01407 # define YYMAXDEPTH 10000
01408 #endif
01409 
01410 
01411 
01412 #if YYERROR_VERBOSE
01413 
01414 # ifndef yystrlen
01415 #  if defined (__GLIBC__) && defined (_STRING_H)
01416 #   define yystrlen strlen
01417 #  else
01418 /* Return the length of YYSTR.  */
01419 static YYSIZE_T
01420 #   if defined (__STDC__) || defined (__cplusplus)
01421 yystrlen (const char *yystr)
01422 #   else
01423 yystrlen (yystr)
01424      const char *yystr;
01425 #   endif
01426 {
01427   const char *yys = yystr;
01428 
01429   while (*yys++ != '\0')
01430     continue;
01431 
01432   return yys - yystr - 1;
01433 }
01434 #  endif
01435 # endif
01436 
01437 # ifndef yystpcpy
01438 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
01439 #   define yystpcpy stpcpy
01440 #  else
01441 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01442    YYDEST.  */
01443 static char *
01444 #   if defined (__STDC__) || defined (__cplusplus)
01445 yystpcpy (char *yydest, const char *yysrc)
01446 #   else
01447 yystpcpy (yydest, yysrc)
01448      char *yydest;
01449      const char *yysrc;
01450 #   endif
01451 {
01452   char *yyd = yydest;
01453   const char *yys = yysrc;
01454 
01455   while ((*yyd++ = *yys++) != '\0')
01456     continue;
01457 
01458   return yyd - 1;
01459 }
01460 #  endif
01461 # endif
01462 
01463 # ifndef yytnamerr
01464 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01465    quotes and backslashes, so that it's suitable for yyerror.  The
01466    heuristic is that double-quoting is unnecessary unless the string
01467    contains an apostrophe, a comma, or backslash (other than
01468    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01469    null, do not copy; instead, return the length of what the result
01470    would have been.  */
01471 static YYSIZE_T
01472 yytnamerr (char *yyres, const char *yystr)
01473 {
01474   if (*yystr == '"')
01475     {
01476       size_t yyn = 0;
01477       char const *yyp = yystr;
01478 
01479       for (;;)
01480     switch (*++yyp)
01481       {
01482       case '\'':
01483       case ',':
01484         goto do_not_strip_quotes;
01485 
01486       case '\\':
01487         if (*++yyp != '\\')
01488           goto do_not_strip_quotes;
01489         /* Fall through.  */
01490       default:
01491         if (yyres)
01492           yyres[yyn] = *yyp;
01493         yyn++;
01494         break;
01495 
01496       case '"':
01497         if (yyres)
01498           yyres[yyn] = '\0';
01499         return yyn;
01500       }
01501     do_not_strip_quotes: ;
01502     }
01503 
01504   if (! yyres)
01505     return yystrlen (yystr);
01506 
01507   return yystpcpy (yyres, yystr) - yyres;
01508 }
01509 # endif
01510 
01511 #endif /* YYERROR_VERBOSE */
01512 
01513 
01514 
01515 #if YYDEBUG
01516 /*--------------------------------.
01517 | Print this symbol on YYOUTPUT.  |
01518 `--------------------------------*/
01519 
01520 #if defined (__STDC__) || defined (__cplusplus)
01521 static void
01522 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
01523 #else
01524 static void
01525 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
01526     FILE *yyoutput;
01527     int yytype;
01528     YYSTYPE *yyvaluep;
01529     YYLTYPE *yylocationp;
01530 #endif
01531 {
01532   /* Pacify ``unused variable'' warnings.  */
01533   (void) yyvaluep;
01534   (void) yylocationp;
01535 
01536   if (yytype < YYNTOKENS)
01537     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01538   else
01539     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01540 
01541   YY_LOCATION_PRINT (yyoutput, *yylocationp);
01542   YYFPRINTF (yyoutput, ": ");
01543 
01544 # ifdef YYPRINT
01545   if (yytype < YYNTOKENS)
01546     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
01547 # endif
01548   switch (yytype)
01549     {
01550       default:
01551         break;
01552     }
01553   YYFPRINTF (yyoutput, ")");
01554 }
01555 
01556 #endif /* ! YYDEBUG */
01557 /*-----------------------------------------------.
01558 | Release the memory associated to this symbol.  |
01559 `-----------------------------------------------*/
01560 
01561 #if defined (__STDC__) || defined (__cplusplus)
01562 static void
01563 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
01564 #else
01565 static void
01566 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
01567     const char *yymsg;
01568     int yytype;
01569     YYSTYPE *yyvaluep;
01570     YYLTYPE *yylocationp;
01571 #endif
01572 {
01573   /* Pacify ``unused variable'' warnings.  */
01574   (void) yyvaluep;
01575   (void) yylocationp;
01576 
01577   if (!yymsg)
01578     yymsg = "Deleting";
01579   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01580 
01581   switch (yytype)
01582     {
01583 
01584       default:
01585         break;
01586     }
01587 }
01588 
01589 
01590 /* Prevent warnings from -Wmissing-prototypes.  */
01591 
01592 #ifdef YYPARSE_PARAM
01593 # if defined (__STDC__) || defined (__cplusplus)
01594 int yyparse (void *YYPARSE_PARAM);
01595 # else
01596 int yyparse ();
01597 # endif
01598 #else /* ! YYPARSE_PARAM */
01599 #if defined (__STDC__) || defined (__cplusplus)
01600 int yyparse (void);
01601 #else
01602 int yyparse ();
01603 #endif
01604 #endif /* ! YYPARSE_PARAM */
01605 
01606 
01607 
01608 /* The look-ahead symbol.  */
01609 int yychar;
01610 
01611 /* The semantic value of the look-ahead symbol.  */
01612 YYSTYPE yylval;
01613 
01614 /* Number of syntax errors so far.  */
01615 int yynerrs;
01616 /* Location data for the look-ahead symbol.  */
01617 YYLTYPE yylloc;
01618 
01619 
01620 
01621 /*----------.
01622 | yyparse.  |
01623 `----------*/
01624 
01625 #ifdef YYPARSE_PARAM
01626 # if defined (__STDC__) || defined (__cplusplus)
01627 int yyparse (void *YYPARSE_PARAM)
01628 # else
01629 int yyparse (YYPARSE_PARAM)
01630   void *YYPARSE_PARAM;
01631 # endif
01632 #else /* ! YYPARSE_PARAM */
01633 #if defined (__STDC__) || defined (__cplusplus)
01634 int
01635 yyparse (void)
01636 #else
01637 int
01638 yyparse ()
01639     ;
01640 #endif
01641 #endif
01642 {
01643   
01644   int yystate;
01645   int yyn;
01646   int yyresult;
01647   /* Number of tokens to shift before error messages enabled.  */
01648   int yyerrstatus;
01649   /* Look-ahead token as an internal (translated) token number.  */
01650   int yytoken = 0;
01651 
01652   /* Three stacks and their tools:
01653      `yyss': related to states,
01654      `yyvs': related to semantic values,
01655      `yyls': related to locations.
01656 
01657      Refer to the stacks thru separate pointers, to allow yyoverflow
01658      to reallocate them elsewhere.  */
01659 
01660   /* The state stack.  */
01661   short int yyssa[YYINITDEPTH];
01662   short int *yyss = yyssa;
01663   short int *yyssp;
01664 
01665   /* The semantic value stack.  */
01666   YYSTYPE yyvsa[YYINITDEPTH];
01667   YYSTYPE *yyvs = yyvsa;
01668   YYSTYPE *yyvsp;
01669 
01670   /* The location stack.  */
01671   YYLTYPE yylsa[YYINITDEPTH];
01672   YYLTYPE *yyls = yylsa;
01673   YYLTYPE *yylsp;
01674   /* The locations where the error started and ended. */
01675   YYLTYPE yyerror_range[2];
01676 
01677 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
01678 
01679   YYSIZE_T yystacksize = YYINITDEPTH;
01680 
01681   /* The variables used to return semantic value and location from the
01682      action routines.  */
01683   YYSTYPE yyval;
01684   YYLTYPE yyloc;
01685 
01686   /* When reducing, the number of symbols on the RHS of the reduced
01687      rule.  */
01688   int yylen;
01689 
01690   YYDPRINTF ((stderr, "Starting parse\n"));
01691 
01692   yystate = 0;
01693   yyerrstatus = 0;
01694   yynerrs = 0;
01695   yychar = YYEMPTY;     /* Cause a token to be read.  */
01696 
01697   /* Initialize stack pointers.
01698      Waste one element of value and location stack
01699      so that they stay on the same level as the state stack.
01700      The wasted elements are never initialized.  */
01701 
01702   yyssp = yyss;
01703   yyvsp = yyvs;
01704   yylsp = yyls;
01705 #if YYLTYPE_IS_TRIVIAL
01706   /* Initialize the default location before parsing starts.  */
01707   yylloc.first_line   = yylloc.last_line   = 1;
01708   yylloc.first_column = yylloc.last_column = 0;
01709 #endif
01710 
01711   goto yysetstate;
01712 
01713 /*------------------------------------------------------------.
01714 | yynewstate -- Push a new state, which is found in yystate.  |
01715 `------------------------------------------------------------*/
01716  yynewstate:
01717   /* In all cases, when you get here, the value and location stacks
01718      have just been pushed. so pushing a state here evens the stacks.
01719      */
01720   yyssp++;
01721 
01722  yysetstate:
01723   *yyssp = yystate;
01724 
01725   if (yyss + yystacksize - 1 <= yyssp)
01726     {
01727       /* Get the current used size of the three stacks, in elements.  */
01728       YYSIZE_T yysize = yyssp - yyss + 1;
01729 
01730 #ifdef yyoverflow
01731       {
01732     /* Give user a chance to reallocate the stack. Use copies of
01733        these so that the &'s don't force the real ones into
01734        memory.  */
01735     YYSTYPE *yyvs1 = yyvs;
01736     short int *yyss1 = yyss;
01737     YYLTYPE *yyls1 = yyls;
01738 
01739     /* Each stack pointer address is followed by the size of the
01740        data in use in that stack, in bytes.  This used to be a
01741        conditional around just the two extra args, but that might
01742        be undefined if yyoverflow is a macro.  */
01743     yyoverflow (YY_("memory exhausted"),
01744             &yyss1, yysize * sizeof (*yyssp),
01745             &yyvs1, yysize * sizeof (*yyvsp),
01746             &yyls1, yysize * sizeof (*yylsp),
01747             &yystacksize);
01748     yyls = yyls1;
01749     yyss = yyss1;
01750     yyvs = yyvs1;
01751       }
01752 #else /* no yyoverflow */
01753 # ifndef YYSTACK_RELOCATE
01754       goto yyexhaustedlab;
01755 # else
01756       /* Extend the stack our own way.  */
01757       if (YYMAXDEPTH <= yystacksize)
01758     goto yyexhaustedlab;
01759       yystacksize *= 2;
01760       if (YYMAXDEPTH < yystacksize)
01761     yystacksize = YYMAXDEPTH;
01762 
01763       {
01764     short int *yyss1 = yyss;
01765     union yyalloc *yyptr =
01766       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01767     if (! yyptr)
01768       goto yyexhaustedlab;
01769     YYSTACK_RELOCATE (yyss);
01770     YYSTACK_RELOCATE (yyvs);
01771     YYSTACK_RELOCATE (yyls);
01772 #  undef YYSTACK_RELOCATE
01773     if (yyss1 != yyssa)
01774       YYSTACK_FREE (yyss1);
01775       }
01776 # endif
01777 #endif /* no yyoverflow */
01778 
01779       yyssp = yyss + yysize - 1;
01780       yyvsp = yyvs + yysize - 1;
01781       yylsp = yyls + yysize - 1;
01782 
01783       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01784           (unsigned long int) yystacksize));
01785 
01786       if (yyss + yystacksize - 1 <= yyssp)
01787     YYABORT;
01788     }
01789 
01790   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01791 
01792   goto yybackup;
01793 
01794 /*-----------.
01795 | yybackup.  |
01796 `-----------*/
01797 yybackup:
01798 
01799 /* Do appropriate processing given the current state.  */
01800 /* Read a look-ahead token if we need one and don't already have one.  */
01801 /* yyresume: */
01802 
01803   /* First try to decide what to do without reference to look-ahead token.  */
01804 
01805   yyn = yypact[yystate];
01806   if (yyn == YYPACT_NINF)
01807     goto yydefault;
01808 
01809   /* Not known => get a look-ahead token if don't already have one.  */
01810 
01811   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
01812   if (yychar == YYEMPTY)
01813     {
01814       YYDPRINTF ((stderr, "Reading a token: "));
01815       yychar = YYLEX;
01816     }
01817 
01818   if (yychar <= YYEOF)
01819     {
01820       yychar = yytoken = YYEOF;
01821       YYDPRINTF ((stderr, "Now at end of input.\n"));
01822     }
01823   else
01824     {
01825       yytoken = YYTRANSLATE (yychar);
01826       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01827     }
01828 
01829   /* If the proper action on seeing token YYTOKEN is to reduce or to
01830      detect an error, take that action.  */
01831   yyn += yytoken;
01832   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01833     goto yydefault;
01834   yyn = yytable[yyn];
01835   if (yyn <= 0)
01836     {
01837       if (yyn == 0 || yyn == YYTABLE_NINF)
01838     goto yyerrlab;
01839       yyn = -yyn;
01840       goto yyreduce;
01841     }
01842 
01843   if (yyn == YYFINAL)
01844     YYACCEPT;
01845 
01846   /* Shift the look-ahead token.  */
01847   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01848 
01849   /* Discard the token being shifted unless it is eof.  */
01850   if (yychar != YYEOF)
01851     yychar = YYEMPTY;
01852 
01853   *++yyvsp = yylval;
01854   *++yylsp = yylloc;
01855 
01856   /* Count tokens shifted since error; after three, turn off error
01857      status.  */
01858   if (yyerrstatus)
01859     yyerrstatus--;
01860 
01861   yystate = yyn;
01862   goto yynewstate;
01863 
01864 
01865 /*-----------------------------------------------------------.
01866 | yydefault -- do the default action for the current state.  |
01867 `-----------------------------------------------------------*/
01868 yydefault:
01869   yyn = yydefact[yystate];
01870   if (yyn == 0)
01871     goto yyerrlab;
01872   goto yyreduce;
01873 
01874 
01875 /*-----------------------------.
01876 | yyreduce -- Do a reduction.  |
01877 `-----------------------------*/
01878 yyreduce:
01879   /* yyn is the number of a rule to reduce with.  */
01880   yylen = yyr2[yyn];
01881 
01882   /* If YYLEN is nonzero, implement the default value of the action:
01883      `$$ = $1'.
01884 
01885      Otherwise, the following line sets YYVAL to garbage.
01886      This behavior is undocumented and Bison
01887      users should not rely upon it.  Assigning to YYVAL
01888      unconditionally makes the parser a bit smaller, and it avoids a
01889      GCC warning that YYVAL may be used uninitialized.  */
01890   yyval = yyvsp[1-yylen];
01891 
01892   /* Default location. */
01893   YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
01894   YY_REDUCE_PRINT (yyn);
01895   switch (yyn)
01896     {
01897         case 2:
01898 #line 167 "grammar.y"
01899     { (yyval.node) = new NullNode(); ;}
01900     break;
01901 
01902   case 3:
01903 #line 168 "grammar.y"
01904     { (yyval.node) = new BooleanNode(true); ;}
01905     break;
01906 
01907   case 4:
01908 #line 169 "grammar.y"
01909     { (yyval.node) = new BooleanNode(false); ;}
01910     break;
01911 
01912   case 5:
01913 #line 170 "grammar.y"
01914     { (yyval.node) = new NumberNode((yyvsp[0].dval)); ;}
01915     break;
01916 
01917   case 6:
01918 #line 171 "grammar.y"
01919     { (yyval.node) = new StringNode((yyvsp[0].ustr)); ;}
01920     break;
01921 
01922   case 7:
01923 #line 172 "grammar.y"
01924     { Lexer *l = Lexer::curr();
01925                                      if (!l->scanRegExp()) YYABORT;
01926                                      (yyval.node) = new RegExpNode(l->pattern,l->flags);;}
01927     break;
01928 
01929   case 8:
01930 #line 176 "grammar.y"
01931     { Lexer *l = Lexer::curr();
01932                                      if (!l->scanRegExp()) YYABORT;
01933                                      (yyval.node) = new RegExpNode(UString('=')+l->pattern,l->flags);;}
01934     break;
01935 
01936   case 9:
01937 #line 182 "grammar.y"
01938     { (yyval.node) = new ThisNode(); ;}
01939     break;
01940 
01941   case 10:
01942 #line 183 "grammar.y"
01943     { (yyval.node) = new ResolveNode(*(yyvsp[0].ident)); ;}
01944     break;
01945 
01946   case 13:
01947 #line 186 "grammar.y"
01948     { (yyval.node) = new GroupNode((yyvsp[-1].node)); ;}
01949     break;
01950 
01951   case 14:
01952 #line 187 "grammar.y"
01953     { (yyval.node) = new ObjectLiteralNode(); ;}
01954     break;
01955 
01956   case 15:
01957 #line 188 "grammar.y"
01958     { (yyval.node) = new ObjectLiteralNode((yyvsp[-1].plist)); ;}
01959     break;
01960 
01961   case 16:
01962 #line 189 "grammar.y"
01963     { (yyval.node) = new ObjectLiteralNode((yyvsp[-2].plist)); ;}
01964     break;
01965 
01966   case 17:
01967 #line 193 "grammar.y"
01968     { (yyval.node) = new ArrayNode((yyvsp[-1].ival)); ;}
01969     break;
01970 
01971   case 18:
01972 #line 194 "grammar.y"
01973     { (yyval.node) = new ArrayNode((yyvsp[-1].elm)); ;}
01974     break;
01975 
01976   case 19:
01977 #line 195 "grammar.y"
01978     { (yyval.node) = new ArrayNode((yyvsp[-1].ival), (yyvsp[-3].elm)); ;}
01979     break;
01980 
01981   case 20:
01982 #line 199 "grammar.y"
01983     { (yyval.elm) = new ElementNode((yyvsp[-1].ival), (yyvsp[0].node)); ;}
01984     break;
01985 
01986   case 21:
01987 #line 201 "grammar.y"
01988     { (yyval.elm) = new ElementNode((yyvsp[-3].elm), (yyvsp[-1].ival), (yyvsp[0].node)); ;}
01989     break;
01990 
01991   case 22:
01992 #line 205 "grammar.y"
01993     { (yyval.ival) = 0; ;}
01994     break;
01995 
01996   case 24:
01997 #line 210 "grammar.y"
01998     { (yyval.ival) = 1; ;}
01999     break;
02000 
02001   case 25:
02002 #line 211 "grammar.y"
02003     { (yyval.ival) = (yyvsp[-1].ival) + 1; ;}
02004     break;
02005 
02006   case 26:
02007 #line 215 "grammar.y"
02008     { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node)); ;}
02009     break;
02010 
02011   case 27:
02012 #line 217 "grammar.y"
02013     { (yyval.plist) = new PropertyValueNode((yyvsp[-2].pnode), (yyvsp[0].node), (yyvsp[-4].plist)); ;}
02014     break;
02015 
02016   case 28:
02017 #line 221 "grammar.y"
02018     { (yyval.pnode) = new PropertyNode(*(yyvsp[0].ident)); ;}
02019     break;
02020 
02021   case 29:
02022 #line 222 "grammar.y"
02023     { (yyval.pnode) = new PropertyNode(Identifier(*(yyvsp[0].ustr))); ;}
02024     break;
02025 
02026   case 30:
02027 #line 223 "grammar.y"
02028     { (yyval.pnode) = new PropertyNode((yyvsp[0].dval)); ;}
02029     break;
02030 
02031   case 33:
02032 #line 229 "grammar.y"
02033     { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
02034     break;
02035 
02036   case 34:
02037 #line 230 "grammar.y"
02038     { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
02039     break;
02040 
02041   case 35:
02042 #line 231 "grammar.y"
02043     { (yyval.node) = new NewExprNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
02044     break;
02045 
02046   case 37:
02047 #line 236 "grammar.y"
02048     { (yyval.node) = new NewExprNode((yyvsp[0].node)); ;}
02049     break;
02050 
02051   case 38:
02052 #line 240 "grammar.y"
02053     { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
02054     break;
02055 
02056   case 39:
02057 #line 241 "grammar.y"
02058     { (yyval.node) = new FunctionCallNode((yyvsp[-1].node), (yyvsp[0].args)); ;}
02059     break;
02060 
02061   case 40:
02062 #line 242 "grammar.y"
02063     { (yyval.node) = new AccessorNode1((yyvsp[-3].node), (yyvsp[-1].node)); ;}
02064     break;
02065 
02066   case 41:
02067 #line 243 "grammar.y"
02068     { (yyval.node) = new AccessorNode2((yyvsp[-2].node), *(yyvsp[0].ident)); ;}
02069     break;
02070 
02071   case 42:
02072 #line 247 "grammar.y"
02073     { (yyval.args) = new ArgumentsNode(); ;}
02074     break;
02075 
02076   case 43:
02077 #line 248 "grammar.y"
02078     { (yyval.args) = new ArgumentsNode((yyvsp[-1].alist)); ;}
02079     break;
02080 
02081   case 44:
02082 #line 252 "grammar.y"
02083     { (yyval.alist) = new ArgumentListNode((yyvsp[0].node)); ;}
02084     break;
02085 
02086   case 45:
02087 #line 253 "grammar.y"
02088     { (yyval.alist) = new ArgumentListNode((yyvsp[-2].alist), (yyvsp[0].node)); ;}
02089     break;
02090 
02091   case 49:
02092 #line 263 "grammar.y"
02093     { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpPlusPlus); ;}
02094     break;
02095 
02096   case 50:
02097 #line 264 "grammar.y"
02098     { (yyval.node) = new PostfixNode((yyvsp[-1].node), OpMinusMinus); ;}
02099     break;
02100 
02101   case 52:
02102 #line 269 "grammar.y"
02103     { (yyval.node) = new DeleteNode((yyvsp[0].node)); ;}
02104     break;
02105 
02106   case 53:
02107 #line 270 "grammar.y"
02108     { (yyval.node) = new VoidNode((yyvsp[0].node)); ;}
02109     break;
02110 
02111   case 54:
02112 #line 271 "grammar.y"
02113     { (yyval.node) = new TypeOfNode((yyvsp[0].node)); ;}
02114     break;
02115 
02116   case 55:
02117 #line 272 "grammar.y"
02118     { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
02119     break;
02120 
02121   case 56:
02122 #line 273 "grammar.y"
02123     { (yyval.node) = new PrefixNode(OpPlusPlus, (yyvsp[0].node)); ;}
02124     break;
02125 
02126   case 57:
02127 #line 274 "grammar.y"
02128     { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
02129     break;
02130 
02131   case 58:
02132 #line 275 "grammar.y"
02133     { (yyval.node) = new PrefixNode(OpMinusMinus, (yyvsp[0].node)); ;}
02134     break;
02135 
02136   case 59:
02137 #line 276 "grammar.y"
02138     { (yyval.node) = new UnaryPlusNode((yyvsp[0].node)); ;}
02139     break;
02140 
02141   case 60:
02142 #line 277 "grammar.y"
02143     { (yyval.node) = new NegateNode((yyvsp[0].node)); ;}
02144     break;
02145 
02146   case 61:
02147 #line 278 "grammar.y"
02148     { (yyval.node) = new BitwiseNotNode((yyvsp[0].node)); ;}
02149     break;
02150 
02151   case 62:
02152 #line 279 "grammar.y"
02153     { (yyval.node) = new LogicalNotNode((yyvsp[0].node)); ;}
02154     break;
02155 
02156   case 64:
02157 #line 284 "grammar.y"
02158     { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '*'); ;}
02159     break;
02160 
02161   case 65:
02162 #line 285 "grammar.y"
02163     { (yyval.node) = new MultNode((yyvsp[-2].node), (yyvsp[0].node), '/'); ;}
02164     break;
02165 
02166   case 66:
02167 #line 286 "grammar.y"
02168     { (yyval.node) = new MultNode((yyvsp[-2].node),(yyvsp[0].node),'%'); ;}
02169     break;
02170 
02171   case 68:
02172 #line 291 "grammar.y"
02173     { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '+'); ;}
02174     break;
02175 
02176   case 69:
02177 #line 292 "grammar.y"
02178     { (yyval.node) = AddNode::create((yyvsp[-2].node), (yyvsp[0].node), '-'); ;}
02179     break;
02180 
02181   case 71:
02182 #line 297 "grammar.y"
02183     { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpLShift, (yyvsp[0].node)); ;}
02184     break;
02185 
02186   case 72:
02187 #line 298 "grammar.y"
02188     { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpRShift, (yyvsp[0].node)); ;}
02189     break;
02190 
02191   case 73:
02192 #line 299 "grammar.y"
02193     { (yyval.node) = new ShiftNode((yyvsp[-2].node), OpURShift, (yyvsp[0].node)); ;}
02194     break;
02195 
02196   case 75:
02197 #line 305 "grammar.y"
02198     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLess, (yyvsp[0].node)); ;}
02199     break;
02200 
02201   case 76:
02202 #line 307 "grammar.y"
02203     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreater, (yyvsp[0].node)); ;}
02204     break;
02205 
02206   case 77:
02207 #line 309 "grammar.y"
02208     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpLessEq, (yyvsp[0].node)); ;}
02209     break;
02210 
02211   case 78:
02212 #line 311 "grammar.y"
02213     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpGreaterEq, (yyvsp[0].node)); ;}
02214     break;
02215 
02216   case 79:
02217 #line 313 "grammar.y"
02218     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpInstanceOf, (yyvsp[0].node)); ;}
02219     break;
02220 
02221   case 80:
02222 #line 315 "grammar.y"
02223     { (yyval.node) = new RelationalNode((yyvsp[-2].node), OpIn, (yyvsp[0].node)); ;}
02224     break;
02225 
02226   case 82:
02227 #line 320 "grammar.y"
02228     { (yyval.node) = new EqualNode((yyvsp[-2].node), OpEqEq, (yyvsp[0].node)); ;}
02229     break;
02230 
02231   case 83:
02232 #line 321 "grammar.y"
02233     { (yyval.node) = new EqualNode((yyvsp[-2].node), OpNotEq, (yyvsp[0].node)); ;}
02234     break;
02235 
02236   case 84:
02237 #line 322 "grammar.y"
02238     { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrEq, (yyvsp[0].node)); ;}
02239     break;
02240 
02241   case 85:
02242 #line 323 "grammar.y"
02243     { (yyval.node) = new EqualNode((yyvsp[-2].node), OpStrNEq, (yyvsp[0].node));;}
02244     break;
02245 
02246   case 87:
02247 #line 328 "grammar.y"
02248     { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitAnd, (yyvsp[0].node)); ;}
02249     break;
02250 
02251   case 89:
02252 #line 333 "grammar.y"
02253     { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitXOr, (yyvsp[0].node)); ;}
02254     break;
02255 
02256   case 91:
02257 #line 338 "grammar.y"
02258     { (yyval.node) = new BitOperNode((yyvsp[-2].node), OpBitOr, (yyvsp[0].node)); ;}
02259     break;
02260 
02261   case 93:
02262 #line 344 "grammar.y"
02263     { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpAnd, (yyvsp[0].node)); ;}
02264     break;
02265 
02266   case 95:
02267 #line 350 "grammar.y"
02268     { (yyval.node) = new BinaryLogicalNode((yyvsp[-2].node), OpOr, (yyvsp[0].node)); ;}
02269     break;
02270 
02271   case 97:
02272 #line 356 "grammar.y"
02273     { (yyval.node) = new ConditionalNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].node)); ;}
02274     break;
02275 
02276   case 99:
02277 #line 362 "grammar.y"
02278     { (yyval.node) = new AssignNode((yyvsp[-2].node), (yyvsp[-1].op), (yyvsp[0].node));;}
02279     break;
02280 
02281   case 100:
02282 #line 366 "grammar.y"
02283     { (yyval.op) = OpEqual; ;}
02284     break;
02285 
02286   case 101:
02287 #line 367 "grammar.y"
02288     { (yyval.op) = OpPlusEq; ;}
02289     break;
02290 
02291   case 102:
02292 #line 368 "grammar.y"
02293     { (yyval.op) = OpMinusEq; ;}
02294     break;
02295 
02296   case 103:
02297 #line 369 "grammar.y"
02298     { (yyval.op) = OpMultEq; ;}
02299     break;
02300 
02301   case 104:
02302 #line 370 "grammar.y"
02303     { (yyval.op) = OpDivEq; ;}
02304     break;
02305 
02306   case 105:
02307 #line 371 "grammar.y"
02308     { (yyval.op) = OpLShift; ;}
02309     break;
02310 
02311   case 106:
02312 #line 372 "grammar.y"
02313     { (yyval.op) = OpRShift; ;}
02314     break;
02315 
02316   case 107:
02317 #line 373 "grammar.y"
02318     { (yyval.op) = OpURShift; ;}
02319     break;
02320 
02321   case 108:
02322 #line 374 "grammar.y"
02323     { (yyval.op) = OpAndEq; ;}
02324     break;
02325 
02326   case 109:
02327 #line 375 "grammar.y"
02328     { (yyval.op) = OpXOrEq; ;}
02329     break;
02330 
02331   case 110:
02332 #line 376 "grammar.y"
02333     { (yyval.op) = OpOrEq; ;}
02334     break;
02335 
02336   case 111:
02337 #line 377 "grammar.y"
02338     { (yyval.op) = OpModEq; ;}
02339     break;
02340 
02341   case 113:
02342 #line 382 "grammar.y"
02343     { (yyval.node) = new CommaNode((yyvsp[-2].node), (yyvsp[0].node)); ;}
02344     break;
02345 
02346   case 129:
02347 #line 404 "grammar.y"
02348     { (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
02349     break;
02350 
02351   case 130:
02352 #line 405 "grammar.y"
02353     { (yyval.stat) = new BlockNode((yyvsp[-1].srcs)); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
02354     break;
02355 
02356   case 131:
02357 #line 409 "grammar.y"
02358     { (yyval.slist) = new StatListNode((yyvsp[0].stat)); ;}
02359     break;
02360 
02361   case 132:
02362 #line 410 "grammar.y"
02363     { (yyval.slist) = new StatListNode((yyvsp[-1].slist), (yyvsp[0].stat)); ;}
02364     break;
02365 
02366   case 133:
02367 #line 414 "grammar.y"
02368     { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
02369                                       DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
02370     break;
02371 
02372   case 134:
02373 #line 416 "grammar.y"
02374     { if (automatic()) {
02375                                           (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
02376                       DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
02377                                         } else {
02378                       YYABORT;
02379                     }
02380                                       ;}
02381     break;
02382 
02383   case 135:
02384 #line 426 "grammar.y"
02385     { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
02386     break;
02387 
02388   case 136:
02389 #line 428 "grammar.y"
02390     { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
02391     break;
02392 
02393   case 137:
02394 #line 432 "grammar.y"
02395     { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Variable); ;}
02396     break;
02397 
02398   case 138:
02399 #line 433 "grammar.y"
02400     { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Variable); ;}
02401     break;
02402 
02403   case 139:
02404 #line 437 "grammar.y"
02405     { (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
02406                                       DBG((yyval.stat), (yylsp[-2]), (yylsp[0])); ;}
02407     break;
02408 
02409   case 140:
02410 #line 439 "grammar.y"
02411     { if (automatic()) {
02412                                           (yyval.stat) = new VarStatementNode((yyvsp[-1].vlist));
02413                       DBG((yyval.stat), (yylsp[-2]), (yylsp[-1]));
02414                                         } else {
02415                       YYABORT;
02416                     }
02417                                       ;}
02418     break;
02419 
02420   case 141:
02421 #line 449 "grammar.y"
02422     { (yyval.vlist) = new VarDeclListNode((yyvsp[0].decl)); ;}
02423     break;
02424 
02425   case 142:
02426 #line 451 "grammar.y"
02427     { (yyval.vlist) = new VarDeclListNode((yyvsp[-2].vlist), (yyvsp[0].decl)); ;}
02428     break;
02429 
02430   case 143:
02431 #line 455 "grammar.y"
02432     { (yyval.decl) = new VarDeclNode(*(yyvsp[0].ident), 0, VarDeclNode::Constant); ;}
02433     break;
02434 
02435   case 144:
02436 #line 456 "grammar.y"
02437     { (yyval.decl) = new VarDeclNode(*(yyvsp[-1].ident), (yyvsp[0].init), VarDeclNode::Constant); ;}
02438     break;
02439 
02440   case 145:
02441 #line 460 "grammar.y"
02442     { (yyval.init) = new AssignExprNode((yyvsp[0].node)); ;}
02443     break;
02444 
02445   case 146:
02446 #line 464 "grammar.y"
02447     { (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[0]), (yylsp[0])); ;}
02448     break;
02449 
02450   case 147:
02451 #line 468 "grammar.y"
02452     { (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
02453                                      DBG((yyval.stat), (yylsp[-1]), (yylsp[0])); ;}
02454     break;
02455 
02456   case 148:
02457 #line 470 "grammar.y"
02458     { if (automatic()) {
02459                                        (yyval.stat) = new ExprStatementNode((yyvsp[-1].node));
02460                        DBG((yyval.stat), (yylsp[-1]), (yylsp[-1]));
02461                                      } else
02462                        YYABORT; ;}
02463     break;
02464 
02465   case 149:
02466 #line 478 "grammar.y"
02467     { (yyval.stat) = new IfNode((yyvsp[-2].node),(yyvsp[0].stat),0);DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
02468     break;
02469 
02470   case 150:
02471 #line 480 "grammar.y"
02472     { (yyval.stat) = new IfNode((yyvsp[-4].node),(yyvsp[-2].stat),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-6]),(yylsp[-3])); ;}
02473     break;
02474 
02475   case 151:
02476 #line 484 "grammar.y"
02477     { (yyval.stat)=new DoWhileNode((yyvsp[-4].stat),(yyvsp[-1].node));DBG((yyval.stat),(yylsp[-5]),(yylsp[-3]));;}
02478     break;
02479 
02480   case 152:
02481 #line 485 "grammar.y"
02482     { (yyval.stat) = new WhileNode((yyvsp[-2].node),(yyvsp[0].stat));DBG((yyval.stat),(yylsp[-4]),(yylsp[-1])); ;}
02483     break;
02484 
02485   case 153:
02486 #line 487 "grammar.y"
02487     { (yyval.stat) = new ForNode((yyvsp[-6].node),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
02488                                  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
02489     break;
02490 
02491   case 154:
02492 #line 490 "grammar.y"
02493     { (yyval.stat) = new ForNode((yyvsp[-6].vlist),(yyvsp[-4].node),(yyvsp[-2].node),(yyvsp[0].stat));
02494                                  DBG((yyval.stat),(yylsp[-9]),(yylsp[-1])); ;}
02495     break;
02496 
02497   case 155:
02498 #line 493 "grammar.y"
02499     { (yyval.stat) = new ForInNode((yyvsp[-4].node), (yyvsp[-2].node), (yyvsp[0].stat));
02500                                  DBG((yyval.stat),(yylsp[-6]),(yylsp[-1])); ;}
02501     break;
02502 
02503   case 156:
02504 #line 496 "grammar.y"
02505     { (yyval.stat) = new ForInNode(*(yyvsp[-4].ident),0,(yyvsp[-2].node),(yyvsp[0].stat));
02506                                  DBG((yyval.stat),(yylsp[-7]),(yylsp[-1])); ;}
02507     break;
02508 
02509   case 157:
02510 #line 499 "grammar.y"
02511     { (yyval.stat) = new ForInNode(*(yyvsp[-5].ident),(yyvsp[-4].init),(yyvsp[-2].node),(yyvsp[0].stat));
02512                                  DBG((yyval.stat),(yylsp[-8]),(yylsp[-1])); ;}
02513     break;
02514 
02515   case 158:
02516 #line 504 "grammar.y"
02517     { (yyval.node) = 0; ;}
02518     break;
02519 
02520   case 160:
02521 #line 509 "grammar.y"
02522     { (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
02523     break;
02524 
02525   case 161:
02526 #line 510 "grammar.y"
02527     { if (automatic()) {
02528                                        (yyval.stat) = new ContinueNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[0]));
02529                                      } else
02530                        YYABORT; ;}
02531     break;
02532 
02533   case 162:
02534 #line 514 "grammar.y"
02535     { (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
02536     break;
02537 
02538   case 163:
02539 #line 515 "grammar.y"
02540     { if (automatic()) {
02541                                        (yyval.stat) = new ContinueNode(*(yyvsp[-1].ident));DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
02542                                      } else
02543                        YYABORT; ;}
02544     break;
02545 
02546   case 164:
02547 #line 522 "grammar.y"
02548     { (yyval.stat) = new BreakNode();DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
02549     break;
02550 
02551   case 165:
02552 #line 523 "grammar.y"
02553     { if (automatic()) {
02554                                        (yyval.stat) = new BreakNode(); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
02555                                      } else
02556                        YYABORT; ;}
02557     break;
02558 
02559   case 166:
02560 #line 527 "grammar.y"
02561     { (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
02562     break;
02563 
02564   case 167:
02565 #line 528 "grammar.y"
02566     { if (automatic()) {
02567                                        (yyval.stat) = new BreakNode(*(yyvsp[-1].ident)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1]));
02568                                      } else
02569                        YYABORT;
02570                                    ;}
02571     break;
02572 
02573   case 168:
02574 #line 536 "grammar.y"
02575     { (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[0])); ;}
02576     break;
02577 
02578   case 169:
02579 #line 537 "grammar.y"
02580     { if (automatic()) {
02581                                        (yyval.stat) = new ReturnNode(0); DBG((yyval.stat),(yylsp[-1]),(yylsp[-1]));
02582                                      } else
02583                        YYABORT; ;}
02584     break;
02585 
02586   case 170:
02587 #line 541 "grammar.y"
02588     { (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
02589     break;
02590 
02591   case 171:
02592 #line 542 "grammar.y"
02593     { if (automatic()) {
02594                                        (yyval.stat) = new ReturnNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
02595                                      }
02596                                      else
02597                        YYABORT; ;}
02598     break;
02599 
02600   case 172:
02601 #line 550 "grammar.y"
02602     { (yyval.stat) = new WithNode((yyvsp[-2].node),(yyvsp[0].stat));
02603                                      DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
02604     break;
02605 
02606   case 173:
02607 #line 555 "grammar.y"
02608     { (yyval.stat) = new SwitchNode((yyvsp[-2].node), (yyvsp[0].cblk));
02609                                      DBG((yyval.stat), (yylsp[-4]), (yylsp[-1])); ;}
02610     break;
02611 
02612   case 174:
02613 #line 560 "grammar.y"
02614     { (yyval.cblk) = new CaseBlockNode((yyvsp[-1].clist), 0, 0); ;}
02615     break;
02616 
02617   case 175:
02618 #line 562 "grammar.y"
02619     { (yyval.cblk) = new CaseBlockNode((yyvsp[-3].clist), (yyvsp[-2].ccl), (yyvsp[-1].clist)); ;}
02620     break;
02621 
02622   case 176:
02623 #line 566 "grammar.y"
02624     { (yyval.clist) = 0; ;}
02625     break;
02626 
02627   case 178:
02628 #line 571 "grammar.y"
02629     { (yyval.clist) = new ClauseListNode((yyvsp[0].ccl)); ;}
02630     break;
02631 
02632   case 179:
02633 #line 572 "grammar.y"
02634     { (yyval.clist) = new ClauseListNode((yyvsp[-1].clist), (yyvsp[0].ccl)); ;}
02635     break;
02636 
02637   case 180:
02638 #line 576 "grammar.y"
02639     { (yyval.ccl) = new CaseClauseNode((yyvsp[-1].node)); ;}
02640     break;
02641 
02642   case 181:
02643 #line 577 "grammar.y"
02644     { (yyval.ccl) = new CaseClauseNode((yyvsp[-2].node), (yyvsp[0].slist)); ;}
02645     break;
02646 
02647   case 182:
02648 #line 581 "grammar.y"
02649     { (yyval.ccl) = new CaseClauseNode(0); ;}
02650     break;
02651 
02652   case 183:
02653 #line 582 "grammar.y"
02654     { (yyval.ccl) = new CaseClauseNode(0, (yyvsp[0].slist)); ;}
02655     break;
02656 
02657   case 184:
02658 #line 586 "grammar.y"
02659     { (yyvsp[0].stat)->pushLabel(*(yyvsp[-2].ident));
02660                                      (yyval.stat) = new LabelNode(*(yyvsp[-2].ident), (yyvsp[0].stat)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-1])); ;}
02661     break;
02662 
02663   case 185:
02664 #line 591 "grammar.y"
02665     { (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[0])); ;}
02666     break;
02667 
02668   case 186:
02669 #line 592 "grammar.y"
02670     { if (automatic()) {
02671                                        (yyval.stat) = new ThrowNode((yyvsp[-1].node)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2]));
02672                                      } else {
02673                        YYABORT; } ;}
02674     break;
02675 
02676   case 187:
02677 #line 599 "grammar.y"
02678     { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].cnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
02679     break;
02680 
02681   case 188:
02682 #line 600 "grammar.y"
02683     { (yyval.stat) = new TryNode((yyvsp[-1].stat), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-2]),(yylsp[-2])); ;}
02684     break;
02685 
02686   case 189:
02687 #line 601 "grammar.y"
02688     { (yyval.stat) = new TryNode((yyvsp[-2].stat), (yyvsp[-1].cnode), (yyvsp[0].fnode)); DBG((yyval.stat),(yylsp[-3]),(yylsp[-3])); ;}
02689     break;
02690 
02691   case 190:
02692 #line 605 "grammar.y"
02693     { CatchNode *c; (yyval.cnode) = c = new CatchNode(*(yyvsp[-2].ident), (yyvsp[0].stat));
02694                      DBG(c,(yylsp[-4]),(yylsp[-1])); ;}
02695     break;
02696 
02697   case 191:
02698 #line 610 "grammar.y"
02699     { FinallyNode *f; (yyval.fnode) = f = new FinallyNode((yyvsp[0].stat)); DBG(f,(yylsp[-1]),(yylsp[-1])); ;}
02700     break;
02701 
02702   case 193:
02703 #line 616 "grammar.y"
02704     { (yyval.func) = (yyvsp[0].func); ;}
02705     break;
02706 
02707   case 194:
02708 #line 620 "grammar.y"
02709     { (yyval.func) = new FuncDeclNode(*(yyvsp[-3].ident), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-4]),(yylsp[-1])); ;}
02710     break;
02711 
02712   case 195:
02713 #line 622 "grammar.y"
02714     { (yyval.func) = new FuncDeclNode(*(yyvsp[-4].ident), (yyvsp[-2].param), (yyvsp[0].body)); DBG((yyval.func),(yylsp[-5]),(yylsp[-1])); ;}
02715     break;
02716 
02717   case 196:
02718 #line 626 "grammar.y"
02719     { (yyval.node) = new FuncExprNode((yyvsp[0].body)); ;}
02720     break;
02721 
02722   case 197:
02723 #line 628 "grammar.y"
02724     { (yyval.node) = new FuncExprNode((yyvsp[-2].param), (yyvsp[0].body)); ;}
02725     break;
02726 
02727   case 198:
02728 #line 633 "grammar.y"
02729     { (yyval.param) = new ParameterNode(*(yyvsp[0].ident)); ;}
02730     break;
02731 
02732   case 199:
02733 #line 634 "grammar.y"
02734     { (yyval.param) = new ParameterNode((yyvsp[-2].param), *(yyvsp[0].ident)); ;}
02735     break;
02736 
02737   case 200:
02738 #line 638 "grammar.y"
02739     { (yyval.body) = new FunctionBodyNode(0);
02740                                  DBG((yyval.body), (yylsp[-1]), (yylsp[0]));;}
02741     break;
02742 
02743   case 201:
02744 #line 640 "grammar.y"
02745     { (yyval.body) = new FunctionBodyNode((yyvsp[-1].srcs));
02746                                  DBG((yyval.body), (yylsp[-2]), (yylsp[0]));;}
02747     break;
02748 
02749   case 202:
02750 #line 645 "grammar.y"
02751     { (yyval.prog) = new FunctionBodyNode(0);
02752                                      (yyval.prog)->setLoc(0, 0, Parser::source);
02753                                      Parser::progNode = (yyval.prog); ;}
02754     break;
02755 
02756   case 203:
02757 #line 648 "grammar.y"
02758     { (yyval.prog) = new FunctionBodyNode((yyvsp[0].srcs));
02759                                      Parser::progNode = (yyval.prog); ;}
02760     break;
02761 
02762   case 204:
02763 #line 653 "grammar.y"
02764     { (yyval.srcs) = new SourceElementsNode((yyvsp[0].stat)); ;}
02765     break;
02766 
02767   case 205:
02768 #line 654 "grammar.y"
02769     { (yyval.srcs) = new SourceElementsNode((yyvsp[-1].srcs), (yyvsp[0].stat)); ;}
02770     break;
02771 
02772   case 206:
02773 #line 658 "grammar.y"
02774     { (yyval.stat) = (yyvsp[0].stat); ;}
02775     break;
02776 
02777   case 207:
02778 #line 659 "grammar.y"
02779     { (yyval.stat) = (yyvsp[0].func); ;}
02780     break;
02781 
02782 
02783       default: break;
02784     }
02785 
02786 /* Line 1126 of yacc.c.  */
02787 #line 2788 "grammar.tab.c"
02788 
02789   yyvsp -= yylen;
02790   yyssp -= yylen;
02791   yylsp -= yylen;
02792 
02793   YY_STACK_PRINT (yyss, yyssp);
02794 
02795   *++yyvsp = yyval;
02796   *++yylsp = yyloc;
02797 
02798   /* Now `shift' the result of the reduction.  Determine what state
02799      that goes to, based on the state we popped back to and the rule
02800      number reduced by.  */
02801 
02802   yyn = yyr1[yyn];
02803 
02804   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
02805   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02806     yystate = yytable[yystate];
02807   else
02808     yystate = yydefgoto[yyn - YYNTOKENS];
02809 
02810   goto yynewstate;
02811 
02812 
02813 /*------------------------------------.
02814 | yyerrlab -- here on detecting error |
02815 `------------------------------------*/
02816 yyerrlab:
02817   /* If not already recovering from an error, report this error.  */
02818   if (!yyerrstatus)
02819     {
02820       ++yynerrs;
02821 #if YYERROR_VERBOSE
02822       yyn = yypact[yystate];
02823 
02824       if (YYPACT_NINF < yyn && yyn < YYLAST)
02825     {
02826       int yytype = YYTRANSLATE (yychar);
02827       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
02828       YYSIZE_T yysize = yysize0;
02829       YYSIZE_T yysize1;
02830       int yysize_overflow = 0;
02831       char *yymsg = 0;
02832 #     define YYERROR_VERBOSE_ARGS_MAXIMUM 5
02833       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
02834       int yyx;
02835 
02836 #if 0
02837       /* This is so xgettext sees the translatable formats that are
02838          constructed on the fly.  */
02839       YY_("syntax error, unexpected %s");
02840       YY_("syntax error, unexpected %s, expecting %s");
02841       YY_("syntax error, unexpected %s, expecting %s or %s");
02842       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
02843       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
02844 #endif
02845       char *yyfmt;
02846       char const *yyf;
02847       static char const yyunexpected[] = "syntax error, unexpected %s";
02848       static char const yyexpecting[] = ", expecting %s";
02849       static char const yyor[] = " or %s";
02850       char yyformat[sizeof yyunexpected
02851             + sizeof yyexpecting - 1
02852             + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
02853                * (sizeof yyor - 1))];
02854       char const *yyprefix = yyexpecting;
02855 
02856       /* Start YYX at -YYN if negative to avoid negative indexes in
02857          YYCHECK.  */
02858       int yyxbegin = yyn < 0 ? -yyn : 0;
02859 
02860       /* Stay within bounds of both yycheck and yytname.  */
02861       int yychecklim = YYLAST - yyn;
02862       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
02863       int yycount = 1;
02864 
02865       yyarg[0] = yytname[yytype];
02866       yyfmt = yystpcpy (yyformat, yyunexpected);
02867 
02868       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
02869         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
02870           {
02871         if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
02872           {
02873             yycount = 1;
02874             yysize = yysize0;
02875             yyformat[sizeof yyunexpected - 1] = '\0';
02876             break;
02877           }
02878         yyarg[yycount++] = yytname[yyx];
02879         yysize1 = yysize + yytnamerr (0, yytname[yyx]);
02880         yysize_overflow |= yysize1 < yysize;
02881         yysize = yysize1;
02882         yyfmt = yystpcpy (yyfmt, yyprefix);
02883         yyprefix = yyor;
02884           }
02885 
02886       yyf = YY_(yyformat);
02887       yysize1 = yysize + yystrlen (yyf);
02888       yysize_overflow |= yysize1 < yysize;
02889       yysize = yysize1;
02890 
02891       if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
02892         yymsg = (char *) YYSTACK_ALLOC (yysize);
02893       if (yymsg)
02894         {
02895           /* Avoid sprintf, as that infringes on the user's name space.
02896          Don't have undefined behavior even if the translation
02897          produced a string with the wrong number of "%s"s.  */
02898           char *yyp = yymsg;
02899           int yyi = 0;
02900           while ((*yyp = *yyf))
02901         {
02902           if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
02903             {
02904               yyp += yytnamerr (yyp, yyarg[yyi++]);
02905               yyf += 2;
02906             }
02907           else
02908             {
02909               yyp++;
02910               yyf++;
02911             }
02912         }
02913           yyerror (yymsg);
02914           YYSTACK_FREE (yymsg);
02915         }
02916       else
02917         {
02918           yyerror (YY_("syntax error"));
02919           goto yyexhaustedlab;
02920         }
02921     }
02922       else
02923 #endif /* YYERROR_VERBOSE */
02924     yyerror (YY_("syntax error"));
02925     }
02926 
02927   yyerror_range[0] = yylloc;
02928 
02929   if (yyerrstatus == 3)
02930     {
02931       /* If just tried and failed to reuse look-ahead token after an
02932      error, discard it.  */
02933 
02934       if (yychar <= YYEOF)
02935         {
02936       /* Return failure if at end of input.  */
02937       if (yychar == YYEOF)
02938         YYABORT;
02939         }
02940       else
02941     {
02942       yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
02943       yychar = YYEMPTY;
02944     }
02945     }
02946 
02947   /* Else will try to reuse look-ahead token after shifting the error
02948      token.  */
02949   goto yyerrlab1;
02950 
02951 
02952 /*---------------------------------------------------.
02953 | yyerrorlab -- error raised explicitly by YYERROR.  |
02954 `---------------------------------------------------*/
02955 yyerrorlab:
02956 
02957   /* Pacify compilers like GCC when the user code never invokes
02958      YYERROR and the label yyerrorlab therefore never appears in user
02959      code.  */
02960   if (0)
02961      goto yyerrorlab;
02962 
02963   yyerror_range[0] = yylsp[1-yylen];
02964   yylsp -= yylen;
02965   yyvsp -= yylen;
02966   yyssp -= yylen;
02967   yystate = *yyssp;
02968   goto yyerrlab1;
02969 
02970 
02971 /*-------------------------------------------------------------.
02972 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
02973 `-------------------------------------------------------------*/
02974 yyerrlab1:
02975   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
02976 
02977   for (;;)
02978     {
02979       yyn = yypact[yystate];
02980       if (yyn != YYPACT_NINF)
02981     {
02982       yyn += YYTERROR;
02983       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02984         {
02985           yyn = yytable[yyn];
02986           if (0 < yyn)
02987         break;
02988         }
02989     }
02990 
02991       /* Pop the current state because it cannot handle the error token.  */
02992       if (yyssp == yyss)
02993     YYABORT;
02994 
02995       yyerror_range[0] = *yylsp;
02996       yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
02997       YYPOPSTACK;
02998       yystate = *yyssp;
02999       YY_STACK_PRINT (yyss, yyssp);
03000     }
03001 
03002   if (yyn == YYFINAL)
03003     YYACCEPT;
03004 
03005   *++yyvsp = yylval;
03006 
03007   yyerror_range[1] = yylloc;
03008   /* Using YYLLOC is tempting, but would change the location of
03009      the look-ahead.  YYLOC is available though. */
03010   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
03011   *++yylsp = yyloc;
03012 
03013   /* Shift the error token. */
03014   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
03015 
03016   yystate = yyn;
03017   goto yynewstate;
03018 
03019 
03020 /*-------------------------------------.
03021 | yyacceptlab -- YYACCEPT comes here.  |
03022 `-------------------------------------*/
03023 yyacceptlab:
03024   yyresult = 0;
03025   goto yyreturn;
03026 
03027 /*-----------------------------------.
03028 | yyabortlab -- YYABORT comes here.  |
03029 `-----------------------------------*/
03030 yyabortlab:
03031   yyresult = 1;
03032   goto yyreturn;
03033 
03034 #ifndef yyoverflow
03035 /*-------------------------------------------------.
03036 | yyexhaustedlab -- memory exhaustion comes here.  |
03037 `-------------------------------------------------*/
03038 yyexhaustedlab:
03039   yyerror (YY_("memory exhausted"));
03040   yyresult = 2;
03041   /* Fall through.  */
03042 #endif
03043 
03044 yyreturn:
03045   if (yychar != YYEOF && yychar != YYEMPTY)
03046      yydestruct ("Cleanup: discarding lookahead",
03047          yytoken, &yylval, &yylloc);
03048   while (yyssp != yyss)
03049     {
03050       yydestruct ("Cleanup: popping",
03051           yystos[*yyssp], yyvsp, yylsp);
03052       YYPOPSTACK;
03053     }
03054 #ifndef yyoverflow
03055   if (yyss != yyssa)
03056     YYSTACK_FREE (yyss);
03057 #endif
03058   return yyresult;
03059 }
03060 
03061 
03062 #line 662 "grammar.y"
03063 
03064 
03065 int yyerror (const char * /* s */)  /* Called by yyparse on error */
03066 {
03067   //  fprintf(stderr, "ERROR: %s at line %d\n",
03068   //      s, KJS::Lexer::curr()->lineNo());
03069   return 1;
03070 }
03071 
03072 /* may we automatically insert a semicolon ? */
03073 bool automatic()
03074 {
03075   if (Lexer::curr()->hadError())
03076     return false;
03077   if (yychar == '}' || yychar == 0)
03078     return true;
03079   else if (Lexer::curr()->prevTerminator())
03080     return true;
03081 
03082   return false;
03083 }
03084 
KDE Home | KDE Accessibility Home | Description of Access Keys