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 Wed Sep 29 09:40:46 2004 by doxygen 1.3.8 written by Dimitri van Heesch, © 1997-2003