--- parser3/src/main/compile.tab.C 2003/04/03 12:25:33 1.81.2.13.2.25 +++ parser3/src/main/compile.tab.C 2003/07/24 11:36:33 1.85 @@ -1,122 +1,40 @@ -/* A Bison parser, made from compile.y, by GNU bison 1.75. */ -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. +/* A Bison parser, made from compile.y + by GNU Bison version 1.28 */ - 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. +#define YYBISON 1 /* Identify Bison output. */ - 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. */ +#define EON 257 +#define STRING 258 +#define BOGUS 259 +#define BAD_STRING_COMPARISON_OPERATOR 260 +#define BAD_HEX_LITERAL 261 +#define BAD_METHOD_DECL_START 262 +#define BAD_METHOD_PARAMETER_NAME_CHARACTER 263 +#define BAD_MATH_OPERATOR_CHARACTER 264 +#define LAND 265 +#define LOR 266 +#define LXOR 267 +#define NXOR 268 +#define NLE 269 +#define NGE 270 +#define NEQ 271 +#define NNE 272 +#define NSL 273 +#define NSR 274 +#define SLT 275 +#define SGT 276 +#define SLE 277 +#define SGE 278 +#define SEQ 279 +#define SNE 280 +#define DEF 281 +#define IN 282 +#define FEXISTS 283 +#define DEXISTS 284 +#define IS 285 +#define NUNARY 286 -/* 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. */ - -/* Written by Richard Stallman by simplifying the original so called - ``semantic'' parser. */ - -/* 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. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Pure parsers. */ -#define YYPURE 1 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - EON = 258, - STRING = 259, - BOGUS = 260, - BAD_STRING_COMPARISON_OPERATOR = 261, - BAD_HEX_LITERAL = 262, - BAD_METHOD_DECL_START = 263, - BAD_METHOD_PARAMETER_NAME_CHARACTER = 264, - BAD_MATH_OPERATOR_CHARACTER = 265, - LAND = 266, - LOR = 267, - LXOR = 268, - NXOR = 269, - NLE = 270, - NGE = 271, - NEQ = 272, - NNE = 273, - NSL = 274, - NSR = 275, - SLT = 276, - SGT = 277, - SLE = 278, - SGE = 279, - SEQ = 280, - SNE = 281, - DEF = 282, - IN = 283, - FEXISTS = 284, - DEXISTS = 285, - IS = 286, - NUNARY = 287 - }; -#endif -#define EON 258 -#define STRING 259 -#define BOGUS 260 -#define BAD_STRING_COMPARISON_OPERATOR 261 -#define BAD_HEX_LITERAL 262 -#define BAD_METHOD_DECL_START 263 -#define BAD_METHOD_PARAMETER_NAME_CHARACTER 264 -#define BAD_MATH_OPERATOR_CHARACTER 265 -#define LAND 266 -#define LOR 267 -#define LXOR 268 -#define NXOR 269 -#define NLE 270 -#define NGE 271 -#define NEQ 272 -#define NNE 273 -#define NSL 274 -#define NSR 275 -#define SLT 276 -#define SGT 277 -#define SLE 278 -#define SGE 279 -#define SEQ 280 -#define SNE 281 -#define DEF 282 -#define IN 283 -#define FEXISTS 284 -#define DEXISTS 285 -#define IS 286 -#define NUNARY 287 - - - - -/* Copy the first part of user declarations. */ #line 1 "compile.y" /** @file @@ -125,7 +43,7 @@ Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan (http://design.ru/paf) - $Id: compile.tab.C,v 1.81.2.13.2.25 2003/04/03 12:25:33 paf Exp $ + $Id: compile.tab.C,v 1.85 2003/07/24 11:36:33 paf Exp $ */ /** @@ -161,7 +79,6 @@ // defines #define USE_CONTROL_METHOD_NAME "USE" -#define TAB_SIZE 8 // forwards @@ -176,863 +93,623 @@ static int yylex(YYSTYPE* lvalp, void* p #undef POOL #define POOL (*PC.pool) #ifndef DOXYGEN - - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 +#ifndef YYSTYPE +#define YYSTYPE int #endif +#include -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 +#ifndef __cplusplus +#ifndef __STDC__ +#define const #endif - -#ifndef YYSTYPE -typedef int 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 - -/* Copy the second part of user declarations. */ - - -/* Line 213 of /usr/local/share/bison/yacc.c. */ -#line 217 "compile.tab.C" - -#if ! defined (yyoverflow) || 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) || 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; - }; - -/* 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. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) - -/* 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 (__STDC__) || defined (__cplusplus) - typedef signed char yysigned_char; -#else - typedef short yysigned_char; -#endif -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 51 -#define YYLAST 483 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 60 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 80 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 161 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 252 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 287 - -#define YYTRANSLATE(X) \ - ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const unsigned char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 46, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 44, 58, 2, 50, 41, 35, 59, - 54, 55, 38, 36, 2, 37, 53, 39, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 57, 49, - 32, 2, 33, 2, 45, 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, 47, 40, 48, 56, 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, 51, 34, 52, 43, 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, 2, 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, 42 -}; -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const unsigned short yyprhs[] = -{ - 0, 0, 3, 5, 7, 9, 12, 14, 16, 18, - 23, 25, 27, 29, 32, 35, 37, 39, 47, 49, - 51, 55, 57, 59, 61, 65, 67, 69, 71, 73, - 75, 78, 80, 82, 84, 86, 88, 90, 93, 96, - 98, 102, 104, 106, 108, 111, 113, 116, 120, 122, - 124, 126, 128, 131, 134, 136, 138, 140, 144, 148, - 152, 154, 156, 158, 160, 162, 164, 167, 169, 170, - 171, 178, 180, 182, 185, 187, 189, 191, 195, 199, - 203, 205, 209, 211, 215, 217, 221, 223, 225, 227, - 229, 231, 233, 235, 237, 240, 242, 245, 248, 250, - 252, 255, 257, 259, 261, 263, 266, 269, 273, 275, - 277, 280, 283, 285, 287, 290, 293, 295, 297, 299, - 301, 305, 309, 313, 316, 319, 322, 325, 328, 331, - 334, 337, 341, 345, 349, 353, 357, 361, 365, 369, - 373, 377, 381, 385, 389, 393, 397, 401, 405, 409, - 413, 417, 421, 425, 429, 433, 437, 441, 445, 447, - 449, 450 +#define YYFINAL 252 +#define YYFLAG -32768 +#define YYNTBASE 60 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 139) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 46, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 44, 58, 2, 50, 41, 35, 59, 54, + 55, 38, 36, 2, 37, 53, 39, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 57, 49, 32, + 2, 33, 2, 45, 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, + 47, 40, 48, 56, 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, 51, 34, 52, 43, 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, 42 }; -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const short yyrhs[] = -{ - 61, 0, -1, 63, -1, 62, -1, 64, -1, 62, - 64, -1, 76, -1, 65, -1, 70, -1, 45, 4, - 46, 66, -1, 139, -1, 67, -1, 68, -1, 67, - 68, -1, 69, 46, -1, 139, -1, 4, -1, 45, - 4, 72, 71, 75, 46, 76, -1, 139, -1, 72, - -1, 47, 73, 48, -1, 139, -1, 74, -1, 4, - -1, 74, 49, 4, -1, 139, -1, 4, -1, 139, - -1, 77, -1, 78, -1, 77, 78, -1, 137, -1, - 79, -1, 80, -1, 88, -1, 101, -1, 81, -1, - 50, 82, -1, 84, 3, -1, 83, -1, 51, 84, - 52, -1, 85, -1, 86, -1, 87, -1, 131, 87, - -1, 123, -1, 120, 123, -1, 50, 89, 93, -1, - 90, -1, 91, -1, 92, -1, 119, -1, 53, 119, - -1, 131, 119, -1, 94, -1, 95, -1, 96, -1, - 47, 97, 48, -1, 54, 134, 55, -1, 51, 76, - 52, -1, 138, -1, 4, -1, 98, -1, 99, -1, - 100, -1, 79, -1, 78, 77, -1, 102, -1, -1, - -1, 56, 103, 105, 104, 106, 3, -1, 84, -1, - 107, -1, 106, 107, -1, 108, -1, 109, -1, 110, - -1, 47, 111, 48, -1, 54, 112, 55, -1, 51, - 113, 52, -1, 114, -1, 111, 49, 114, -1, 115, - -1, 112, 49, 115, -1, 116, -1, 113, 49, 116, - -1, 117, -1, 118, -1, 76, -1, 138, -1, 4, - -1, 98, -1, 134, -1, 124, -1, 120, 124, -1, - 121, -1, 120, 121, -1, 122, 53, -1, 124, -1, - 124, -1, 4, 5, -1, 4, -1, 125, -1, 126, - -1, 127, -1, 50, 128, -1, 4, 129, -1, 47, - 77, 48, -1, 4, -1, 130, -1, 129, 130, -1, - 50, 128, -1, 132, -1, 133, -1, 4, 57, -1, - 132, 57, -1, 135, -1, 4, -1, 81, -1, 102, - -1, 58, 136, 58, -1, 59, 136, 59, -1, 54, - 135, 55, -1, 37, 135, -1, 36, 135, -1, 43, - 135, -1, 44, 135, -1, 27, 135, -1, 28, 135, - -1, 29, 135, -1, 30, 135, -1, 135, 37, 135, - -1, 135, 36, 135, -1, 135, 38, 135, -1, 135, - 39, 135, -1, 135, 41, 135, -1, 135, 40, 135, - -1, 135, 19, 135, -1, 135, 20, 135, -1, 135, - 35, 135, -1, 135, 34, 135, -1, 135, 14, 135, - -1, 135, 11, 135, -1, 135, 12, 135, -1, 135, - 13, 135, -1, 135, 32, 135, -1, 135, 33, 135, - -1, 135, 15, 135, -1, 135, 16, 135, -1, 135, - 17, 135, -1, 135, 18, 135, -1, 135, 21, 135, - -1, 135, 22, 135, -1, 135, 23, 135, -1, 135, - 24, 135, -1, 135, 25, 135, -1, 135, 26, 135, - -1, 135, 31, 135, -1, 76, -1, 4, -1, -1, - -1 +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 6, 9, 11, 13, 15, 20, 22, + 24, 26, 29, 32, 34, 36, 44, 46, 48, 52, + 54, 56, 58, 62, 64, 66, 68, 70, 72, 75, + 77, 79, 81, 83, 85, 87, 90, 93, 95, 99, + 101, 103, 105, 108, 110, 113, 117, 119, 121, 123, + 125, 128, 131, 133, 135, 137, 141, 145, 149, 151, + 153, 155, 157, 159, 161, 164, 166, 167, 168, 175, + 177, 179, 182, 184, 186, 188, 192, 196, 200, 202, + 206, 208, 212, 214, 218, 220, 222, 224, 226, 228, + 230, 232, 234, 237, 239, 242, 245, 247, 249, 252, + 254, 256, 258, 260, 263, 266, 270, 272, 274, 277, + 280, 282, 284, 287, 290, 292, 294, 296, 298, 302, + 306, 310, 313, 316, 319, 322, 325, 328, 331, 334, + 338, 342, 346, 350, 354, 358, 362, 366, 370, 374, + 378, 382, 386, 390, 394, 398, 402, 406, 410, 414, + 418, 422, 426, 430, 434, 438, 442, 444, 446, 447 }; -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const unsigned short yyrline[] = -{ - 0, 122, 122, 130, 132, 132, 133, 135, 135, 137, - 209, 209, 210, 210, 211, 212, 212, 214, 243, 243, - 244, 245, 245, 246, 246, 248, 248, 252, 252, 254, - 254, 255, 255, 256, 256, 256, 260, 267, 268, 268, - 269, 270, 272, 273, 295, 296, 296, 300, 304, 306, - 307, 308, 325, 330, 332, 334, 335, 337, 343, 351, - 357, 359, 360, 362, 368, 369, 369, 373, 379, 382, - 379, 398, 400, 400, 401, 403, 404, 406, 407, 408, - 409, 411, 413, 415, 417, 419, 421, 425, 429, 433, - 435, 436, 438, 447, 447, 449, 449, 450, 451, 459, - 464, 466, 468, 469, 470, 472, 476, 485, 491, 496, - 496, 497, 502, 504, 506, 518, 530, 535, 537, 538, - 539, 540, 541, 543, 544, 545, 546, 547, 548, 549, - 550, 552, 553, 554, 555, 556, 557, 558, 559, 560, - 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, - 571, 572, 573, 574, 575, 576, 577, 578, 581, 590, - 595, 596 +static const short yyrhs[] = { 62, + 0, 61, 0, 63, 0, 61, 63, 0, 75, 0, + 64, 0, 69, 0, 45, 4, 46, 65, 0, 138, + 0, 66, 0, 67, 0, 66, 67, 0, 68, 46, + 0, 138, 0, 4, 0, 45, 4, 71, 70, 74, + 46, 75, 0, 138, 0, 71, 0, 47, 72, 48, + 0, 138, 0, 73, 0, 4, 0, 73, 49, 4, + 0, 138, 0, 4, 0, 138, 0, 76, 0, 77, + 0, 76, 77, 0, 136, 0, 78, 0, 79, 0, + 87, 0, 100, 0, 80, 0, 50, 81, 0, 83, + 3, 0, 82, 0, 51, 83, 52, 0, 84, 0, + 85, 0, 86, 0, 130, 86, 0, 122, 0, 119, + 122, 0, 50, 88, 92, 0, 89, 0, 90, 0, + 91, 0, 118, 0, 53, 118, 0, 130, 118, 0, + 93, 0, 94, 0, 95, 0, 47, 96, 48, 0, + 54, 133, 55, 0, 51, 75, 52, 0, 137, 0, + 4, 0, 97, 0, 98, 0, 99, 0, 78, 0, + 77, 76, 0, 101, 0, 0, 0, 56, 102, 104, + 103, 105, 3, 0, 83, 0, 106, 0, 105, 106, + 0, 107, 0, 108, 0, 109, 0, 47, 110, 48, + 0, 54, 111, 55, 0, 51, 112, 52, 0, 113, + 0, 110, 49, 113, 0, 114, 0, 111, 49, 114, + 0, 115, 0, 112, 49, 115, 0, 116, 0, 117, + 0, 75, 0, 137, 0, 4, 0, 97, 0, 133, + 0, 123, 0, 119, 123, 0, 120, 0, 119, 120, + 0, 121, 53, 0, 123, 0, 123, 0, 4, 5, + 0, 4, 0, 124, 0, 125, 0, 126, 0, 50, + 127, 0, 4, 128, 0, 47, 76, 48, 0, 4, + 0, 129, 0, 128, 129, 0, 50, 127, 0, 131, + 0, 132, 0, 4, 57, 0, 131, 57, 0, 134, + 0, 4, 0, 80, 0, 101, 0, 58, 135, 58, + 0, 59, 135, 59, 0, 54, 134, 55, 0, 37, + 134, 0, 36, 134, 0, 43, 134, 0, 44, 134, + 0, 27, 134, 0, 28, 134, 0, 29, 134, 0, + 30, 134, 0, 134, 37, 134, 0, 134, 36, 134, + 0, 134, 38, 134, 0, 134, 39, 134, 0, 134, + 41, 134, 0, 134, 40, 134, 0, 134, 19, 134, + 0, 134, 20, 134, 0, 134, 35, 134, 0, 134, + 34, 134, 0, 134, 14, 134, 0, 134, 11, 134, + 0, 134, 12, 134, 0, 134, 13, 134, 0, 134, + 32, 134, 0, 134, 33, 134, 0, 134, 15, 134, + 0, 134, 16, 134, 0, 134, 17, 134, 0, 134, + 18, 134, 0, 134, 21, 134, 0, 134, 22, 134, + 0, 134, 23, 134, 0, 134, 24, 134, 0, 134, + 25, 134, 0, 134, 26, 134, 0, 134, 31, 134, + 0, 75, 0, 4, 0, 0, 0 }; + #endif -#if YYDEBUG || YYERROR_VERBOSE -/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "EON", "STRING", "BOGUS", - "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL", - "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER", - "BAD_MATH_OPERATOR_CHARACTER", "\"&&\"", "\"||\"", "\"!||\"", "\"!|\"", - "\"<=\"", "\">=\"", "\"==\"", "\"!=\"", "\"<<\"", "\">>\"", "\"lt\"", - "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"", "\"ne\"", "\"def\"", "\"in\"", - "\"-f\"", "\"-d\"", "\"is\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", - "'*'", "'/'", "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", - "'['", "']'", "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'", - "':'", "'\"'", "'''", "$accept", "all", "methods", "one_big_piece", - "method", "control_method", "maybe_control_strings", "control_strings", - "control_string", "maybe_string", "code_method", - "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings", - "strings", "maybe_comment", "maybe_codes", "codes", "code", "action", - "get", "get_value", "get_name_value", "name_in_curly_rdive", - "name_without_curly_rdive", "name_without_curly_rdive_read", - "name_without_curly_rdive_class", "name_without_curly_rdive_code", - "put", "name_expr_wdive", "name_expr_wdive_root", - "name_expr_wdive_write", "name_expr_wdive_class", "construct", - "construct_square", "construct_round", "construct_curly", - "any_constructor_code_value", "constructor_code_value", - "constructor_code", "codes__excluding_sole_str_literal", "call", - "call_value", "@1", "@2", "call_name", "store_params", "store_param", - "store_square_param", "store_round_param", "store_curly_param", - "store_code_param_parts", "store_expr_param_parts", - "store_curly_param_parts", "store_code_param_part", - "store_expr_param_part", "store_curly_param_part", "code_param_value", - "write_expr_value", "name_expr_dive_code", "name_path", "name_step", - "name_advance1", "name_advance2", "name_expr_value", - "name_expr_subvar_value", "name_expr_with_subvar_value", - "name_square_code_value", "subvar_ref_name_rdive", "subvar_get_writes", - "subvar__get_write", "class_prefix", "class_static_prefix", - "class_constructor_prefix", "expr_value", "expr", - "string_inside_quotes_value", "write_string", "void_value", "empty", 0 +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 121, 129, 131, 131, 132, 134, 134, 136, 208, 208, + 209, 209, 210, 211, 211, 213, 242, 242, 243, 244, + 244, 245, 245, 247, 247, 251, 251, 253, 253, 254, + 254, 255, 255, 255, 259, 266, 267, 267, 268, 269, + 271, 272, 294, 295, 295, 299, 303, 305, 306, 307, + 324, 329, 331, 333, 334, 336, 342, 350, 356, 358, + 359, 361, 367, 368, 368, 372, 378, 381, 384, 397, + 399, 399, 400, 402, 403, 405, 406, 407, 408, 410, + 412, 414, 416, 418, 420, 424, 428, 432, 434, 435, + 437, 446, 446, 448, 448, 449, 450, 458, 463, 465, + 467, 468, 469, 471, 475, 484, 490, 495, 495, 496, + 501, 503, 505, 517, 529, 534, 536, 537, 538, 539, + 540, 542, 543, 544, 545, 546, 547, 548, 549, 551, + 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, + 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, + 572, 573, 574, 575, 576, 577, 580, 589, 594, 595 }; #endif -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const unsigned short yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 60, 62, 124, 38, 43, 45, 42, 47, - 92, 37, 287, 126, 33, 64, 10, 91, 93, 59, - 36, 123, 125, 46, 40, 41, 94, 58, 34, 39 -}; -# endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const unsigned char yyr1[] = -{ - 0, 60, 61, 61, 62, 62, 63, 64, 64, 65, - 66, 66, 67, 67, 68, 69, 69, 70, 71, 71, - 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, - 77, 78, 78, 79, 79, 79, 80, 81, 82, 82, - 83, 84, 84, 85, 86, 87, 87, 88, 89, 89, - 89, 90, 91, 92, 93, 93, 93, 94, 95, 96, - 97, 97, 97, 98, 99, 100, 100, 101, 103, 104, - 102, 105, 106, 106, 107, 107, 107, 108, 109, 110, - 111, 111, 112, 112, 113, 113, 114, 115, 116, 117, - 117, 117, 118, 119, 119, 120, 120, 121, 122, 123, - 123, 124, 124, 124, 124, 125, 126, 127, 128, 129, - 129, 130, 131, 131, 132, 133, 134, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 135, 136, 137, - 138, 139 +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","EON","STRING", +"BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START", +"BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_MATH_OPERATOR_CHARACTER","\"&&\"", +"\"||\"","\"!||\"","\"!|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"<<\"","\">>\"", +"\"lt\"","\"gt\"","\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"", +"\"-d\"","\"is\"","'<'","'>'","'|'","'&'","'+'","'-'","'*'","'/'","'\\\\'","'%'", +"NUNARY","'~'","'!'","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'", +"'('","')'","'^'","':'","'\\\"'","'\\''","all","methods","one_big_piece","method", +"control_method","maybe_control_strings","control_strings","control_string", +"maybe_string","code_method","maybe_bracketed_strings","bracketed_maybe_strings", +"maybe_strings","strings","maybe_comment","maybe_codes","codes","code","action", +"get","get_value","get_name_value","name_in_curly_rdive","name_without_curly_rdive", +"name_without_curly_rdive_read","name_without_curly_rdive_class","name_without_curly_rdive_code", +"put","name_expr_wdive","name_expr_wdive_root","name_expr_wdive_write","name_expr_wdive_class", +"construct","construct_square","construct_round","construct_curly","any_constructor_code_value", +"constructor_code_value","constructor_code","codes__excluding_sole_str_literal", +"call","call_value","@1","@2","call_name","store_params","store_param","store_square_param", +"store_round_param","store_curly_param","store_code_param_parts","store_expr_param_parts", +"store_curly_param_parts","store_code_param_part","store_expr_param_part","store_curly_param_part", +"code_param_value","write_expr_value","name_expr_dive_code","name_path","name_step", +"name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value", +"name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write", +"class_prefix","class_static_prefix","class_constructor_prefix","expr_value", +"expr","string_inside_quotes_value","write_string","void_value","empty", NULL }; +#endif -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const unsigned char yyr2[] = -{ - 0, 2, 1, 1, 1, 2, 1, 1, 1, 4, - 1, 1, 1, 2, 2, 1, 1, 7, 1, 1, - 3, 1, 1, 1, 3, 1, 1, 1, 1, 1, - 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, - 3, 1, 1, 1, 2, 1, 2, 3, 1, 1, - 1, 1, 2, 2, 1, 1, 1, 3, 3, 3, - 1, 1, 1, 1, 1, 1, 2, 1, 0, 0, - 6, 1, 1, 2, 1, 1, 1, 3, 3, 3, - 1, 3, 1, 3, 1, 3, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 2, 2, 1, 1, - 2, 1, 1, 1, 1, 2, 2, 3, 1, 1, - 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, - 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, - 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, - 0, 0 +static const short yyr1[] = { 0, + 60, 60, 61, 61, 62, 63, 63, 64, 65, 65, + 66, 66, 67, 68, 68, 69, 70, 70, 71, 72, + 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, + 77, 78, 78, 78, 79, 80, 81, 81, 82, 83, + 83, 84, 85, 86, 86, 87, 88, 88, 88, 89, + 90, 91, 92, 92, 92, 93, 94, 95, 96, 96, + 96, 97, 98, 99, 99, 100, 102, 103, 101, 104, + 105, 105, 106, 106, 106, 107, 108, 109, 110, 110, + 111, 111, 112, 112, 113, 114, 115, 116, 116, 116, + 117, 118, 118, 119, 119, 120, 121, 122, 122, 123, + 123, 123, 123, 124, 125, 126, 127, 128, 128, 129, + 130, 130, 131, 132, 133, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 134, 134, 134, 134, 134, 135, 136, 137, 138 }; -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const unsigned char yydefact[] = -{ - 161, 159, 0, 0, 68, 0, 3, 2, 4, 7, - 8, 6, 28, 29, 32, 33, 36, 34, 35, 67, - 31, 27, 0, 101, 0, 0, 0, 0, 37, 39, - 0, 41, 42, 43, 0, 48, 49, 50, 51, 0, - 95, 0, 45, 93, 102, 103, 104, 0, 112, 113, - 0, 1, 5, 30, 161, 161, 161, 100, 0, 114, - 106, 109, 0, 108, 105, 0, 0, 99, 0, 101, - 52, 0, 93, 38, 160, 161, 0, 47, 54, 55, - 56, 101, 96, 46, 94, 97, 44, 53, 115, 71, - 69, 16, 9, 11, 12, 0, 10, 23, 0, 22, - 21, 161, 19, 18, 111, 110, 107, 40, 94, 159, - 0, 32, 0, 62, 63, 64, 60, 0, 117, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 161, - 161, 118, 119, 0, 116, 0, 13, 15, 14, 20, - 0, 26, 0, 25, 66, 57, 59, 127, 128, 129, - 130, 124, 123, 125, 126, 0, 158, 0, 0, 58, - 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, 0, 160, 161, 0, - 0, 72, 74, 75, 76, 24, 161, 122, 120, 121, - 142, 143, 144, 141, 147, 148, 149, 150, 137, 138, - 151, 152, 153, 154, 155, 156, 157, 145, 146, 140, - 139, 132, 131, 133, 134, 136, 135, 159, 91, 0, - 80, 86, 89, 88, 0, 84, 0, 82, 87, 92, - 70, 73, 17, 77, 160, 161, 79, 0, 78, 81, - 85, 83 +static const short yyr2[] = { 0, + 1, 1, 1, 2, 1, 1, 1, 4, 1, 1, + 1, 2, 2, 1, 1, 7, 1, 1, 3, 1, + 1, 1, 3, 1, 1, 1, 1, 1, 2, 1, + 1, 1, 1, 1, 1, 2, 2, 1, 3, 1, + 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, + 2, 2, 1, 1, 1, 3, 3, 3, 1, 1, + 1, 1, 1, 1, 2, 1, 0, 0, 6, 1, + 1, 2, 1, 1, 1, 3, 3, 3, 1, 3, + 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 1, 2, 2, 1, 1, 2, 1, + 1, 1, 1, 2, 2, 3, 1, 1, 2, 2, + 1, 1, 2, 2, 1, 1, 1, 1, 3, 3, + 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 1, 1, 0, 0 }; -/* YYDEFGOTO[NTERM-NUM]. */ -static const short yydefgoto[] = -{ - -1, 5, 6, 7, 8, 9, 92, 93, 94, 95, - 10, 101, 56, 98, 99, 142, 156, 12, 13, 14, - 15, 131, 28, 29, 30, 31, 32, 33, 17, 34, - 35, 36, 37, 77, 78, 79, 80, 112, 228, 114, - 115, 18, 132, 50, 135, 90, 190, 191, 192, 193, - 194, 229, 236, 234, 230, 237, 235, 231, 238, 38, - 66, 40, 41, 42, 67, 44, 45, 46, 64, 60, - 61, 68, 48, 49, 239, 134, 157, 20, 232, 21 +static const short yydefact[] = { 160, + 158, 0, 0, 67, 2, 1, 3, 6, 7, 5, + 27, 28, 31, 32, 35, 33, 34, 66, 30, 26, + 0, 100, 0, 0, 0, 0, 36, 38, 0, 40, + 41, 42, 0, 47, 48, 49, 50, 0, 94, 0, + 44, 92, 101, 102, 103, 0, 111, 112, 0, 4, + 29, 160, 160, 160, 99, 0, 113, 105, 108, 0, + 107, 104, 0, 0, 98, 0, 100, 51, 0, 92, + 37, 159, 160, 0, 46, 53, 54, 55, 100, 95, + 45, 93, 96, 43, 52, 114, 70, 68, 15, 8, + 10, 11, 0, 9, 22, 0, 21, 20, 160, 18, + 17, 110, 109, 106, 39, 93, 158, 0, 31, 0, + 61, 62, 63, 59, 0, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 160, 160, 117, 118, + 0, 115, 0, 12, 14, 13, 19, 0, 25, 0, + 24, 65, 56, 58, 126, 127, 128, 129, 123, 122, + 124, 125, 0, 157, 0, 0, 57, 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, 0, 159, 160, 0, 0, 71, 73, + 74, 75, 23, 160, 121, 119, 120, 141, 142, 143, + 140, 146, 147, 148, 149, 136, 137, 150, 151, 152, + 153, 154, 155, 156, 144, 145, 139, 138, 131, 130, + 132, 133, 135, 134, 158, 90, 0, 79, 85, 88, + 87, 0, 83, 0, 81, 86, 91, 69, 72, 16, + 76, 159, 160, 78, 0, 77, 80, 84, 82, 0, + 0, 0 }; -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -71 -static const short yypact[] = -{ - 4, -71, 11, 98, -71, 27, 5, -71, -71, -71, - -71, -71, 16, -71, -71, -71, -71, -71, -71, -71, - -71, -71, -15, 23, 16, 41, 6, 21, -71, -71, - 94, -71, -71, -71, 71, -71, -71, -71, -71, 48, - -71, 53, -71, 14, -71, -71, -71, 48, 66, -71, - 6, -71, -71, -71, 117, 122, 96, -71, 41, -71, - 97, -71, 9, -71, -71, 106, 48, 114, 48, 97, - -71, 21, 114, -71, 32, 16, 57, -71, -71, -71, - -71, 64, -71, -71, 14, -71, -71, -71, -71, -71, - -71, -71, -71, 12, -71, 123, 126, -71, 125, 121, - -71, 173, -71, -71, -71, -71, -71, -71, 114, 135, - 16, -9, 136, -71, -71, -71, -71, 133, -71, 57, - 57, 57, 57, 57, 57, 57, 57, 77, 57, 16, - 16, -71, -71, 131, 283, 124, -71, -71, -71, -71, - 188, -71, 147, -71, 16, -71, -71, 442, 442, 442, - 442, -71, -71, -71, -71, 238, -71, 137, 138, -71, - 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, - 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, - 57, 57, 57, 57, 57, 57, 57, 33, 16, 57, - 45, -71, -71, -71, -71, -71, 16, -71, -71, -71, - 373, 345, 314, 100, 401, 401, 414, 414, 116, 116, - 401, 401, 401, 401, 414, 414, 442, 401, 401, 246, - 427, 141, 141, -71, -71, -71, -71, -5, -71, 60, - -71, -71, -71, -71, -30, -71, -26, -71, -71, -71, - -71, -71, -71, -71, 33, 16, -71, 57, -71, -71, - -71, -71 +static const short yydefgoto[] = { 250, + 5, 6, 7, 8, 90, 91, 92, 93, 9, 99, + 54, 96, 97, 140, 154, 11, 12, 13, 14, 129, + 27, 28, 29, 30, 31, 32, 16, 33, 34, 35, + 36, 75, 76, 77, 78, 110, 226, 112, 113, 17, + 130, 49, 133, 88, 188, 189, 190, 191, 192, 227, + 234, 232, 228, 235, 233, 229, 236, 37, 64, 39, + 40, 41, 65, 43, 44, 45, 62, 58, 59, 66, + 47, 48, 237, 132, 155, 19, 230, 20 }; -/* YYPGOTO[NTERM-NUM]. */ -static const short yypgoto[] = -{ - -71, -71, -71, -71, 221, -71, -71, -71, 101, -71, - -71, -71, 172, -71, -71, -71, 3, -19, -11, -70, - -71, 0, -71, -71, -8, -71, -71, -38, -71, -71, - -71, -71, -71, -71, -71, -71, -71, -71, 155, -71, - -71, -71, 2, -71, -71, -71, -71, 42, -71, -71, - -71, -71, -71, -71, -14, -16, -10, -71, -71, -6, - 43, -33, -71, -32, 8, -71, -71, -71, 176, -71, - 177, 233, -71, -71, 162, 40, 109, -71, 166, 49 +static const short yypact[] = { 13, +-32768, 24, 98,-32768, 36,-32768,-32768,-32768,-32768,-32768, + 14,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + -26, 39, 14, 44, 45, 100,-32768,-32768, 47,-32768, +-32768,-32768, 52,-32768,-32768,-32768,-32768, 118,-32768, 59, +-32768, 4,-32768,-32768,-32768, 118, -3,-32768, 45,-32768, +-32768, 101, 113, 71,-32768, 44,-32768, 70,-32768, 32, +-32768,-32768, 73, 118, 83, 118, 70,-32768, 100, 83, +-32768, 27, 14, 57,-32768,-32768,-32768,-32768, 1,-32768, +-32768, 4,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 20,-32768, 78, 91,-32768, 90, 94,-32768, 135,-32768, +-32768,-32768,-32768,-32768,-32768, 83, 92, 14, -22, 106, +-32768,-32768,-32768,-32768, 115,-32768, 57, 57, 57, 57, + 57, 57, 57, 57, 105, 57, 14, 14,-32768,-32768, + 114, 281, 72,-32768,-32768,-32768,-32768, 142,-32768, 107, +-32768, 14,-32768,-32768, 440, 440, 440, 440,-32768,-32768, +-32768,-32768, 236,-32768, 112, 120,-32768, 57, 57, 57, + 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, + 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, + 57, 57, 57, 57, 41, 14, 57, 5,-32768,-32768, +-32768,-32768,-32768, 14,-32768,-32768,-32768, 371, 343, 312, + 244, 399, 399, 412, 412, 136, 136, 399, 399, 399, + 399, 412, 412, 440, 399, 399, 447, 453, 93, 93, +-32768,-32768,-32768,-32768, -11,-32768, 19,-32768,-32768,-32768, +-32768, -10,-32768, -33,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 41, 14,-32768, 57,-32768,-32768,-32768,-32768, 180, + 181,-32768 }; -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, parse error. */ -#define YYTABLE_NINF -162 -static const short yytable[] = -{ - 16, 53, 19, 11, 111, 62, 82, 83, 1, 86, - 23, 43, 16, 1, 19, 22, 91, -99, 65, 245, - 1, 70, 246, 247, 16, 69, 19, 51, 57, 248, - 86, 54, 55, 82, 83, 72, 109, 227, 82, -65, - -65, 87, 89, -90, -90, 63, 39, 84, 240, 2, - 2, 53, 81, 24, 3, 43, 25, 106, -161, 3, - 4, 118, 16, 110, 19, 4, 3, -98, 24, 57, - 71, 25, 4, 58, 16, 16, 19, 19, 117, 108, - 59, 23, 3, 3, 119, 120, 121, 122, 4, 4, - 39, 144, 187, 123, 124, 24, 188, 73, 25, 189, - 125, 126, 23, 96, 100, 103, 85, 127, 243, 244, - 16, 128, 19, 4, 58, 129, 130, 111, 74, 168, - 169, 91, 75, 88, 24, 76, 97, 25, 26, 16, - 16, 19, 19, 53, 179, 180, 181, 182, 183, 184, - 185, 186, 137, 55, 16, 24, 19, 58, 25, 26, - 143, 27, 181, 182, 183, 184, 185, 186, 107, 147, - 148, 149, 150, 151, 152, 153, 154, -98, 155, 138, - 140, 187, -15, 139, 111, 188, 110, 141, 189, 183, - 184, 185, 186, -61, 145, 146, 159, 16, 16, 19, - 19, 233, 195, 196, 136, 198, 16, 199, 19, 242, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 52, 102, 113, - 249, 251, 241, 110, 104, 250, 47, 105, 133, 158, - 116, 0, 0, 0, 16, 16, 19, 19, 233, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 168, 169, 0, 0, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 0, 180, 181, 182, 183, 184, 185, 186, 0, 0, - 0, 0, 0, 197, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 0, 0, 0, 0, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 160, 161, 0, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 0, 0, 0, 0, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 160, 0, 0, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 0, 0, 0, 0, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 0, 0, 0, 0, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 163, 0, 0, 166, 167, - 168, 169, 0, 0, 0, 0, 174, 175, 163, 0, - 0, 0, 176, 168, 169, 179, 180, 181, 182, 183, - 184, 185, 186, 0, 0, 176, 168, 169, 179, 180, - 181, 182, 183, 184, 185, 186, 163, 0, 0, 0, - 0, 168, 169, 181, 182, 183, 184, 185, 186, 0, - 0, 0, 0, 0, 0, 0, 179, 180, 181, 182, - 183, 184, 185, 186 +static const short yypgoto[] = {-32768, +-32768,-32768, 177,-32768,-32768,-32768, 99,-32768,-32768,-32768, + 129,-32768,-32768,-32768, 3, -18, -7, -71,-32768, 0, +-32768,-32768, -6,-32768,-32768, -37,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 119,-32768,-32768,-32768, + 2,-32768,-32768,-32768,-32768, -4,-32768,-32768,-32768,-32768, +-32768,-32768, -50, -52, -48,-32768,-32768, -16, 95, -23, +-32768, -24, 9,-32768,-32768,-32768, 169,-32768, 168, 224, +-32768,-32768, 154, 40, 102,-32768, 157, -20 }; -static const short yycheck[] = -{ - 0, 12, 0, 0, 74, 24, 39, 39, 4, 47, - 4, 3, 12, 4, 12, 4, 4, 3, 26, 49, - 4, 27, 52, 49, 24, 4, 24, 0, 5, 55, - 68, 46, 47, 66, 66, 27, 4, 4, 71, 48, - 49, 47, 50, 48, 49, 4, 3, 39, 3, 45, - 45, 62, 4, 47, 50, 47, 50, 48, 46, 50, - 56, 4, 62, 74, 62, 56, 50, 53, 47, 5, - 27, 50, 56, 50, 74, 75, 74, 75, 75, 71, - 57, 4, 50, 50, 27, 28, 29, 30, 56, 56, - 47, 110, 47, 36, 37, 47, 51, 3, 50, 54, - 43, 44, 4, 54, 55, 56, 53, 50, 48, 49, - 110, 54, 110, 56, 50, 58, 59, 187, 47, 19, - 20, 4, 51, 57, 47, 54, 4, 50, 51, 129, - 130, 129, 130, 144, 34, 35, 36, 37, 38, 39, - 40, 41, 93, 47, 144, 47, 144, 50, 50, 51, - 101, 53, 36, 37, 38, 39, 40, 41, 52, 119, - 120, 121, 122, 123, 124, 125, 126, 53, 128, 46, - 49, 47, 46, 48, 244, 51, 187, 4, 54, 38, - 39, 40, 41, 48, 48, 52, 55, 187, 188, 187, - 188, 188, 4, 46, 93, 58, 196, 59, 196, 196, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 6, 56, 74, - 244, 247, 190, 244, 58, 245, 3, 60, 76, 130, - 74, -1, -1, -1, 244, 245, 244, 245, 245, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 19, 20, -1, -1, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - -1, 35, 36, 37, 38, 39, 40, 41, -1, -1, - -1, -1, -1, 55, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, -1, -1, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 11, 12, -1, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, -1, -1, -1, -1, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 11, -1, -1, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, -1, -1, -1, -1, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - -1, -1, -1, -1, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 14, -1, -1, 17, 18, - 19, 20, -1, -1, -1, -1, 25, 26, 14, -1, - -1, -1, 31, 19, 20, 34, 35, 36, 37, 38, - 39, 40, 41, -1, -1, 31, 19, 20, 34, 35, - 36, 37, 38, 39, 40, 41, 14, -1, -1, -1, - -1, 19, 20, 36, 37, 38, 39, 40, 41, -1, - -1, -1, -1, -1, -1, -1, 34, 35, 36, 37, - 38, 39, 40, 41 + +#define YYLAST 494 + + +static const short yytable[] = { 15, + 109, 18, 10, 51, 60, 55, -98, 238, 84, 68, + 15, 42, 18, 81, 80, 245, 1, 1, 63, 52, + 53, 246, 15, 89, 18, -64, -64, 21, 84, 85, + 107, 94, 98, 101, 70, 1, -89, -89, 243, 81, + 80, 244, 87, 55, 225, 80, 82, 61, 22, 71, + 56, 185, 51, 86, 42, 186, -97, 2, 187, 15, + 116, 18, 3, 3, 108, -160, 241, 242, 4, 4, + 135, 15, 15, 18, 18, 115, 3, 106, 141, 104, + 2, 3, 4, 117, 118, 119, 120, 4, 56, 142, + 3, 23, 121, 122, 24, 57, 4, 38, 72, 123, + 124, 22, 73, 67, 89, 74, 125, 15, 22, 18, + 126, 83, 4, 109, 127, 128, 95, 53, 185, 56, + 69, 79, 186, 136, 105, 187, 15, 15, 18, 18, + 181, 182, 183, 184, 51, -97, -14, 137, 139, -60, + 38, 15, 138, 18, 23, 193, 23, 24, 25, 24, + 26, 23, 194, 143, 24, 25, 145, 146, 147, 148, + 149, 150, 151, 152, 23, 153, 144, 24, 157, 196, + 109, 179, 180, 181, 182, 183, 184, 108, 197, 251, + 252, 50, 100, 239, 15, 15, 18, 18, 231, 134, + 111, 247, 249, 15, 248, 18, 240, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 102, 103, 46, 131, 114, 156, + 0, 0, 0, 0, 108, 0, 0, 0, 0, 0, + 0, 15, 15, 18, 18, 231, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 166, 167, 0, 0, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 177, 178, 179, + 180, 181, 182, 183, 184, 0, 0, 0, 0, 0, + 195, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 0, 0, 0, + 0, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 158, 159, 0, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 0, 0, + 0, 0, 174, 175, 176, 177, 178, 179, 180, 181, + 182, 183, 184, 158, 0, 0, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, + 0, 0, 0, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 0, 0, 0, + 0, 174, 175, 176, 177, 178, 179, 180, 181, 182, + 183, 184, 161, 0, 0, 164, 165, 166, 167, 0, + 0, 0, 0, 172, 173, 161, 0, 0, 0, 174, + 166, 167, 177, 178, 179, 180, 181, 182, 183, 184, + 0, 0, 174, 0, 0, 177, 178, 179, 180, 181, + 182, 183, 184, 161, 0, 0, 0, 0, 166, 167, + 0, 0, 0, 0, 0, 166, 167, 0, 0, 0, + 0, 166, 167, 177, 178, 179, 180, 181, 182, 183, + 184, 178, 179, 180, 181, 182, 183, 184, 179, 180, + 181, 182, 183, 184 }; -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const unsigned char yystos[] = -{ - 0, 4, 45, 50, 56, 61, 62, 63, 64, 65, - 70, 76, 77, 78, 79, 80, 81, 88, 101, 102, - 137, 139, 4, 4, 47, 50, 51, 53, 82, 83, - 84, 85, 86, 87, 89, 90, 91, 92, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 131, 132, 133, - 103, 0, 64, 78, 46, 47, 72, 5, 50, 57, - 129, 130, 77, 4, 128, 84, 120, 124, 131, 4, - 119, 120, 124, 3, 47, 51, 54, 93, 94, 95, - 96, 4, 121, 123, 124, 53, 87, 119, 57, 84, - 105, 4, 66, 67, 68, 69, 139, 4, 73, 74, - 139, 71, 72, 139, 128, 130, 48, 52, 124, 4, - 78, 79, 97, 98, 99, 100, 138, 76, 4, 27, - 28, 29, 30, 36, 37, 43, 44, 50, 54, 58, - 59, 81, 102, 134, 135, 104, 68, 139, 46, 48, - 49, 4, 75, 139, 77, 48, 52, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 76, 136, 136, 55, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 47, 51, 54, - 106, 107, 108, 109, 110, 4, 46, 55, 58, 59, - 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 4, 98, 111, - 114, 117, 138, 76, 113, 116, 112, 115, 118, 134, - 3, 107, 76, 48, 49, 49, 52, 49, 55, 114, - 116, 115 +static const short yycheck[] = { 0, + 72, 0, 0, 11, 23, 5, 3, 3, 46, 26, + 11, 3, 11, 38, 38, 49, 4, 4, 25, 46, + 47, 55, 23, 4, 23, 48, 49, 4, 66, 46, + 4, 52, 53, 54, 26, 4, 48, 49, 49, 64, + 64, 52, 49, 5, 4, 69, 38, 4, 4, 3, + 50, 47, 60, 57, 46, 51, 53, 45, 54, 60, + 4, 60, 50, 50, 72, 46, 48, 49, 56, 56, + 91, 72, 73, 72, 73, 73, 50, 69, 99, 48, + 45, 50, 56, 27, 28, 29, 30, 56, 50, 108, + 50, 47, 36, 37, 50, 57, 56, 3, 47, 43, + 44, 4, 51, 4, 4, 54, 50, 108, 4, 108, + 54, 53, 56, 185, 58, 59, 4, 47, 47, 50, + 26, 4, 51, 46, 52, 54, 127, 128, 127, 128, + 38, 39, 40, 41, 142, 53, 46, 48, 4, 48, + 46, 142, 49, 142, 47, 4, 47, 50, 51, 50, + 53, 47, 46, 48, 50, 51, 117, 118, 119, 120, + 121, 122, 123, 124, 47, 126, 52, 50, 55, 58, + 242, 36, 37, 38, 39, 40, 41, 185, 59, 0, + 0, 5, 54, 188, 185, 186, 185, 186, 186, 91, + 72, 242, 245, 194, 243, 194, 194, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 56, 58, 3, 74, 72, 128, + -1, -1, -1, -1, 242, -1, -1, -1, -1, -1, + -1, 242, 243, 242, 243, 243, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 19, 20, -1, -1, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 34, 35, 36, + 37, 38, 39, 40, 41, -1, -1, -1, -1, -1, + 55, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, -1, + -1, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 11, 12, -1, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, -1, -1, + -1, -1, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 11, -1, -1, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, -1, + -1, -1, -1, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, -1, -1, -1, + -1, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 14, -1, -1, 17, 18, 19, 20, -1, + -1, -1, -1, 25, 26, 14, -1, -1, -1, 31, + 19, 20, 34, 35, 36, 37, 38, 39, 40, 41, + -1, -1, 31, -1, -1, 34, 35, 36, 37, 38, + 39, 40, 41, 14, -1, -1, -1, -1, 19, 20, + -1, -1, -1, -1, -1, 19, 20, -1, -1, -1, + -1, 19, 20, 34, 35, 36, 37, 38, 39, 40, + 41, 35, 36, 37, 38, 39, 40, 41, 36, 37, + 38, 39, 40, 41 }; +#define YYPURE 1 -#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 +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 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. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc #endif +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 - #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab +#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. +/* 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) \ +#define YYBACKUP(token, value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ + { yychar = (token), yylval = (value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ - { \ - yyerror ("syntax error: cannot back up"); \ - YYERROR; \ - } \ + { 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). */ - -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.first_line = Rhs[1].first_line; \ - Current.first_column = Rhs[1].first_column; \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; +#ifndef YYPURE +#define YYLEX yylex() #endif -/* YYLEX -- calling `yylex' with the right arguments. */ - +#ifdef YYPURE +#ifdef YYLSP_NEEDED #ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) #else -# define YYLEX yylex (&yylval) +#define YYLEX yylex(&yylval, &yylloc) #endif - -/* 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) -# define YYDSYMPRINT(Args) \ -do { \ - if (yydebug) \ - yysymprint 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) -# define YYDSYMPRINT(Args) -#endif /* !YYDEBUG */ - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) #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 /* not YYLSP_NEEDED */ #endif -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif +/* If nonreentrant, generate the variables here */ - +#ifndef YYPURE -#if YYERROR_VERBOSE +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ -# 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; +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif - while (*yys++ != '\0') - continue; +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ - return yys - yystr - 1; -} -# endif -# endif +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#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; +/* YYINITDEPTH indicates the initial size of the parser's stacks */ - while ((*yyd++ = *yys++) != '\0') - continue; +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif - return yyd - 1; -} -# endif -# endif +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ -#endif /* !YYERROR_VERBOSE */ +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus -#if YYDEBUG -/*-----------------------------. -| Print this symbol on YYOUT. | -`-----------------------------*/ - +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ static void -#if defined (__STDC__) || defined (__cplusplus) -yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) -#else -yysymprint (yyout, yytype, yyvalue) - FILE* yyout; - int yytype; - YYSTYPE yyvalue; -#endif +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; { - /* Pacify ``unused variable'' warnings. */ - (void) yyvalue; - - if (yytype < YYNTOKENS) - { - YYFPRINTF (yyout, "token %s (", yytname[yytype]); -# ifdef YYPRINT - YYPRINT (yyout, yytoknum[yytype], yyvalue); -# endif - } - else - YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + register char *f = from; + register char *t = to; + register int i = count; - switch (yytype) - { - default: - break; - } - YYFPRINTF (yyout, ")"); + while (i-- > 0) + *t++ = *f++; } -#endif /* YYDEBUG. */ - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ +#else /* __cplusplus */ +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ static void -#if defined (__STDC__) || defined (__cplusplus) -yydestruct (int yytype, YYSTYPE yyvalue) -#else -yydestruct (yytype, yyvalue) - int yytype; - YYSTYPE yyvalue; -#endif +__yy_memcpy (char *to, char *from, unsigned int count) { - /* Pacify ``unused variable'' warnings. */ - (void) yyvalue; + register char *t = to; + register char *f = from; + register int i = count; - switch (yytype) - { - default: - break; - } + while (i-- > 0) + *t++ = *f++; } +#endif +#endif +#line 217 "/usr/share/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 *. @@ -1041,85 +718,76 @@ yydestruct (yytype, yyvalue) 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 */ +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ -# ifdef YYPARSE_PARAM +#ifdef YYPARSE_PARAM int yyparse (void *); -# else +#else int yyparse (void); -# endif #endif - - - +#endif int -yyparse (YYPARSE_PARAM_ARG) +yyparse(YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL { - /* The lookahead symbol. */ -int yychar; - -/* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; - -/* Number of parse errors so far. */ -int yynerrs; - 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; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else #define YYPOPSTACK (yyvsp--, yyssp--) +#endif - YYSIZE_T yystacksize = YYINITDEPTH; + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ - /* When reducing, the number of symbols on the RHS of the reduced - rule. */ int yylen; - YYDPRINTF ((stderr, "Starting parse\n")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif yystate = 0; yyerrstatus = 0; @@ -1131,96 +799,110 @@ int yynerrs; so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss; + yyssp = yyss - 1; yyvsp = yyvs; +#ifdef 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++; +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: - yysetstate: - *yyssp = yystate; + *++yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { + /* 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; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + int size = 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. 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), - - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* 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, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif #else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyoverflowlab; -# else /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) - goto yyoverflowlab; + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } 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); - -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif #endif /* no yyoverflow */ - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif if (yyssp >= yyss + yystacksize - 1) YYABORT; } - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: + yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ @@ -1229,7 +911,7 @@ yybackup: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) + if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ @@ -1239,131 +921,138 @@ yybackup: if (yychar == YYEMPTY) { - YYDPRINTF ((stderr, "Reading a token: ")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with. */ + /* Convert token to internal form (in yychar1) for indexing tables with */ - if (yychar <= 0) /* This means end of input. */ + if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more. */ + yychar = YYEOF; /* Don't call YYLEX any more */ - YYDPRINTF ((stderr, "Now at end of input.\n")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif } else { - yychar1 = YYTRANSLATE (yychar); + yychar1 = YYTRANSLATE(yychar); - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - YYDPRINTF ((stderr, "Next token is ")); - YYDSYMPRINT ((stderr, yychar1, yylval)); - YYDPRINTF ((stderr, "\n")); +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (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 + fprintf (stderr, ")\n"); + } +#endif } - /* If the proper action on seeing token YYCHAR1 is to reduce or to - detect an error, take that action. */ yyn += yychar1; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; + yyn = yytable[yyn]; - if (yyn <= 0) + + /* 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 == 0 || yyn == YYTABLE_NINF) + 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])); + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; + /* 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. | -`-----------------------------------------------------------*/ +/* Do the default action for the current state. */ yydefault: + yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; - goto yyreduce; - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ +/* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: - /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - 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 YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ +#if YYDEBUG != 0 if (yydebug) { - int yyi; + int i; - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn - 1, yyrline[yyn]); + fprintf (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]]); + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif - switch (yyn) - { - case 2: -#line 123 "compile.y" - { + + + switch (yyn) { + +case 1: +#line 122 "compile.y" +{ Method& method=*new Method(Method::CT_ANY, 0, 0, /*min, max numbered_params_count*/ 0/*param_names*/, 0/*local_names*/, yyvsp[0]/*parser_code*/, 0/*native_code*/); PC.cclass->add_method(PC.alias_method(main_method_name), method); -} - break; - - case 9: -#line 138 "compile.y" - { +; + break;} +case 8: +#line 137 "compile.y" +{ const String& command=*LA2S(*yyvsp[-2]); YYSTYPE strings_code=yyvsp[0]; - if(strings_code->count()<1*2) { + if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) { strcpy(PC.error, "@"); strcat(PC.error, command.cstr()); strcat(PC.error, " is empty"); @@ -1376,7 +1065,7 @@ yyreduce: strcat(PC.error, "'"); YYERROR; } - if(strings_code->count()==1*2) { + if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { // new class' name const String& name=*LA2S(*strings_code); // creating the class @@ -1386,11 +1075,11 @@ yyreduce: // append to request's classes PC.request.classes().put(name, cclass); } else { - strcpy(PC.error, "@"CLASS_NAME" must contain sole name"); + strcpy(PC.error, "@"CLASS_NAME" must contain only one line with class name (contains more then one)"); YYERROR; } } else if(command==USE_CONTROL_METHOD_NAME) { - for(size_t i=0; icount(); i+=2) + for(size_t i=0; icount(); i+=OPERATIONS_PER_OPVALUE) PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i)); } else if(command==BASE_NAME) { if(PC.cclass->base_class()) { // already changed from default? @@ -1399,7 +1088,7 @@ yyreduce: strcat(PC.error, "'"); YYERROR; } - if(strings_code->count()==1*2) { + if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { const String& base_name=*LA2S(*strings_code); if(Value* base_class_value=PC.request.classes().get(base_name)) { // @CLASS == @BASE sanity check @@ -1430,24 +1119,22 @@ yyreduce: "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'"); YYERROR; } -} - break; - - case 13: -#line 210 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 17: -#line 215 "compile.y" - { +; + break;} +case 12: +#line 209 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 16: +#line 214 "compile.y" +{ const String& name=*LA2S(*yyvsp[-5]); YYSTYPE params_names_code=yyvsp[-4]; ArrayString* params_names=0; if(int size=params_names_code->count()) { params_names=new ArrayString; - for(int i=0; icount()) { locals_names=new ArrayString; - for(int i=0; iadd_method(PC.alias_method(name), method); -} - break; - - case 20: -#line 244 "compile.y" - {yyval=yyvsp[-1]} - break; - - case 24: -#line 246 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) } - break; - - case 30: -#line 254 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 36: -#line 260 "compile.y" - { +; + break;} +case 19: +#line 243 "compile.y" +{yyval=yyvsp[-1]; + break;} +case 23: +#line 245 "compile.y" +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ; + break;} +case 29: +#line 253 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 35: +#line 259 "compile.y" +{ yyval=yyvsp[0]; /* stack: resulting value */ changetail_or_append(*yyval, OP_GET_ELEMENT, false, /*->*/OP_GET_ELEMENT__WRITE, /*or */OP_WRITE_VALUE ); /* value=pop; wcontext.write(value) */ -} - break; - - case 37: -#line 267 "compile.y" - { yyval=yyvsp[0] } - break; - - case 40: -#line 269 "compile.y" - { yyval=yyvsp[-1] } - break; - - case 43: -#line 273 "compile.y" - { +; + break;} +case 36: +#line 266 "compile.y" +{ yyval=yyvsp[0] ; + break;} +case 39: +#line 268 "compile.y" +{ yyval=yyvsp[-1] ; + break;} +case 42: +#line 272 "compile.y" +{ yyval=N(); ArrayOperation* diving_code=yyvsp[0]; const String* first_name=LA2S(*diving_code); // self.xxx... -> xxx... - // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... + // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... if(first_name && *first_name==SELF_ELEMENT_NAME) { O(*yyval, OP_WITH_SELF); /* stack: starting context */ P(*yyval, *diving_code, /* skip over... */ - diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); + diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/); } else { O(*yyval, OP_WITH_READ); /* stack: starting context */ // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR - // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR. - if(PC.in_call_value && diving_code->count()==3) - diving_code->put(2, OP_GET_ELEMENT_OR_OPERATOR); + // OP_VALUE+origin+string+OP_GET_ELEMENT. -> OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR. + if(PC.in_call_value && diving_code->count()==4) + diving_code->put(4-1, OP_GET_ELEMENT_OR_OPERATOR); P(*yyval, *diving_code); } /* diving code; stack: current context */ -} - break; - - case 44: +; + break;} +case 43: +#line 294 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 45: #line 295 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 46: -#line 296 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 47: -#line 300 "compile.y" - { +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 46: +#line 299 "compile.y" +{ yyval=yyvsp[-1]; /* stack: context,name */ P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */ -} - break; - - case 51: -#line 308 "compile.y" - { +; + break;} +case 50: +#line 307 "compile.y" +{ yyval=N(); ArrayOperation* diving_code=yyvsp[0]; const String* first_name=LA2S(*diving_code); // $self.xxx... -> $xxx... - // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... + // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+... if(first_name && *first_name==SELF_ELEMENT_NAME) { O(*yyval, OP_WITH_SELF); /* stack: starting context */ P(*yyval, *diving_code, /* skip over... */ - diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); + diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/); } else { O(*yyval, OP_WITH_ROOT); /* stack: starting context */ P(*yyval, *diving_code); } /* diving code; stack: current context */ -} - break; - - case 52: -#line 325 "compile.y" - { +; + break;} +case 51: +#line 324 "compile.y" +{ yyval=N(); O(*yyval, OP_WITH_WRITE); /* stack: starting context */ P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */ -} - break; - - case 53: -#line 330 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 57: -#line 337 "compile.y" - { +; + break;} +case 52: +#line 329 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 56: +#line 336 "compile.y" +{ // stack: context, name yyval=yyvsp[-1]; // stack: context, name, value O(*yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */ -} - break; - - case 58: -#line 343 "compile.y" - { +; + break;} +case 57: +#line 342 "compile.y" +{ yyval=N(); O(*yyval, OP_PREPARE_TO_EXPRESSION); // stack: context, name P(*yyval, *yyvsp[-1]); // stack: context, name, value O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */ -} - break; - - case 59: -#line 351 "compile.y" - { +; + break;} +case 58: +#line 350 "compile.y" +{ // stack: context, name yyval=N(); OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */ -} - break; - - case 63: -#line 362 "compile.y" - { +; + break;} +case 62: +#line 361 "compile.y" +{ yyval=N(); OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */ /* some code that writes to that context */ /* context=pop; stack: context.value() */ -} - break; - - case 66: -#line 369 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 67: -#line 373 "compile.y" - { +; + break;} +case 65: +#line 368 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 66: +#line 372 "compile.y" +{ yyval=yyvsp[0]; /* stack: value */ changetail_or_append(*yyval, OP_CALL, true, /*->*/ OP_CALL__WRITE, /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */ -} - break; - - case 68: -#line 379 "compile.y" - { +; + break;} +case 67: +#line 378 "compile.y" +{ PC.in_call_value=true; - } - break; - - case 69: -#line 382 "compile.y" - { + ; + break;} +case 68: +#line 381 "compile.y" +{ PC.in_call_value=false; - } - break; - - case 70: -#line 385 "compile.y" - { /* ^field.$method{vasya} */ + ; + break;} +case 69: +#line 384 "compile.y" +{ /* ^field.$method{vasya} */ yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */ YYSTYPE params_code=yyvsp[-1]; - if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM] - if(Value* value=LA2V(*params_code)) // it is OP_VALUE + value? + if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM] + if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value? if(!value->is_defined()) // value is VVoid? params_code=0; // ^zzz[] case. don't append lone empty param. } /* stack: context, method_junction */ OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value -} - break; - - case 73: -#line 400 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 77: +; + break;} +case 72: +#line 399 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 76: +#line 405 "compile.y" +{yyval=yyvsp[-1]; + break;} +case 77: #line 406 "compile.y" - {yyval=yyvsp[-1]} - break; - - case 78: +{yyval=yyvsp[-1]; + break;} +case 78: #line 407 "compile.y" - {yyval=yyvsp[-1]} - break; - - case 79: -#line 408 "compile.y" - {yyval=yyvsp[-1]} - break; - - case 81: -#line 411 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) } - break; - - case 83: -#line 415 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) } - break; - - case 85: -#line 419 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) } - break; - - case 86: -#line 421 "compile.y" - { +{yyval=yyvsp[-1]; + break;} +case 80: +#line 410 "compile.y" +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ; + break;} +case 82: +#line 414 "compile.y" +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ; + break;} +case 84: +#line 418 "compile.y" +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ; + break;} +case 85: +#line 420 "compile.y" +{ yyval=yyvsp[0]; O(*yyval, OP_STORE_PARAM); -} - break; - - case 87: -#line 425 "compile.y" - { +; + break;} +case 86: +#line 424 "compile.y" +{ yyval=N(); OA(*yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]); -} - break; - - case 88: -#line 429 "compile.y" - { +; + break;} +case 87: +#line 428 "compile.y" +{ yyval=N(); OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]); -} - break; - - case 92: -#line 438 "compile.y" - { +; + break;} +case 91: +#line 437 "compile.y" +{ yyval=N(); O(*yyval, OP_PREPARE_TO_EXPRESSION); P(*yyval, *yyvsp[0]); O(*yyval, OP_WRITE_EXPR_RESULT); -} - break; - - case 94: -#line 447 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 96: -#line 449 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 98: -#line 451 "compile.y" - { +; + break;} +case 93: +#line 446 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 95: +#line 448 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 97: +#line 450 "compile.y" +{ // we know that name_advance1 not called from ^xxx context // so we'll not check for operator call possibility as we do in name_advance2 /* stack: context */ yyval=yyvsp[0]; /* stack: context,name */ O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ -} - break; - - case 99: -#line 459 "compile.y" - { +; + break;} +case 98: +#line 458 "compile.y" +{ /* stack: context */ yyval=yyvsp[0]; /* stack: context,name */ O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ -} - break; - - case 105: -#line 472 "compile.y" - { +; + break;} +case 104: +#line 471 "compile.y" +{ yyval=yyvsp[0]; O(*yyval, OP_GET_ELEMENT); -} - break; - - case 106: -#line 476 "compile.y" - { +; + break;} +case 105: +#line 475 "compile.y" +{ ArrayOperation* code; { change_string_literal_to_write_string_literal(*(code=yyvsp[-1])); @@ -1786,44 +1434,39 @@ yyreduce: } yyval=N(); OA(*yyval, OP_STRING_POOL, code); -} - break; - - case 107: -#line 485 "compile.y" - { +; + break;} +case 106: +#line 484 "compile.y" +{ yyval=N(); OA(*yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */ /* some code that writes to that context */ /* context=pop; stack: context.value() */ -} - break; - - case 108: -#line 491 "compile.y" - { +; + break;} +case 107: +#line 490 "compile.y" +{ yyval=N(); O(*yyval, OP_WITH_READ); P(*yyval, *yyvsp[0]); -} - break; - - case 110: +; + break;} +case 109: +#line 495 "compile.y" +{ yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ; + break;} +case 110: #line 496 "compile.y" - { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) } - break; - - case 111: -#line 497 "compile.y" - { +{ yyval=yyvsp[0]; O(*yyval, OP_GET_ELEMENT__WRITE); -} - break; - - case 114: -#line 506 "compile.y" - { +; + break;} +case 113: +#line 505 "compile.y" +{ yyval=yyvsp[-1]; // stack: class name string if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class if(VStateless_class* base=PC.cclass->base_class()) { @@ -1834,478 +1477,432 @@ yyreduce: } } O(*yyval, OP_GET_CLASS); -} - break; - - case 115: -#line 518 "compile.y" - { +; + break;} +case 114: +#line 517 "compile.y" +{ yyval=yyvsp[-1]; if(!PC.in_call_value) { strcpy(PC.error, ":: not allowed here"); YYERROR; } O(*yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT); -} - break; - - case 116: -#line 530 "compile.y" - { +; + break;} +case 115: +#line 529 "compile.y" +{ // see OP_PREPARE_TO_EXPRESSION!! if((yyval=yyvsp[0])->count()==2) // only one string literal in there? change_string_literal_to_double_literal(*yyval); // make that string literal Double -} - break; - - case 120: +; + break;} +case 119: +#line 538 "compile.y" +{ yyval = yyvsp[-1]; ; + break;} +case 120: #line 539 "compile.y" - { yyval = yyvsp[-1]; } - break; - - case 121: +{ yyval = yyvsp[-1]; ; + break;} +case 121: #line 540 "compile.y" - { yyval = yyvsp[-1]; } - break; - - case 122: -#line 541 "compile.y" - { yyval = yyvsp[-1]; } - break; - - case 123: +{ yyval = yyvsp[-1]; ; + break;} +case 122: +#line 542 "compile.y" +{ yyval=yyvsp[0]; O(*yyval, OP_NEG) ; + break;} +case 123: #line 543 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_NEG) } - break; - - case 124: +{ yyval=yyvsp[0] ; + break;} +case 124: #line 544 "compile.y" - { yyval=yyvsp[0] } - break; - - case 125: +{ yyval=yyvsp[0]; O(*yyval, OP_INV) ; + break;} +case 125: #line 545 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_INV) } - break; - - case 126: +{ yyval=yyvsp[0]; O(*yyval, OP_NOT) ; + break;} +case 126: #line 546 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_NOT) } - break; - - case 127: +{ yyval=yyvsp[0]; O(*yyval, OP_DEF) ; + break;} +case 127: #line 547 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_DEF) } - break; - - case 128: +{ yyval=yyvsp[0]; O(*yyval, OP_IN) ; + break;} +case 128: #line 548 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_IN) } - break; - - case 129: +{ yyval=yyvsp[0]; O(*yyval, OP_FEXISTS) ; + break;} +case 129: #line 549 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_FEXISTS) } - break; - - case 130: -#line 550 "compile.y" - { yyval=yyvsp[0]; O(*yyval, OP_DEXISTS) } - break; - - case 131: +{ yyval=yyvsp[0]; O(*yyval, OP_DEXISTS) ; + break;} +case 130: +#line 551 "compile.y" +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_SUB) ; + break;} +case 131: #line 552 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_SUB) } - break; - - case 132: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_ADD) ; + break;} +case 132: #line 553 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_ADD) } - break; - - case 133: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_MUL) ; + break;} +case 133: #line 554 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_MUL) } - break; - - case 134: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_DIV) ; + break;} +case 134: #line 555 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_DIV) } - break; - - case 135: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_MOD) ; + break;} +case 135: #line 556 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_MOD) } - break; - - case 136: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_INTDIV) ; + break;} +case 136: #line 557 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_INTDIV) } - break; - - case 137: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_SL) ; + break;} +case 137: #line 558 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_SL) } - break; - - case 138: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_SR) ; + break;} +case 138: #line 559 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_SR) } - break; - - case 139: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_AND) ; + break;} +case 139: #line 560 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_AND) } - break; - - case 140: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_OR) ; + break;} +case 140: #line 561 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_OR) } - break; - - case 141: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_XOR) ; + break;} +case 141: #line 562 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_BIN_XOR) } - break; - - case 142: +{ yyval=yyvsp[-2]; OA(*yyval, OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP_LOG_AND) ; + break;} +case 142: #line 563 "compile.y" - { yyval=yyvsp[-2]; OA(*yyval, OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP_LOG_AND) } - break; - - case 143: +{ yyval=yyvsp[-2]; OA(*yyval, OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP_LOG_OR) ; + break;} +case 143: #line 564 "compile.y" - { yyval=yyvsp[-2]; OA(*yyval, OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP_LOG_OR) } - break; - - case 144: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_LOG_XOR) ; + break;} +case 144: #line 565 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_LOG_XOR) } - break; - - case 145: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_LT) ; + break;} +case 145: #line 566 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_LT) } - break; - - case 146: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_GT) ; + break;} +case 146: #line 567 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_GT) } - break; - - case 147: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_LE) ; + break;} +case 147: #line 568 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_LE) } - break; - - case 148: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_GE) ; + break;} +case 148: #line 569 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_GE) } - break; - - case 149: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_EQ) ; + break;} +case 149: #line 570 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_EQ) } - break; - - case 150: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_NE) ; + break;} +case 150: #line 571 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_NUM_NE) } - break; - - case 151: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_LT) ; + break;} +case 151: #line 572 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_LT) } - break; - - case 152: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_GT) ; + break;} +case 152: #line 573 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_GT) } - break; - - case 153: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_LE) ; + break;} +case 153: #line 574 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_LE) } - break; - - case 154: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_GE) ; + break;} +case 154: #line 575 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_GE) } - break; - - case 155: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_EQ) ; + break;} +case 155: #line 576 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_EQ) } - break; - - case 156: +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_NE) ; + break;} +case 156: #line 577 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_STR_NE) } - break; - - case 157: -#line 578 "compile.y" - { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_IS) } - break; - - case 158: -#line 581 "compile.y" - { +{ yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP_IS) ; + break;} +case 157: +#line 580 "compile.y" +{ yyval=N(); OA(*yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */ /* some code that writes to that context */ /* context=pop; stack: context.get_string() */ -} - break; - - case 159: -#line 590 "compile.y" - { +; + break;} +case 158: +#line 589 "compile.y" +{ // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE change_string_literal_to_write_string_literal(*(yyval=yyvsp[0])) -} - break; - - case 160: +; + break;} +case 159: +#line 594 "compile.y" +{ yyval=VL(new VVoid(), 0, 0, 0) ; + break;} +case 160: #line 595 "compile.y" - { yyval=VL(new VVoid(), 0, 0, 0) } - break; - - case 161: -#line 596 "compile.y" - { yyval=N() } - break; - - - } - -/* Line 1016 of /usr/local/share/bison/yacc.c. */ -#line 2084 "compile.tab.C" +{ yyval=N() ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/bison.simple" yyvsp -= yylen; yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif - -#if YYDEBUG +#if YYDEBUG != 0 if (yydebug) { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); } #endif *++yyvsp = yyval; +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#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. */ + /* 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 - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTOKENS]; + yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; +yyerrlab: /* here on detecting error */ -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ { ++yynerrs; -#if YYERROR_VERBOSE + +#ifdef YYERROR_VERBOSE yyn = yypact[yystate]; - if (YYPACT_NINF < yyn && yyn < YYLAST) + if (yyn > YYFLAG && yyn < YYLAST) { - YYSIZE_T yysize = 0; - int yytype = YYTRANSLATE (yychar); - 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 && yyx != YYTERROR) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[yytype]); - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg != 0) + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[yytype]); + strcpy(msg, "parse error"); - if (yycount < 5) + if (count < 5) { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); - yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; } } - yyerror (yymsg); - YYSTACK_FREE (yymsg); + yyerror(msg); + free(msg); } else - yyerror ("parse error; also virtual memory exhausted"); + yyerror ("parse error; also virtual memory exceeded"); } else #endif /* YYERROR_VERBOSE */ - yyerror ("parse error"); + yyerror("parse error"); } - goto yyerrlab1; + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ -/*----------------------------------------------------. -| 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. */ + /* if just tried and failed to reuse lookahead token after an error, discard it. */ - /* Return failure if at end of input. */ + /* return failure if at end of input */ if (yychar == YYEOF) - { - /* Pop the error token. */ - YYPOPSTACK; - /* Pop the rest of the stack. */ - while (yyssp > yyss) - { - YYDPRINTF ((stderr, "Error: popping ")); - YYDSYMPRINT ((stderr, - yystos[*yyssp], - *yyvsp)); - YYDPRINTF ((stderr, "\n")); - yydestruct (yystos[*yyssp], *yyvsp); - YYPOPSTACK; - } - YYABORT; - } + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yydestruct (yychar1, yylval); yychar = YYEMPTY; } - /* Else will try to reuse lookahead token after shifting the error - token. */ + /* Else will try to reuse lookahead token + after shifting the error token. */ - yyerrstatus = 3; /* Each real token shifted decrements this. */ + yyerrstatus = 3; /* Each real token shifted decrements this */ - for (;;) - { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } + goto yyerrhandle; - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; +yyerrdefault: /* current state does not do anything special for the error token. */ - YYDPRINTF ((stderr, "Error: popping ")); - YYDSYMPRINT ((stderr, - yystos[*yyssp], *yyvsp)); - YYDPRINTF ((stderr, "\n")); +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif - yydestruct (yystos[yystate], *yyvsp); - yyvsp--; - yystate = *--yyssp; +yyerrpop: /* pop the current state because it cannot handle the error token */ + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef 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"); - } +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } #endif + +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, ")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif *++yyvsp = yylval; - +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif yystate = yyn; goto yynewstate; + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*----------------------------------------------. -| yyoverflowlab -- parser overflow comes here. | -`----------------------------------------------*/ -yyoverflowlab: - yyerror ("parser stack overflow"); - yyresult = 2; - /* Fall through. */ -#endif - -yyreturn: -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); #endif - return yyresult; + } + return 1; } - - -#line 598 "compile.y" +#line 597 "compile.y" #endif /* - 000(2222)00 - 000{3333}00 + 000$111(2222)00 + 000$111{3333}00 $,^: push,=0 1:( { break=pop 2:( ) pop @@ -2344,7 +1941,6 @@ static int yylex(YYSTYPE *lvalp, void *a const char *begin=pc.source; Pos begin_pos=pc.pos; - uint last_line_end_col=0; const char *end; int skip_analized=0; while(true) { @@ -2352,11 +1948,9 @@ static int yylex(YYSTYPE *lvalp, void *a // fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp); if(c=='\n') { - pc.pos.line++; - last_line_end_col=pc.pos.col; - pc.pos.col=0; + pc.pos_next_line(); } else - pc.pos.col+=c=='\t'?TAB_SIZE:1; + pc.pos_next_c(c); if(c=='@' && pc.pos.col==0+1) { if(pc.ls==LS_DEF_SPECIAL_BODY) { @@ -2402,7 +1996,7 @@ default: if(!pc.string_start) pc.string_start=begin_pos; // append piece till ^ - pc.string.append_strdup(begin, end-begin); + pc.string.append_strdup_know_length(begin, end-begin); } // reset piece 'begin' position & line begin=pc.source; // ->punctuation @@ -2418,7 +2012,7 @@ default: if(!pc.string_start) pc.string_start=begin_pos; // append piece till ^ - pc.string.append_strdup(begin, end-begin); + pc.string.append_strdup_know_length(begin, end-begin); } // #HH ? if(pc.source[0]=='#' && pc.source[1] && pc.source[2]) { @@ -2451,7 +2045,7 @@ default: if(!pc.string_start) pc.string_start=begin_pos; // append piece till # - pc.string.append_strdup(begin, end-begin); + pc.string.append_strdup_know_length(begin, end-begin); } // fall into COMMENT lexical state [wait for \n] push_LS(pc, LS_USER_COMMENT); @@ -2596,7 +2190,7 @@ default: if(!pc.string_start) pc.string_start=begin_pos; // append piece till # - pc.string.append_strdup(begin, end-begin); + pc.string.append_strdup_know_length(begin, end-begin); } // fall into COMMENT lexical state [wait for \n] push_LS(pc, LS_EXPRESSION_COMMENT); @@ -2779,7 +2373,7 @@ default: // expression integer division case '\\': pop_LS(pc); - ungetc(pc, last_line_end_col); + pc.ungetc(); result=EON; goto break2; } @@ -2791,7 +2385,7 @@ default: switch(c) { case ':': pop_LS(pc); - ungetc(pc, last_line_end_col); + pc.ungetc(); result=EON; goto break2; } @@ -2811,7 +2405,7 @@ default: // before call case '^': pop_LS(pc); - ungetc(pc, last_line_end_col); + pc.ungetc(); result=EON; goto break2; case '[': @@ -3008,7 +2602,7 @@ default: RC; } pop_LS(pc); - ungetc(pc, last_line_end_col); + pc.ungetc(); result=EON; goto break2; } @@ -3030,11 +2624,11 @@ break2: if(!pc.string_start) pc.string_start=begin_pos; // append it - pc.string.append_strdup(begin, end-begin); + pc.string.append_strdup_know_length(begin, end-begin); } } if(!pc.string.is_empty()) { // something accumulated? - // create STRING value: array of OP_VALUE+vstring + // create STRING value: array of OP_VALUE+origin+vstring *lvalp=VL( new VString(*new String(pc.string, String::L_CLEAN)), pc.file_no, pc.string_start.line, pc.string_start.col); @@ -3059,5 +2653,3 @@ static void yyprint(FILE *file, int type if(type==STRING) fprintf(file, " \"%s\"", LA2S(*value)->cstr()); } - -