/* A Bison parser, made from grammar.y by GNU bison 1.35. */ #define YYBISON 1 /* Identify Bison output. */ #define yyparse qsyyparse #define yylex qsyylex #define yyerror qsyyerror #define yylval qsyylval #define yychar qsyychar #define yydebug qsyydebug #define yynerrs qsyynerrs #define YYLSP_NEEDED 1 # define NULLTOKEN 257 # define TRUETOKEN 258 # define FALSETOKEN 259 # define STRING 260 # define NUMBER 261 # define BREAK 262 # define CASE 263 # define DEFAULT 264 # define FOR 265 # define NEW 266 # define VAR 267 # define CONTINUE 268 # define FUNCTION 269 # define RETURN 270 # define VOID 271 # define DELETE 272 # define IF 273 # define THIS 274 # define DO 275 # define WHILE 276 # define ELSE 277 # define IN 278 # define INSTANCEOF 279 # define TYPEOF 280 # define IS 281 # define SWITCH 282 # define WITH 283 # define RESERVED 284 # define THROW 285 # define TRY 286 # define CATCH 287 # define FINALLY 288 # define CLASS 289 # define CONSTRUCTOR 290 # define EXTENDS 291 # define ABSTRACT 292 # define FINAL 293 # define PRIVATE 294 # define PUBLIC 295 # define STATIC 296 # define CONST 297 # define PACKAGE 298 # define IMPORT 299 # define EQEQ 300 # define NE 301 # define STREQ 302 # define STRNEQ 303 # define LE 304 # define GE 305 # define OR 306 # define AND 307 # define PLUSPLUS 308 # define MINUSMINUS 309 # define LSHIFT 310 # define RSHIFT 311 # define URSHIFT 312 # define PLUSEQUAL 313 # define MINUSEQUAL 314 # define MULTEQUAL 315 # define DIVEQUAL 316 # define LSHIFTEQUAL 317 # define RSHIFTEQUAL 318 # define URSHIFTEQUAL 319 # define ANDEQUAL 320 # define MODEQUAL 321 # define XOREQUAL 322 # define OREQUAL 323 # define IDENT 324 #line 1 "grammar.y" /**************************************************************************** ** ** Copyright (C) 2001-2002 Trolltech AS. All rights reserved. ** ** This file is part of the Qt Script Interpreter. ** *****************************************************************************/ #ifdef HAVE_CONFIG_H #include #endif #include #include "qsengine.h" #include "qsnodes.h" #include "qslexer.h" /* default values for bison */ #define YYDEBUG 0 #define YYMAXDEPTH 0 #ifdef QSDEBUGGER #define YYERROR_VERBOSE #define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line); } // location #else #undef YYLSP_NEEDED #define DBG(l, s, e) #endif extern int yylex(); int yyerror (const char *); bool automatic(); #line 36 "grammar.y" #ifndef YYSTYPE typedef union { int ival; double dval; QString *ustr; QSNode *node; QSStatementNode *stat; QSParameterNode *param; QSFunctionBodyNode *body; QSFuncDeclNode *func; QSClassDefNode *clss; QSProgramNode *prog; QSAssignExprNode *init; QSSourceElementNode *src; QSSourceElementsNode *srcs; QSStatListNode *slist; QSArgumentsNode *args; QSArgumentListNode *alist; QSCaseBlockNode *cblk; QSClauseListNode *clist; QSCaseClauseNode *ccl; QSElementNode *elm; QSElisionNode *eli; QSTypeNode *type; QSTypedVarNode *tvar; QSVarBindingNode *vbin; QSVarBindingListNode *blist; QSAttributeNode *attrs; QSAttribute attr; Operator op; } yystype; # define YYSTYPE yystype # define YYSTYPE_IS_TRIVIAL 1 #endif #ifndef YYLTYPE typedef struct yyltype { int first_line; int first_column; int last_line; int last_column; } yyltype; # define YYLTYPE yyltype # define YYLTYPE_IS_TRIVIAL 1 #endif #ifndef YYDEBUG # define YYDEBUG 0 #endif #define YYFINAL 407 #define YYFLAG -32768 #define YYNTBASE 95 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ #define YYTRANSLATE(x) ((unsigned)(x) <= 324 ? yytranslate[x] : 168) /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ static const char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 84, 2, 2, 2, 86, 89, 2, 72, 73, 85, 81, 78, 82, 80, 71, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 79, 94, 87, 93, 88, 92, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, 2, 77, 90, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 74, 91, 75, 83, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70 }; #if YYDEBUG static const short yyprhs[] = { 0, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 24, 27, 31, 35, 39, 45, 48, 53, 54, 56, 58, 61, 65, 71, 73, 75, 77, 79, 81, 86, 90, 94, 96, 99, 102, 105, 110, 114, 117, 121, 123, 127, 129, 131, 133, 136, 139, 141, 144, 147, 150, 153, 156, 159, 162, 165, 168, 170, 174, 178, 182, 184, 188, 192, 194, 198, 202, 206, 208, 212, 216, 220, 224, 228, 232, 236, 238, 242, 246, 250, 254, 256, 260, 262, 266, 268, 272, 274, 278, 280, 284, 286, 292, 294, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 328, 330, 332, 334, 337, 339, 341, 343, 345, 347, 349, 351, 353, 355, 357, 359, 361, 363, 365, 368, 372, 374, 377, 379, 382, 385, 391, 399, 406, 412, 422, 433, 441, 450, 451, 453, 456, 459, 463, 467, 470, 473, 477, 481, 484, 487, 491, 495, 501, 507, 511, 517, 518, 520, 522, 525, 529, 534, 537, 541, 545, 549, 553, 557, 562, 568, 571, 575, 579, 581, 585, 592, 600, 608, 617, 618, 621, 626, 632, 634, 638, 642, 648, 651, 655, 659, 663, 669, 670, 672, 674, 677, 679, 681, 683, 686, 688, 690, 692, 694, 696, 698, 700, 702, 705, 709, 711, 713, 715, 719, 721, 725, 727, 731 }; static const short yyrhs[] = { 3, 0, 4, 0, 5, 0, 7, 0, 6, 0, 71, 0, 20, 0, 70, 0, 95, 0, 97, 0, 72, 124, 73, 0, 74, 75, 0, 74, 101, 75, 0, 76, 99, 77, 0, 76, 98, 77, 0, 76, 98, 78, 99, 77, 0, 99, 122, 0, 98, 78, 99, 122, 0, 0, 100, 0, 78, 0, 100, 78, 0, 102, 79, 122, 0, 101, 78, 102, 79, 122, 0, 70, 0, 6, 0, 7, 0, 96, 0, 153, 0, 103, 76, 124, 77, 0, 103, 80, 70, 0, 12, 103, 106, 0, 103, 0, 12, 104, 0, 103, 106, 0, 105, 106, 0, 105, 76, 124, 77, 0, 105, 80, 70, 0, 72, 73, 0, 72, 107, 73, 0, 122, 0, 107, 78, 122, 0, 104, 0, 105, 0, 108, 0, 108, 54, 0, 108, 55, 0, 109, 0, 18, 110, 0, 17, 110, 0, 26, 110, 0, 54, 110, 0, 55, 110, 0, 81, 110, 0, 82, 110, 0, 83, 110, 0, 84, 110, 0, 110, 0, 111, 85, 110, 0, 111, 71, 110, 0, 111, 86, 110, 0, 111, 0, 112, 81, 111, 0, 112, 82, 111, 0, 112, 0, 113, 56, 112, 0, 113, 57, 112, 0, 113, 58, 112, 0, 113, 0, 114, 87, 113, 0, 114, 88, 113, 0, 114, 50, 113, 0, 114, 51, 113, 0, 114, 27, 113, 0, 114, 25, 113, 0, 114, 24, 113, 0, 114, 0, 115, 46, 114, 0, 115, 47, 114, 0, 115, 48, 114, 0, 115, 49, 114, 0, 115, 0, 116, 89, 115, 0, 116, 0, 117, 90, 115, 0, 117, 0, 118, 91, 115, 0, 118, 0, 119, 53, 118, 0, 119, 0, 120, 52, 119, 0, 120, 0, 120, 92, 122, 79, 122, 0, 121, 0, 108, 123, 122, 0, 93, 0, 59, 0, 60, 0, 61, 0, 62, 0, 63, 0, 64, 0, 65, 0, 66, 0, 68, 0, 69, 0, 67, 0, 122, 0, 124, 78, 122, 0, 126, 0, 162, 0, 156, 0, 160, 156, 0, 148, 0, 128, 0, 129, 0, 130, 0, 131, 0, 133, 0, 134, 0, 135, 0, 136, 0, 137, 0, 143, 0, 144, 0, 145, 0, 149, 0, 74, 75, 0, 74, 127, 75, 0, 125, 0, 127, 125, 0, 94, 0, 124, 94, 0, 124, 1, 0, 19, 72, 124, 73, 125, 0, 19, 72, 124, 73, 125, 23, 125, 0, 21, 125, 22, 72, 124, 73, 0, 22, 72, 124, 73, 125, 0, 11, 72, 132, 94, 132, 94, 132, 73, 125, 0, 11, 72, 13, 164, 94, 132, 94, 132, 73, 125, 0, 11, 72, 108, 24, 124, 73, 125, 0, 11, 72, 13, 165, 24, 124, 73, 125, 0, 0, 124, 0, 14, 94, 0, 14, 1, 0, 14, 70, 94, 0, 14, 70, 1, 0, 8, 94, 0, 8, 1, 0, 8, 70, 94, 0, 8, 70, 1, 0, 16, 94, 0, 16, 1, 0, 16, 124, 94, 0, 16, 124, 1, 0, 29, 72, 124, 73, 125, 0, 28, 72, 124, 73, 138, 0, 74, 139, 75, 0, 74, 139, 142, 139, 75, 0, 0, 140, 0, 141, 0, 140, 141, 0, 9, 124, 79, 0, 9, 124, 79, 127, 0, 10, 79, 0, 10, 79, 127, 0, 70, 79, 125, 0, 31, 124, 94, 0, 32, 126, 146, 0, 32, 126, 147, 0, 32, 126, 146, 147, 0, 33, 72, 70, 73, 126, 0, 34, 126, 0, 44, 150, 155, 0, 45, 150, 94, 0, 70, 0, 150, 80, 70, 0, 15, 70, 72, 73, 152, 155, 0, 15, 70, 72, 154, 73, 152, 155, 0, 160, 15, 70, 72, 73, 152, 155, 0, 160, 15, 70, 72, 154, 73, 152, 155, 0, 0, 79, 167, 0, 15, 72, 73, 155, 0, 15, 72, 154, 73, 155, 0, 70, 0, 70, 79, 167, 0, 154, 78, 70, 0, 154, 78, 70, 79, 167, 0, 74, 75, 0, 74, 158, 75, 0, 35, 70, 94, 0, 35, 70, 155, 0, 35, 70, 37, 167, 155, 0, 0, 158, 0, 159, 0, 158, 159, 0, 125, 0, 151, 0, 161, 0, 160, 161, 0, 38, 0, 39, 0, 40, 0, 41, 0, 42, 0, 4, 0, 5, 0, 36, 0, 163, 164, 0, 160, 163, 164, 0, 13, 0, 43, 0, 165, 0, 164, 78, 165, 0, 166, 0, 166, 93, 122, 0, 70, 0, 70, 79, 167, 0, 70, 0 }; #endif #if YYDEBUG /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const short yyrline[] = { 0, 155, 157, 158, 159, 160, 161, 166, 168, 170, 171, 172, 173, 174, 177, 179, 180, 183, 185, 189, 191, 194, 196, 199, 201, 205, 208, 209, 212, 214, 215, 216, 218, 221, 223, 226, 228, 229, 230, 234, 236, 239, 241, 244, 246, 249, 251, 252, 255, 257, 258, 259, 260, 261, 262, 263, 264, 265, 268, 270, 271, 272, 275, 277, 278, 281, 283, 284, 285, 288, 290, 292, 294, 296, 298, 300, 302, 306, 308, 309, 310, 311, 314, 316, 319, 321, 324, 326, 329, 331, 335, 337, 341, 343, 347, 349, 353, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 368, 370, 373, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 394, 396, 399, 401, 404, 408, 411, 418, 420, 424, 426, 427, 430, 433, 436, 441, 443, 446, 448, 452, 454, 461, 463, 467, 469, 477, 479, 483, 484, 493, 498, 503, 505, 509, 511, 514, 516, 519, 521, 524, 526, 529, 535, 539, 541, 542, 545, 549, 553, 559, 563, 565, 568, 571, 573, 576, 581, 583, 586, 588, 593, 596, 598, 599, 603, 605, 608, 611, 613, 618, 621, 625, 627, 630, 632, 635, 637, 640, 642, 643, 644, 645, 646, 647, 648, 653, 656, 661, 663, 666, 668, 672, 674, 677, 680, 686 }; #endif #if (YYDEBUG) || defined YYERROR_VERBOSE /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ static const char *const yytname[] = { "$", "error", "$undefined.", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN", "STRING", "NUMBER", "BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR", "CONTINUE", "FUNCTION", "RETURN", "VOID", "DELETE", "IF", "THIS", "DO", "WHILE", "ELSE", "IN", "INSTANCEOF", "TYPEOF", "IS", "SWITCH", "WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "CLASS", "CONSTRUCTOR", "EXTENDS", "ABSTRACT", "FINAL", "PRIVATE", "PUBLIC", "STATIC", "CONST", "PACKAGE", "IMPORT", "EQEQ", "NE", "STREQ", "STRNEQ", "LE", "GE", "OR", "AND", "PLUSPLUS", "MINUSMINUS", "LSHIFT", "RSHIFT", "URSHIFT", "PLUSEQUAL", "MINUSEQUAL", "MULTEQUAL", "DIVEQUAL", "LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL", "ANDEQUAL", "MODEQUAL", "XOREQUAL", "OREQUAL", "IDENT", "'/'", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "':'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", "'%'", "'<'", "'>'", "'&'", "'^'", "'|'", "'?'", "'='", "';'", "Literal", "PrimaryExpr", "ArrayLiteral", "ElementList", "ElisionOpt", "Elision", "PropertyNameAndValueList", "PropertyName", "MemberExpr", "NewExpr", "CallExpr", "Arguments", "ArgumentList", "LeftHandSideExpr", "PostfixExpr", "UnaryExpr", "MultiplicativeExpr", "AdditiveExpr", "ShiftExpr", "RelationalExpr", "EqualityExpr", "BitwiseANDExpr", "BitwiseXORExpr", "BitwiseORExpr", "LogicalANDExpr", "LogicalORExpr", "ConditionalExpr", "AssignmentExpr", "AssignmentOperator", "Expr", "Statement", "Block", "StatementList", "EmptyStatement", "ExprStatement", "IfStatement", "IterationStatement", "ExprOpt", "ContinueStatement", "BreakStatement", "ReturnStatement", "WithStatement", "SwitchStatement", "CaseBlock", "CaseClausesOpt", "CaseClauses", "CaseClause", "DefaultClause", "LabelledStatement", "ThrowStatement", "TryStatement", "Catch", "Finally", "PackageDefinition", "ImportStatement", "PackageName", "FunctionDeclaration", "ResultSignature", "FunctionExpr", "FormalParameterList", "FunctionBody", "ClassDefinition", "Program", "SourceElements", "SourceElement", "Attributes", "Attribute", "VariableDefinition", "VariableDefinitionKind", "VariableBindingList", "VariableBinding", "TypedVariable", "TypeExpression", 0 }; #endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const short yyr1[] = { 0, 95, 95, 95, 95, 95, 95, 96, 96, 96, 96, 96, 96, 96, 97, 97, 97, 98, 98, 99, 99, 100, 100, 101, 101, 102, 102, 102, 103, 103, 103, 103, 103, 104, 104, 105, 105, 105, 105, 106, 106, 107, 107, 108, 108, 109, 109, 109, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 111, 111, 111, 111, 112, 112, 112, 113, 113, 113, 113, 114, 114, 114, 114, 114, 114, 114, 114, 115, 115, 115, 115, 115, 116, 116, 117, 117, 118, 118, 119, 119, 120, 120, 121, 121, 122, 122, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 124, 124, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 126, 126, 127, 127, 128, 129, 129, 130, 130, 131, 131, 131, 131, 131, 131, 132, 132, 133, 133, 133, 133, 134, 134, 134, 134, 135, 135, 135, 135, 136, 137, 138, 138, 139, 139, 140, 140, 141, 141, 142, 142, 143, 144, 145, 145, 145, 146, 147, 148, 149, 150, 150, 151, 151, 151, 151, 152, 152, 153, 153, 154, 154, 154, 154, 155, 155, 156, 156, 156, 157, 157, 158, 158, 159, 159, 160, 160, 161, 161, 161, 161, 161, 161, 161, 161, 162, 162, 163, 163, 164, 164, 165, 165, 166, 166, 167 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ static const short yyr2[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 3, 3, 3, 5, 2, 4, 0, 1, 1, 2, 3, 5, 1, 1, 1, 1, 1, 4, 3, 3, 1, 2, 2, 2, 4, 3, 2, 3, 1, 3, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 5, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 2, 1, 2, 2, 5, 7, 6, 5, 9, 10, 7, 8, 0, 1, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 5, 5, 3, 5, 0, 1, 1, 2, 3, 4, 2, 3, 3, 3, 3, 3, 4, 5, 2, 3, 3, 1, 3, 6, 7, 7, 8, 0, 2, 4, 5, 1, 3, 3, 5, 2, 3, 3, 3, 5, 0, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 3, 1, 3, 1, 3, 1 }; /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ static const short yydefact[] = { 197, 1, 2, 3, 5, 4, 0, 0, 0, 215, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 212, 205, 206, 207, 208, 209, 216, 0, 0, 0, 0, 8, 6, 0, 0, 19, 0, 0, 0, 0, 132, 9, 28, 10, 33, 43, 44, 45, 48, 58, 62, 65, 69, 77, 82, 84, 86, 88, 90, 92, 94, 108, 0, 201, 110, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 114, 127, 202, 29, 112, 198, 199, 0, 203, 111, 0, 150, 0, 149, 143, 2, 3, 0, 8, 0, 33, 34, 146, 0, 145, 0, 0, 154, 153, 0, 45, 50, 49, 0, 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, 178, 0, 0, 52, 53, 0, 0, 5, 4, 8, 12, 0, 0, 130, 0, 21, 0, 0, 20, 54, 55, 56, 57, 0, 0, 0, 35, 0, 0, 36, 46, 47, 97, 98, 99, 100, 101, 102, 103, 104, 107, 105, 106, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 0, 133, 200, 210, 211, 0, 113, 204, 0, 221, 213, 217, 219, 152, 151, 0, 45, 144, 0, 26, 27, 25, 12, 32, 148, 147, 0, 188, 0, 0, 156, 155, 0, 0, 0, 0, 0, 170, 128, 0, 0, 171, 172, 0, 0, 194, 195, 0, 176, 177, 169, 11, 13, 0, 0, 129, 131, 15, 19, 14, 17, 22, 39, 0, 41, 0, 31, 0, 38, 95, 60, 59, 61, 63, 64, 66, 67, 68, 76, 75, 74, 72, 73, 70, 71, 78, 79, 80, 81, 83, 85, 87, 89, 91, 0, 109, 0, 214, 0, 0, 0, 0, 217, 0, 143, 184, 0, 0, 186, 0, 0, 0, 0, 0, 0, 0, 0, 175, 173, 223, 0, 192, 0, 179, 0, 23, 0, 40, 0, 30, 37, 0, 0, 222, 218, 220, 143, 0, 0, 0, 0, 0, 184, 189, 187, 190, 135, 0, 138, 161, 158, 157, 0, 196, 193, 0, 16, 18, 42, 93, 184, 0, 0, 0, 0, 143, 185, 180, 0, 0, 0, 137, 0, 0, 162, 163, 0, 24, 0, 184, 143, 0, 141, 0, 181, 191, 136, 0, 0, 159, 161, 164, 174, 182, 0, 0, 142, 0, 165, 167, 0, 183, 0, 139, 166, 168, 160, 140, 0, 0, 0 }; static const short yydefgoto[] = { 46, 47, 48, 142, 143, 144, 137, 138, 49, 50, 51, 152, 260, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 170, 67, 68, 69, 140, 70, 71, 72, 73, 215, 74, 75, 76, 77, 78, 347, 370, 371, 372, 387, 79, 80, 81, 238, 239, 82, 83, 127, 84, 338, 85, 226, 243, 86, 405, 87, 88, 117, 90, 91, 92, 207, 208, 209, 317 }; static const short yypact[] = { 827,-32768, 264, 332,-32768,-32768, 19, -56, 1130,-32768, 27, 175, 64, 1159, 1159, -46,-32768, 911, -24, 1159, -10, 24, 1159, 3, 32,-32768,-32768,-32768,-32768,-32768, -32768,-32768, 60, 60, 1159, 1159, 49,-32768, 1159, 407, 79, 1159, 1159, 1159, 1159,-32768,-32768,-32768,-32768, 61, -32768, 112, 908,-32768,-32768, 58, 104, 93, 156, 206, 70, 119, 111, 158, -38,-32768,-32768, 9,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768, 827,-32768, 1211, -32768,-32768, 152,-32768, 28,-32768, 149,-32768,-32768, 143, -32768, 50, 61,-32768,-32768, 30,-32768, 176, 38,-32768, -32768, 22, 184,-32768,-32768, 1159, 204, 1223, 1159,-32768, 1159, 1159, -43, 491, 238, 0,-32768, 25, -42,-32768, -32768, 911, -28, 181, 187, 49, 1003, 20, 195,-32768, 575,-32768, 219, 258, 210,-32768,-32768,-32768,-32768, 1046, 1159, 222,-32768, 1159, 224,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159, 1159,-32768, 1159,-32768,-32768, -32768,-32768, 240,-32768,-32768, 152, 242, 223,-32768, 232, -32768,-32768, 152, 1128, 253, 244,-32768,-32768,-32768,-32768, -32768,-32768,-32768, 117, 254, 269, 2,-32768,-32768, 53, 274, 54, 87, 95,-32768,-32768, 276, 3, 282,-32768, 279, 659,-32768,-32768, 283,-32768,-32768,-32768,-32768,-32768, 18, 1159,-32768,-32768,-32768, 79,-32768,-32768,-32768,-32768, 101,-32768, 231,-32768, 237,-32768,-32768,-32768,-32768,-32768, 58, 58, 104, 104, 104, 93, 93, 93, 93, 93, 93, 93, 156, 156, 156, 156, 206, 206, 206, 111, 158, 275,-32768, 284, 223, 279, 152, 1159, -39, 331, 1159, 1159, 278, 132, 279,-32768, 269, 289, 911, 1159, 911, 286, 911, 292,-32768,-32768,-32768, 269,-32768, 743, -32768, 285,-32768, 1077,-32768, 1159,-32768,-32768, 1159, 154, -32768,-32768,-32768, 1159, 1159, 135, 271, 279, 269, 278, -32768,-32768, 290, 340, 139,-32768, 367,-32768,-32768, 307, -32768,-32768, 1159,-32768,-32768,-32768,-32768, 278, 162, 287, 164, 911, 1159,-32768,-32768, 269, 279, 911,-32768, 1159, -2, 367,-32768, 3,-32768, 269, 278, 1159, 911,-32768, 310,-32768,-32768,-32768, 239, 337,-32768, 367,-32768,-32768, -32768, 269, 344,-32768, 911, 911, 911, 355,-32768, 911, -32768, 911, 911,-32768,-32768, 431, 432,-32768 }; static const short yypgoto[] = { -32768,-32768,-32768,-32768, 179,-32768,-32768, 190, 429, 433, -32768, -30,-32768, 215,-32768, -1, 145, 109, 16, 94, -14,-32768,-32768, 251, 259,-32768,-32768, -134,-32768, -11, -17, -21, -69,-32768,-32768,-32768,-32768, -284,-32768,-32768, -32768,-32768,-32768,-32768, 67,-32768, 84,-32768,-32768,-32768, -32768,-32768, 218,-32768,-32768, 424,-32768, -293,-32768, -217, -124, -70,-32768, 217, -83, 5, -59,-32768, -57, -146, -205,-32768, -251 }; #define YYLAST 1266 static const short yytable[] = { 116, 111, 124, 245, 199, 89, 303, 299, 385, 257, 196, 122, 113, 114, 194, 261, 96, 336, 119, 203, 93, 155, 139, 227, 216, 217, 115, 132, 104, 210, 204, 221, 205, 129, 130, 197, 266, 240, 244, 296, 145, 146, 147, 148, 330, 248, 365, 203, 118, 359, 197, 234, 246, 340, 195, 333, 216, 217, 204, 294, 205, 291, 120, 292, 375, 109, 298, 1, 97, 98, 4, 5, 220, 386, 241, 306, 8, 123, 380, 99, 307, 13, 14, 391, 16, 214, 363, 197, 218, 94, 19, 331, 89, 392, 242, 249, 121, 105, 250, 241, 197, 305, 125, 198, 229, 244, 139, 231, 224, 232, 233, 225, 358, 95, 247, 382, 228, 322, 34, 35, 218, 106, 211, 253, 222, 219, 308, 310, 131, 171, 126, 197, 197, 149, 100, 37, 38, 150, 101, 262, 40, 151, 264, 172, 173, 41, 42, 43, 44, 176, 177, 178, 1, 97, 98, 4, 5, 141, 110, 190, 311, 8, 212, 332, 99, 197, 13, 14, 312, 16, 267, 268, 269, 197, 324, 19, 286, 287, 288, 325, 179, 180, 341, 181, 149, 174, 175, 224, 153, 354, 302, 355, 154, 350, 356, 275, 276, 277, 278, 279, 280, 281, 192, 34, 35, 339, 182, 183, 361, 191, 307, 193, 368, 197, 364, 108, 314, 197, 374, 100, 37, 38, 206, 101, 224, 40, 230, 357, 112, 112, 41, 42, 43, 44, 112, 376, 199, 378, 156, 157, 307, 381, 197, 184, 185, 107, 89, 108, 223, 112, 112, 390, 186, 187, 188, 189, 112, 112, 112, 112, -26, 1, 97, 98, 4, 5, -27, 398, -210, -210, 8, 236, 237, 99, 251, 13, 14, -210, 16, -210, 282, 283, 284, 285, 19, 272, 273, 274, 258, 335, 214, 343, 263, 345, 265, 348, 254, 255, 344, -210, -210, 296, -210, -210, -210, -210, -210, -210, 326, 197, 293, 213, 34, 35, 327, 197, 237, 197, 395, 270, 271, 295, 214, 360, 89, 297, 401, 402, 100, 37, 38, 197, 101, 304, 40, 256, -211, -211, 301, 41, 42, 43, 44, 241, 379, -211, 309, -211, 313, 316, 383, 214, 389, 320, 328, 334, 329, 337, 384, 342, 346, 393, 349, 367, 352, 362, 214, -211, -211, 366, -211, -211, -211, -211, -211, -211, 369, 400, 139, 139, 373, 377, 404, 394, 253, 253, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 1, 2, 3, 133, 134, 6, 396, 399, 7, 8, 9, 10, 99, 12, 13, 14, 15, 16, 17, 18, 403, 406, 407, 19, 323, 20, 21, 102, 22, 23, 321, 103, 24, 25, 289, 26, 27, 28, 29, 30, 31, 32, 33, 290, 397, 388, 315, 128, 319, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, 37, 38, 0, 39, 136, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 99, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 0, 39, 235, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 99, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 0, 39, 252, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 0, 39, 318, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 0, 39, 351, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 37, 38, 0, 39, 0, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 1, 2, 3, 4, 5, 6, 0, 45, 7, 8, 9, 10, 99, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 19, 0, 20, 21, 0, 22, 23, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 32, 33, 0, 0, 0, 0, 0, 156, 157, 0, 34, 35, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 0, 0, 0, 36, 37, 38, 0, 39, 0, 40, 0, 0, 0, 0, 41, 42, 43, 44, 0, 0, 0, 0, 0, 169, 0, -128, 0, 45, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128, 0, 0, -128, 0, -128, -128, 0, -128, -128, 0, 0, -128, -128, 0, -128, -128, -128, -128, -128, -128, -128, -128, 1, 97, 98, 4, 5, 0, 0, 0, 0, 8, 0, 0, 99, 0, 13, 14, 0, 16, 0, 0, 0, 0, 0, 19, -128, 0, 0, 0, -128, -128, 0, 1, 97, 98, 4, 5, 0, -128, -128, 0, 8, 0, 0, 99, 0, 13, 14, 0, 16, 0, 0, 34, 35, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, 37, 38, 259, 101, 0, 40, 0, 0, 0, 0, 41, 42, 43, 44, 34, 35, 1, 97, 98, 4, 5, 0, 0, 0, 0, 8, 0, 0, 99, 0, 100, 37, 38, 16, 101, 300, 40, 353, 0, 0, 0, 41, 42, 43, 44, 1, 97, 98, 4, 5, 0, 0, 0, 0, 8, 0, 0, 99, 0, 13, 14, 0, 16, 0, 0, 156, 157, 0, 19, 0, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 0, 0, 100, 37, 38, 0, 101, 0, 40, 0, 0, 0, 0, 0, 0, 34, 35, 200, 201, 0, 0, 0, 0, 169, 0, 0, 9, 0, 202, 200, 201, 100, 37, 38, 0, 101, 0, 40, 9, 0, 0, 0, 41, 42, 43, 44, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31, 0, 0, 0, 24, 25, 0, 26, 27, 28, 29, 30, 31 }; static const short yycheck[] = { 17, 12, 23, 127, 87, 0, 223, 212, 10, 143, 1, 22, 13, 14, 52, 149, 72, 301, 19, 89, 1, 51, 39, 1, 6, 7, 72, 38, 1, 1, 89, 1, 89, 34, 35, 78, 170, 37, 80, 78, 41, 42, 43, 44, 295, 73, 339, 117, 72, 333, 78, 94, 94, 304, 92, 94, 6, 7, 117, 205, 117, 195, 72, 197, 357, 1, 212, 3, 4, 5, 6, 7, 102, 75, 74, 73, 12, 74, 362, 15, 78, 17, 18, 376, 20, 96, 337, 78, 70, 70, 26, 296, 87, 377, 94, 75, 72, 70, 78, 74, 78, 225, 70, 94, 115, 80, 123, 118, 70, 120, 121, 73, 329, 94, 131, 366, 94, 251, 54, 55, 70, 94, 94, 140, 94, 75, 73, 73, 79, 71, 70, 78, 78, 72, 70, 71, 72, 76, 74, 150, 76, 80, 153, 85, 86, 81, 82, 83, 84, 56, 57, 58, 3, 4, 5, 6, 7, 78, 94, 89, 73, 12, 13, 297, 15, 78, 17, 18, 73, 20, 171, 172, 173, 78, 73, 26, 190, 191, 192, 78, 24, 25, 306, 27, 72, 81, 82, 70, 76, 323, 73, 325, 80, 317, 328, 179, 180, 181, 182, 183, 184, 185, 91, 54, 55, 73, 50, 51, 73, 90, 78, 53, 73, 78, 338, 72, 237, 78, 352, 70, 71, 72, 70, 74, 70, 76, 22, 73, 13, 14, 81, 82, 83, 84, 19, 73, 319, 73, 54, 55, 78, 365, 78, 87, 88, 70, 241, 72, 72, 34, 35, 375, 46, 47, 48, 49, 41, 42, 43, 44, 79, 3, 4, 5, 6, 7, 79, 391, 4, 5, 12, 33, 34, 15, 79, 17, 18, 13, 20, 15, 186, 187, 188, 189, 26, 176, 177, 178, 78, 300, 301, 308, 70, 310, 70, 312, 77, 78, 309, 35, 36, 78, 38, 39, 40, 41, 42, 43, 77, 78, 70, 96, 54, 55, 77, 78, 34, 78, 79, 174, 175, 79, 333, 334, 319, 93, 395, 396, 70, 71, 72, 78, 74, 79, 76, 77, 4, 5, 94, 81, 82, 83, 84, 74, 361, 13, 72, 15, 72, 70, 367, 362, 373, 70, 79, 24, 72, 79, 369, 70, 74, 378, 70, 23, 79, 94, 377, 35, 36, 79, 38, 39, 40, 41, 42, 43, 9, 394, 395, 396, 73, 94, 399, 73, 401, 402, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 3, 4, 5, 6, 7, 8, 79, 73, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 75, 0, 0, 26, 255, 28, 29, 8, 31, 32, 250, 8, 35, 36, 193, 38, 39, 40, 41, 42, 43, 44, 45, 194, 387, 371, 238, 33, 241, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, 75, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, -1, 54, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, -1, 74, -1, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, 3, 4, 5, 6, 7, 8, -1, 94, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, 54, 55, -1, 54, 55, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, -1, -1, -1, 70, 71, 72, -1, 74, -1, 76, -1, -1, -1, -1, 81, 82, 83, 84, -1, -1, -1, -1, -1, 93, -1, 0, -1, 94, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, -1, -1, 26, -1, 28, 29, -1, 31, 32, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, 44, 45, 3, 4, 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 15, -1, 17, 18, -1, 20, -1, -1, -1, -1, -1, 26, 70, -1, -1, -1, 74, 75, -1, 3, 4, 5, 6, 7, -1, 83, 84, -1, 12, -1, -1, 15, -1, 17, 18, -1, 20, -1, -1, 54, 55, -1, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, -1, 76, -1, -1, -1, -1, 81, 82, 83, 84, 54, 55, 3, 4, 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 15, -1, 70, 71, 72, 20, 74, 24, 76, 77, -1, -1, -1, 81, 82, 83, 84, 3, 4, 5, 6, 7, -1, -1, -1, -1, 12, -1, -1, 15, -1, 17, 18, -1, 20, -1, -1, 54, 55, -1, 26, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, -1, -1, 70, 71, 72, -1, 74, -1, 76, -1, -1, -1, -1, -1, -1, 54, 55, 4, 5, -1, -1, -1, -1, 93, -1, -1, 13, -1, 15, 4, 5, 70, 71, 72, -1, 74, -1, 76, 13, -1, -1, -1, 81, 82, 83, 84, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43, -1, -1, -1, 35, 36, -1, 38, 39, 40, 41, 42, 43 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr/share/bison/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) /* The parser invokes alloca or malloc; define the necessary symbols. */ # if YYSTACK_USE_ALLOCA # define YYSTACK_ALLOC alloca # else # ifndef YYSTACK_USE_ALLOCA # if defined (alloca) || defined (_ALLOCA_H) # define YYSTACK_ALLOC alloca # else # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # else # if defined (__STDC__) || defined (__cplusplus) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif # define YYSTACK_ALLOC malloc # define YYSTACK_FREE free # endif #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ #if (! defined (yyoverflow) \ && (! defined (__cplusplus) \ || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { short yyss; YYSTYPE yyvs; # if YYLSP_NEEDED YYLTYPE yyls; # endif }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # if YYLSP_NEEDED # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAX) # else # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAX) # endif /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY # if 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else # define YYCOPY(To, From, Count) \ do \ { \ register YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (To)[yyi] = (From)[yyi]; \ } \ while (0) # endif # endif /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ #endif #if ! defined (YYSIZE_T) && defined (size_t) # define YYSIZE_T size_t #endif #if ! defined (YYSIZE_T) # if defined (__STDC__) || defined (__cplusplus) # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif #endif #if ! defined (YYSIZE_T) # define YYSIZE_T unsigned int #endif #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrlab1 /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ yyerror ("syntax error: cannot back up"); \ YYERROR; \ } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Compute the default location (before the actions are run). When YYLLOC_DEFAULT is run, CURRENT is set the location of the first token. By default, to implement support for ranges, extend its range to the last symbol. */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ Current.last_line = Rhs[N].last_line; \ Current.last_column = Rhs[N].last_column; #endif /* YYLEX -- calling `yylex' with the right arguments. */ #if YYPURE # if YYLSP_NEEDED # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) # else # define YYLEX yylex (&yylval, &yylloc) # endif # else /* !YYLSP_NEEDED */ # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, YYLEX_PARAM) # else # define YYLEX yylex (&yylval) # endif # endif /* !YYLSP_NEEDED */ #else /* !YYPURE */ # define YYLEX yylex () #endif /* !YYPURE */ /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #if YYMAXDEPTH == 0 # undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #ifdef YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T # if defined (__STDC__) || defined (__cplusplus) yystrlen (const char *yystr) # else yystrlen (yystr) const char *yystr; # endif { register const char *yys = yystr; while (*yys++ != '\0') continue; return yys - yystr - 1; } # endif # endif # ifndef yystpcpy # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * # if defined (__STDC__) || defined (__cplusplus) yystpcpy (char *yydest, const char *yysrc) # else yystpcpy (yydest, yysrc) char *yydest; const char *yysrc; # endif { register char *yyd = yydest; register const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif #endif #line 315 "/usr/share/bison/bison.simple" /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. It should actually point to an object. Grammar actions can access the variable by casting it to the proper pointer type. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM # define YYPARSE_PARAM_DECL # else # define YYPARSE_PARAM_ARG YYPARSE_PARAM # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; # endif #else /* !YYPARSE_PARAM */ # define YYPARSE_PARAM_ARG # define YYPARSE_PARAM_DECL #endif /* !YYPARSE_PARAM */ /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ # ifdef YYPARSE_PARAM int yyparse (void *); # else int yyparse (void); # endif #endif /* YY_DECL_VARIABLES -- depending whether we use a pure parser, variables are global, or local to YYPARSE. */ #define YY_DECL_NON_LSP_VARIABLES \ /* The lookahead symbol. */ \ int yychar; \ \ /* The semantic value of the lookahead symbol. */ \ YYSTYPE yylval; \ \ /* Number of parse errors so far. */ \ int yynerrs; #if YYLSP_NEEDED # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES \ \ /* Location data for the lookahead symbol. */ \ YYLTYPE yylloc; #else # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES #endif /* If nonreentrant, generate the variables here. */ #if !YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ int yyparse (YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL { /* If reentrant, generate the variables here. */ #if YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Lookahead token as an internal (translated) token number. */ int yychar1 = 0; /* Three stacks and their tools: `yyss': related to states, `yyvs': related to semantic values, `yyls': related to locations. Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ short yyssa[YYINITDEPTH]; short *yyss = yyssa; register short *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; #if YYLSP_NEEDED /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; #endif #if YYLSP_NEEDED # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else # define YYPOPSTACK (yyvsp--, yyssp--) #endif YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; #if YYLSP_NEEDED YYLTYPE yyloc; #endif /* When reducing, the number of symbols on the RHS of the reduced rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss; yyvsp = yyvs; #if YYLSP_NEEDED yylsp = yyls; #endif goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; short *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ # if YYLSP_NEEDED YYLTYPE *yyls1 = yyls; /* This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; # else yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); # endif yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyoverflowlab; # else /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) goto yyoverflowlab; yystacksize *= 2; if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; { short *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (yyss); YYSTACK_RELOCATE (yyvs); # if YYLSP_NEEDED YYSTACK_RELOCATE (yyls); # endif # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; #if YYLSP_NEEDED yylsp = yyls + yysize - 1; #endif YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyssp >= yyss + yystacksize - 1) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yychar1 = YYTRANSLATE (yychar); #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { YYFPRINTF (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ # ifdef YYPRINT YYPRINT (stderr, yychar, yylval); # endif YYFPRINTF (stderr, ")\n"); } #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1])); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets YYVAL to the semantic value of the lookahead token. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; #if YYLSP_NEEDED /* Similarly for the default location. Let the user run additional commands if for instance locations are ranges. */ yyloc = yylsp[1-yylen]; YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); #endif #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { int yyi; YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", yyn, yyrline[yyn]); /* Print the symbols being reduced, and their result. */ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif switch (yyn) { case 1: #line 156 "grammar.y" { yyval.node = new QSNullNode(); ; break;} case 2: #line 157 "grammar.y" { yyval.node = new QSBooleanNode(true); ; break;} case 3: #line 158 "grammar.y" { yyval.node = new QSBooleanNode(false); ; break;} case 4: #line 159 "grammar.y" { yyval.node = new QSNumberNode(yyvsp[0].dval); ; break;} case 5: #line 160 "grammar.y" { yyval.node = new QSStringNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 6: #line 161 "grammar.y" { QSLexer *l = QSLexer::curr(); if (!l->scanRegExp()) YYABORT; yyval.node = new QSRegExpNode(l->pattern,l->flags);; break;} case 7: #line 167 "grammar.y" { yyval.node = new QSThisNode(); ; break;} case 8: #line 168 "grammar.y" { yyval.node = new QSResolveNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 11: #line 172 "grammar.y" { yyval.node = new QSGroupNode(yyvsp[-1].node); ; break;} case 12: #line 173 "grammar.y" { yyval.node = new QSObjectLiteralNode(0L); ; break;} case 13: #line 174 "grammar.y" { yyval.node = new QSObjectLiteralNode(yyvsp[-1].node); ; break;} case 14: #line 178 "grammar.y" { yyval.node = new QSArrayNode(yyvsp[-1].eli); ; break;} case 15: #line 179 "grammar.y" { yyval.node = new QSArrayNode(yyvsp[-1].elm); ; break;} case 16: #line 180 "grammar.y" { yyval.node = new QSArrayNode(yyvsp[-1].eli, yyvsp[-3].elm); ; break;} case 17: #line 184 "grammar.y" { yyval.elm = new QSElementNode(yyvsp[-1].eli, yyvsp[0].node); ; break;} case 18: #line 186 "grammar.y" { yyval.elm = new QSElementNode(yyvsp[-3].elm, yyvsp[-1].eli, yyvsp[0].node); ; break;} case 19: #line 190 "grammar.y" { yyval.eli = 0L; ; break;} case 21: #line 195 "grammar.y" { yyval.eli = new QSElisionNode(0L); ; break;} case 22: #line 196 "grammar.y" { yyval.eli = new QSElisionNode(yyvsp[-1].eli); ; break;} case 23: #line 200 "grammar.y" { yyval.node = new QSPropertyValueNode(yyvsp[-2].node, yyvsp[0].node); ; break;} case 24: #line 202 "grammar.y" { yyval.node = new QSPropertyValueNode(yyvsp[-2].node, yyvsp[0].node, yyvsp[-4].node); ; break;} case 25: #line 206 "grammar.y" { yyval.node = new QSPropertyNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 26: #line 208 "grammar.y" { yyval.node = new QSPropertyNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 27: #line 209 "grammar.y" { yyval.node = new QSPropertyNode(yyvsp[0].dval); ; break;} case 30: #line 215 "grammar.y" { yyval.node = new QSAccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ; break;} case 31: #line 216 "grammar.y" { yyval.node = new QSAccessorNode2(yyvsp[-2].node, yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 32: #line 218 "grammar.y" { yyval.node = new QSNewExprNode(yyvsp[-1].node, yyvsp[0].args); ; break;} case 34: #line 223 "grammar.y" { yyval.node = new QSNewExprNode(yyvsp[0].node); ; break;} case 35: #line 227 "grammar.y" { yyval.node = new QSFunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ; break;} case 36: #line 228 "grammar.y" { yyval.node = new QSFunctionCallNode(yyvsp[-1].node, yyvsp[0].args); ; break;} case 37: #line 229 "grammar.y" { yyval.node = new QSAccessorNode1(yyvsp[-3].node, yyvsp[-1].node); ; break;} case 38: #line 230 "grammar.y" { yyval.node = new QSAccessorNode2(yyvsp[-2].node, yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} case 39: #line 235 "grammar.y" { yyval.args = new QSArgumentsNode(0L); ; break;} case 40: #line 236 "grammar.y" { yyval.args = new QSArgumentsNode(yyvsp[-1].alist); ; break;} case 41: #line 240 "grammar.y" { yyval.alist = new QSArgumentListNode(yyvsp[0].node); ; break;} case 42: #line 241 "grammar.y" { yyval.alist = new QSArgumentListNode(yyvsp[-2].alist, yyvsp[0].node); ; break;} case 46: #line 251 "grammar.y" { yyval.node = new QSPostfixNode(yyvsp[-1].node, OpPlusPlus); ; break;} case 47: #line 252 "grammar.y" { yyval.node = new QSPostfixNode(yyvsp[-1].node, OpMinusMinus); ; break;} case 49: #line 257 "grammar.y" { yyval.node = new QSDeleteNode(yyvsp[0].node); ; break;} case 50: #line 258 "grammar.y" { yyval.node = new QSVoidNode(yyvsp[0].node); ; break;} case 51: #line 259 "grammar.y" { yyval.node = new QSTypeOfNode(yyvsp[0].node); ; break;} case 52: #line 260 "grammar.y" { yyval.node = new QSPrefixNode(OpPlusPlus, yyvsp[0].node); ; break;} case 53: #line 261 "grammar.y" { yyval.node = new QSPrefixNode(OpMinusMinus, yyvsp[0].node); ; break;} case 54: #line 262 "grammar.y" { yyval.node = new QSUnaryPlusNode(yyvsp[0].node); ; break;} case 55: #line 263 "grammar.y" { yyval.node = new QSNegateNode(yyvsp[0].node); ; break;} case 56: #line 264 "grammar.y" { yyval.node = new QSBitwiseNotNode(yyvsp[0].node); ; break;} case 57: #line 265 "grammar.y" { yyval.node = new QSLogicalNotNode(yyvsp[0].node); ; break;} case 59: #line 270 "grammar.y" { yyval.node = new QSMultNode(yyvsp[-2].node, yyvsp[0].node, '*'); ; break;} case 60: #line 271 "grammar.y" { yyval.node = new QSMultNode(yyvsp[-2].node, yyvsp[0].node, '/'); ; break;} case 61: #line 272 "grammar.y" { yyval.node = new QSMultNode(yyvsp[-2].node,yyvsp[0].node,'%'); ; break;} case 63: #line 277 "grammar.y" { yyval.node = new QSAddNode(yyvsp[-2].node, yyvsp[0].node, '+'); ; break;} case 64: #line 278 "grammar.y" { yyval.node = new QSAddNode(yyvsp[-2].node, yyvsp[0].node, '-'); ; break;} case 66: #line 283 "grammar.y" { yyval.node = new QSShiftNode(yyvsp[-2].node, OpLShift, yyvsp[0].node); ; break;} case 67: #line 284 "grammar.y" { yyval.node = new QSShiftNode(yyvsp[-2].node, OpRShift, yyvsp[0].node); ; break;} case 68: #line 285 "grammar.y" { yyval.node = new QSShiftNode(yyvsp[-2].node, OpURShift, yyvsp[0].node); ; break;} case 70: #line 291 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpLess, yyvsp[0].node); ; break;} case 71: #line 293 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpGreater, yyvsp[0].node); ; break;} case 72: #line 295 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpLessEq, yyvsp[0].node); ; break;} case 73: #line 297 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpGreaterEq, yyvsp[0].node); ; break;} case 74: #line 299 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpIs, yyvsp[0].node); ; break;} case 75: #line 301 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpInstanceOf, yyvsp[0].node); ; break;} case 76: #line 303 "grammar.y" { yyval.node = new QSRelationalNode(yyvsp[-2].node, OpIn, yyvsp[0].node); ; break;} case 78: #line 308 "grammar.y" { yyval.node = new QSEqualNode(yyvsp[-2].node, OpEqEq, yyvsp[0].node); ; break;} case 79: #line 309 "grammar.y" { yyval.node = new QSEqualNode(yyvsp[-2].node, OpNotEq, yyvsp[0].node); ; break;} case 80: #line 310 "grammar.y" { yyval.node = new QSEqualNode(yyvsp[-2].node, OpStrEq, yyvsp[0].node); ; break;} case 81: #line 311 "grammar.y" { yyval.node = new QSEqualNode(yyvsp[-2].node, OpStrNEq, yyvsp[0].node);; break;} case 83: #line 316 "grammar.y" { yyval.node = new QSBitOperNode(yyvsp[-2].node, OpBitAnd, yyvsp[0].node); ; break;} case 85: #line 321 "grammar.y" { yyval.node = new QSBitOperNode(yyvsp[-2].node, OpBitXOr, yyvsp[0].node); ; break;} case 87: #line 326 "grammar.y" { yyval.node = new QSBitOperNode(yyvsp[-2].node, OpBitOr, yyvsp[0].node); ; break;} case 89: #line 332 "grammar.y" { yyval.node = new QSBinaryLogicalNode(yyvsp[-2].node, OpAnd, yyvsp[0].node); ; break;} case 91: #line 338 "grammar.y" { yyval.node = new QSBinaryLogicalNode(yyvsp[-2].node, OpOr, yyvsp[0].node); ; break;} case 93: #line 344 "grammar.y" { yyval.node = new QSConditionalNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ; break;} case 95: #line 350 "grammar.y" { yyval.node = new QSAssignNode(yyvsp[-2].node, yyvsp[-1].op, yyvsp[0].node);; break;} case 96: #line 354 "grammar.y" { yyval.op = OpEqual; ; break;} case 97: #line 355 "grammar.y" { yyval.op = OpPlusEq; ; break;} case 98: #line 356 "grammar.y" { yyval.op = OpMinusEq; ; break;} case 99: #line 357 "grammar.y" { yyval.op = OpMultEq; ; break;} case 100: #line 358 "grammar.y" { yyval.op = OpDivEq; ; break;} case 101: #line 359 "grammar.y" { yyval.op = OpLShift; ; break;} case 102: #line 360 "grammar.y" { yyval.op = OpRShift; ; break;} case 103: #line 361 "grammar.y" { yyval.op = OpURShift; ; break;} case 104: #line 362 "grammar.y" { yyval.op = OpAndEq; ; break;} case 105: #line 363 "grammar.y" { yyval.op = OpXOrEq; ; break;} case 106: #line 364 "grammar.y" { yyval.op = OpOrEq; ; break;} case 107: #line 365 "grammar.y" { yyval.op = OpModEq; ; break;} case 109: #line 370 "grammar.y" { yyval.node = new QSCommaNode(yyvsp[-2].node, yyvsp[0].node); ; break;} case 112: #line 376 "grammar.y" { yyval.stat = yyvsp[0].clss; ; break;} case 113: #line 377 "grammar.y" { yyvsp[0].clss->setAttributes( yyvsp[-1].attrs ); yyval.stat = yyvsp[0].clss; ; break;} case 128: #line 395 "grammar.y" { yyval.stat = new QSBlockNode(0L); DBG(yyval.stat, yylsp[0], yylsp[0]); ; break;} case 129: #line 396 "grammar.y" { yyval.stat = new QSBlockNode(yyvsp[-1].slist); DBG(yyval.stat, yylsp[0], yylsp[0]); ; break;} case 130: #line 400 "grammar.y" { yyval.slist = new QSStatListNode(yyvsp[0].stat); ; break;} case 131: #line 401 "grammar.y" { yyval.slist = new QSStatListNode(yyvsp[-1].slist, yyvsp[0].stat); ; break;} case 132: #line 405 "grammar.y" { yyval.stat = new QSEmptyStatementNode(); ; break;} case 133: #line 409 "grammar.y" { yyval.stat = new QSExprStatementNode(yyvsp[-1].node); DBG(yyval.stat, yylsp[-1], yylsp[0]); ; break;} case 134: #line 411 "grammar.y" { if (automatic()) { yyval.stat = new QSExprStatementNode(yyvsp[-1].node); DBG(yyval.stat, yylsp[-1], yylsp[-1]); } else YYABORT; ; break;} case 135: #line 419 "grammar.y" { yyval.stat = new QSIfNode(yyvsp[-2].node,yyvsp[0].stat,0L);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ; break;} case 136: #line 421 "grammar.y" { yyval.stat = new QSIfNode(yyvsp[-4].node,yyvsp[-2].stat,yyvsp[0].stat);DBG(yyval.stat,yylsp[-6],yylsp[-3]); ; break;} case 137: #line 425 "grammar.y" { yyval.stat=new QSDoWhileNode(yyvsp[-4].stat,yyvsp[-1].node);DBG(yyval.stat,yylsp[-5],yylsp[-3]);; break;} case 138: #line 426 "grammar.y" { yyval.stat = new QSWhileNode(yyvsp[-2].node,yyvsp[0].stat);DBG(yyval.stat,yylsp[-4],yylsp[-1]); ; break;} case 139: #line 428 "grammar.y" { yyval.stat = new QSForNode(yyvsp[-6].node,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat); DBG(yyval.stat,yylsp[-8],yylsp[-1]); ; break;} case 140: #line 431 "grammar.y" { yyval.stat = new QSForNode(yyvsp[-6].blist,yyvsp[-4].node,yyvsp[-2].node,yyvsp[0].stat); DBG(yyval.stat,yylsp[-9],yylsp[-1]); ; break;} case 141: #line 434 "grammar.y" { yyval.stat = new QSForInNode(yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].stat); DBG(yyval.stat,yylsp[-6],yylsp[-1]); ; break;} case 142: #line 437 "grammar.y" { yyval.stat = new QSForInNode(yyvsp[-4].vbin,yyvsp[-2].node,yyvsp[0].stat); DBG(yyval.stat,yylsp[-7],yylsp[-1]); ; break;} case 143: #line 442 "grammar.y" { yyval.node = 0L; ; break;} case 145: #line 447 "grammar.y" { yyval.stat = new QSContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]); ; break;} case 146: #line 448 "grammar.y" { if (automatic()) { yyval.stat = new QSContinueNode(); DBG(yyval.stat,yylsp[-1],yylsp[0]); } else YYABORT; ; break;} case 147: #line 452 "grammar.y" { yyval.stat = new QSContinueNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[0]); delete yyvsp[-1].ustr; ; break;} case 148: #line 454 "grammar.y" { if (automatic()) { yyval.stat = new QSContinueNode(yyvsp[-1].ustr);DBG(yyval.stat,yylsp[-2],yylsp[-1]); delete yyvsp[-1].ustr; } else YYABORT; ; break;} case 149: #line 462 "grammar.y" { yyval.stat = new QSBreakNode();DBG(yyval.stat,yylsp[-1],yylsp[0]); ; break;} case 150: #line 463 "grammar.y" { if (automatic()) { yyval.stat = new QSBreakNode(); DBG(yyval.stat,yylsp[-1],yylsp[-1]); } else YYABORT; ; break;} case 151: #line 467 "grammar.y" { yyval.stat = new QSBreakNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[0]); delete yyvsp[-1].ustr; ; break;} case 152: #line 469 "grammar.y" { if (automatic()) { yyval.stat = new QSBreakNode(yyvsp[-1].ustr); DBG(yyval.stat,yylsp[-2],yylsp[-1]); delete yyvsp[-1].ustr; } else YYABORT; ; break;} case 153: #line 478 "grammar.y" { yyval.stat = new QSReturnNode(0L); DBG(yyval.stat,yylsp[-1],yylsp[0]); ; break;} case 154: #line 479 "grammar.y" { if (automatic()) { yyval.stat = new QSReturnNode(0L); DBG(yyval.stat,yylsp[-1],yylsp[-1]); } else YYABORT; ; break;} case 155: #line 483 "grammar.y" { yyval.stat = new QSReturnNode(yyvsp[-1].node); DBG(yyval.stat,yylsp[-2],yylsp[-1]); ; break;} case 156: #line 484 "grammar.y" { if (automatic()) { yyval.stat = new QSReturnNode(yyvsp[-1].node); DBG(yyval.stat,yylsp[-2],yylsp[-1]); } else { YYABORT; } ; break;} case 157: #line 494 "grammar.y" { yyval.stat = new QSWithNode(yyvsp[-2].node,yyvsp[0].stat); DBG(yyval.stat, yylsp[-4], yylsp[-1]); ; break;} case 158: #line 499 "grammar.y" { yyval.stat = new QSSwitchNode(yyvsp[-2].node, yyvsp[0].cblk); DBG(yyval.stat, yylsp[-4], yylsp[-1]); ; break;} case 159: #line 504 "grammar.y" { yyval.cblk = new QSCaseBlockNode(yyvsp[-1].clist, 0L, 0L); ; break;} case 160: #line 506 "grammar.y" { yyval.cblk = new QSCaseBlockNode(yyvsp[-3].clist, yyvsp[-2].ccl, yyvsp[-1].clist); ; break;} case 161: #line 510 "grammar.y" { yyval.clist = 0L; ; break;} case 163: #line 515 "grammar.y" { yyval.clist = new QSClauseListNode(yyvsp[0].ccl); ; break;} case 164: #line 516 "grammar.y" { yyval.clist = yyvsp[-1].clist->append(yyvsp[0].ccl); ; break;} case 165: #line 520 "grammar.y" { yyval.ccl = new QSCaseClauseNode(yyvsp[-1].node, 0L); ; break;} case 166: #line 521 "grammar.y" { yyval.ccl = new QSCaseClauseNode(yyvsp[-2].node, yyvsp[0].slist); ; break;} case 167: #line 525 "grammar.y" { yyval.ccl = new QSCaseClauseNode(0L, 0L);; ; break;} case 168: #line 526 "grammar.y" { yyval.ccl = new QSCaseClauseNode(0L, yyvsp[0].slist); ; break;} case 169: #line 530 "grammar.y" { yyvsp[0].stat->pushLabel(yyvsp[-2].ustr); yyval.stat = new QSLabelNode(yyvsp[-2].ustr, yyvsp[0].stat); delete yyvsp[-2].ustr; ; break;} case 170: #line 536 "grammar.y" { yyval.stat = new QSThrowNode(yyvsp[-1].node); ; break;} case 171: #line 540 "grammar.y" { yyval.stat = new QSTryNode(yyvsp[-1].stat, yyvsp[0].node); ; break;} case 172: #line 541 "grammar.y" { yyval.stat = new QSTryNode(yyvsp[-1].stat, 0L, yyvsp[0].node); ; break;} case 173: #line 542 "grammar.y" { yyval.stat = new QSTryNode(yyvsp[-2].stat, yyvsp[-1].node, yyvsp[0].node); ; break;} case 174: #line 546 "grammar.y" { yyval.node = new QSCatchNode(yyvsp[-2].ustr, yyvsp[0].stat); delete yyvsp[-2].ustr; ; break;} case 175: #line 550 "grammar.y" { yyval.node = new QSFinallyNode(yyvsp[0].stat); ; break;} case 176: #line 555 "grammar.y" { yyval.stat = new QSPackageNode(yyvsp[-1].ustr, yyvsp[0].body); delete yyvsp[-1].ustr; ; break;} case 177: #line 560 "grammar.y" { yyval.stat = new QSImportNode(yyvsp[-1].ustr); delete yyvsp[-1].ustr; ; break;} case 178: #line 564 "grammar.y" { yyval.ustr = yyvsp[0].ustr; delete yyvsp[0].ustr; ; break;} case 179: #line 565 "grammar.y" { *yyval.ustr += "." + *yyvsp[0].ustr; delete yyvsp[0].ustr; ; break;} case 180: #line 570 "grammar.y" { yyval.func = new QSFuncDeclNode(yyvsp[-4].ustr, 0L, yyvsp[-1].type, yyvsp[0].body); delete yyvsp[-4].ustr; ; break;} case 181: #line 572 "grammar.y" { yyval.func = new QSFuncDeclNode(yyvsp[-5].ustr, yyvsp[-3].param, yyvsp[-1].type, yyvsp[0].body); delete yyvsp[-5].ustr; ; break;} case 182: #line 574 "grammar.y" { yyval.func = new QSFuncDeclNode(yyvsp[-4].ustr, 0L, yyvsp[-1].type, yyvsp[0].body); yyval.func->setAttributes( yyvsp[-6].attrs ); delete yyvsp[-4].ustr; ; break;} case 183: #line 577 "grammar.y" { yyval.func = new QSFuncDeclNode(yyvsp[-5].ustr, yyvsp[-3].param, yyvsp[-1].type, yyvsp[0].body); yyval.func->setAttributes( yyvsp[-7].attrs ); delete yyvsp[-5].ustr; ; break;} case 184: #line 582 "grammar.y" { yyval.type = 0L; ; break;} case 185: #line 583 "grammar.y" { yyval.type = yyvsp[0].type; ; break;} case 186: #line 587 "grammar.y" { yyval.node = new QSFuncExprNode(0L, yyvsp[0].body); ; break;} case 187: #line 589 "grammar.y" { yyval.node = new QSFuncExprNode(yyvsp[-2].param, yyvsp[0].body); ; break;} case 188: #line 594 "grammar.y" { yyval.param = new QSParameterNode(yyvsp[0].ustr, 0L); delete yyvsp[0].ustr; ; break;} case 189: #line 596 "grammar.y" { yyval.param = new QSParameterNode(yyvsp[-2].ustr, yyvsp[0].type); delete yyvsp[-2].ustr; ; break;} case 190: #line 598 "grammar.y" { yyval.param = yyvsp[-2].param->append(yyvsp[0].ustr, 0L); delete yyvsp[0].ustr; ; break;} case 191: #line 600 "grammar.y" { yyval.param = yyvsp[-4].param->append(yyvsp[-2].ustr, yyvsp[0].type); delete yyvsp[-2].ustr; ; break;} case 192: #line 604 "grammar.y" { yyval.body = new QSFunctionBodyNode(0L); ; break;} case 193: #line 605 "grammar.y" { yyval.body = new QSFunctionBodyNode(yyvsp[-1].srcs); ; break;} case 194: #line 609 "grammar.y" { yyval.clss = new QSClassDefNode(yyvsp[-1].ustr, 0L, 0L); delete yyvsp[-1].ustr; ; break;} case 195: #line 611 "grammar.y" { yyval.clss = new QSClassDefNode(yyvsp[-1].ustr, 0L, yyvsp[0].body); delete yyvsp[-1].ustr; ; break;} case 196: #line 614 "grammar.y" { yyval.clss = new QSClassDefNode(yyvsp[-3].ustr, yyvsp[-1].type, yyvsp[0].body); delete yyvsp[-3].ustr; ; break;} case 197: #line 619 "grammar.y" { yyval.prog = new QSProgramNode(0L); QSEngineImp::current()->setProgNode(yyval.prog); ; break;} case 198: #line 621 "grammar.y" { yyval.prog = new QSProgramNode(yyvsp[0].srcs); QSEngineImp::current()->setProgNode(yyval.prog); ; break;} case 199: #line 626 "grammar.y" { yyval.srcs = new QSSourceElementsNode(yyvsp[0].src); ; break;} case 200: #line 627 "grammar.y" { yyval.srcs = new QSSourceElementsNode(yyvsp[-1].srcs, yyvsp[0].src); ; break;} case 201: #line 631 "grammar.y" { yyval.src = new QSSourceElementNode(yyvsp[0].stat); ; break;} case 202: #line 632 "grammar.y" { yyval.src = new QSSourceElementNode(yyvsp[0].func); ; break;} case 203: #line 636 "grammar.y" { yyval.attrs = new QSAttributeNode(yyvsp[0].attr); ; break;} case 204: #line 637 "grammar.y" { yyvsp[-1].attrs->add(yyvsp[0].attr); yyval.attrs = yyvsp[-1].attrs; ; break;} case 205: #line 641 "grammar.y" { yyval.attr = AttributeAbstract; ; break;} case 206: #line 642 "grammar.y" { yyval.attr = AttributeFinal; ; break;} case 207: #line 643 "grammar.y" { yyval.attr = AttributePrivate; ; break;} case 208: #line 644 "grammar.y" { yyval.attr = AttributePublic; ; break;} case 209: #line 645 "grammar.y" { yyval.attr = AttributeStatic; ; break;} case 210: #line 646 "grammar.y" { yyval.attr = AttributeTrue; ; break;} case 211: #line 647 "grammar.y" { yyval.attr = AttributeFalse; ; break;} case 212: #line 648 "grammar.y" { yyval.attr = AttributeConstructor; ; break;} case 213: #line 655 "grammar.y" { yyval.stat = new QSVarDefNode(yyvsp[-1].ival, yyvsp[0].blist); DBG(yyval.stat, yylsp[-1], yylsp[0]); ; break;} case 214: #line 657 "grammar.y" { yyval.stat = new QSVarDefNode(yyvsp[-1].ival, yyvsp[0].blist); DBG(yyval.stat, yylsp[-2], yylsp[0]); ((QSVarDefNode*)yyval.stat)->setAttributes( yyvsp[-2].attrs ); ; break;} case 215: #line 662 "grammar.y" { yyval.ival = 0; ; break;} case 216: #line 663 "grammar.y" { yyval.ival = 1; ; break;} case 217: #line 667 "grammar.y" { yyval.blist = new QSVarBindingListNode(0L, yyvsp[0].vbin); ; break;} case 218: #line 669 "grammar.y" { yyval.blist = new QSVarBindingListNode(yyvsp[-2].blist, yyvsp[0].vbin); ; break;} case 219: #line 673 "grammar.y" { yyval.vbin = new QSVarBindingNode(yyvsp[0].tvar, 0L); ; break;} case 220: #line 674 "grammar.y" { yyval.vbin = new QSVarBindingNode(yyvsp[-2].tvar, yyvsp[0].node); ; break;} case 221: #line 678 "grammar.y" { yyval.tvar = new QSTypedVarNode(yyvsp[0].ustr, 0L); delete yyvsp[0].ustr; ; break;} case 222: #line 680 "grammar.y" { yyval.tvar = new QSTypedVarNode(yyvsp[-2].ustr, yyvsp[0].type); delete yyvsp[-2].ustr; ; break;} case 223: #line 687 "grammar.y" { yyval.type = new QSTypeNode(yyvsp[0].ustr); delete yyvsp[0].ustr; ; break;} } #line 705 "/usr/share/bison/bison.simple" yyvsp -= yylen; yyssp -= yylen; #if YYLSP_NEEDED yylsp -= yylen; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif *++yyvsp = yyval; #if YYLSP_NEEDED *++yylsp = yyloc; #endif /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #ifdef YYERROR_VERBOSE yyn = yypact[yystate]; if (yyn > YYFLAG && yyn < YYLAST) { YYSIZE_T yysize = 0; char *yymsg; int yyx, yycount; yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("parse error, unexpected ") + 1; yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { char *yyp = yystpcpy (yymsg, "parse error, unexpected "); yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); if (yycount < 5) { yycount = 0; for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) { const char *yyq = ! yycount ? ", expecting " : " or "; yyp = yystpcpy (yyp, yyq); yyp = yystpcpy (yyp, yytname[yyx]); yycount++; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else yyerror ("parse error; also virtual memory exhausted"); } else #endif /* defined (YYERROR_VERBOSE) */ yyerror ("parse error"); } goto yyerrlab1; /*--------------------------------------------------. | yyerrlab1 -- error raised explicitly by an action | `--------------------------------------------------*/ yyerrlab1: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYABORT; YYDPRINTF ((stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1])); yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; /*-------------------------------------------------------------------. | yyerrdefault -- current state does not do anything special for the | | error token. | `-------------------------------------------------------------------*/ yyerrdefault: #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ /* If its default is to accept any token, ok. Otherwise pop it. */ yyn = yydefact[yystate]; if (yyn) goto yydefault; #endif /*---------------------------------------------------------------. | yyerrpop -- pop the current state because it cannot handle the | | error token | `---------------------------------------------------------------*/ yyerrpop: if (yyssp == yyss) YYABORT; yyvsp--; yystate = *--yyssp; #if YYLSP_NEEDED yylsp--; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "Error: state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif /*--------------. | yyerrhandle. | `--------------*/ yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; YYDPRINTF ((stderr, "Shifting error token, ")); *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; /*---------------------------------------------. | yyoverflowab -- parser overflow comes here. | `---------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ yyreturn: #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif return yyresult; } #line 690 "grammar.y" int yyerror ( const char * ) /* Called by yyparse on error */ { return 1; } /* may we automatically insert a semicolon ? */ bool automatic() { if ( yychar == '}' || yychar == 0 ) return true; else if ( QSLexer::curr()->prevTerminator() ) return true; return false; }