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