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