kjs Library API Documentation

grammar.cpp

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