--- parser3/src/main/compile.tab.C 2002/12/06 17:27:35 1.78 +++ parser3/src/main/compile.tab.C 2010/10/08 13:16:36 1.152 @@ -1,49 +1,138 @@ +/* A Bison parser, made by GNU Bison 1.875d. */ -/* A Bison parser, made from compile.y - by GNU Bison version 1.28 */ +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 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. */ + +/* 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 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* 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_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 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, + LITERAL_TRUE = 287, + LITERAL_FALSE = 288, + NUNARY = 289 + }; +#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_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE 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 LITERAL_TRUE 287 +#define LITERAL_FALSE 288 +#define NUNARY 289 -#define YYBISON 1 /* Identify Bison output. */ -#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 + +/* Copy the first part of user declarations. */ #line 1 "compile.y" /** @file Parser: compiler(lexical parser and grammar). - Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan (http://design.ru/paf) - $Id: compile.tab.C,v 1.78 2002/12/06 17:27:35 paf Exp $ + $Id: compile.tab.C,v 1.152 2010/10/08 13:16:36 misha Exp $ */ /** @@ -57,14 +146,16 @@ -#: in iis make up specialized Pool object for that */ -#define YYSTYPE Array/**/ * +#define YYSTYPE ArrayOperation* #define YYPARSE_PARAM pc #define YYLEX_PARAM pc #define YYDEBUG 1 #define YYERROR_VERBOSE 1 -#define yyerror(msg) real_yyerror((parse_control *)pc, msg) +#define yyerror(msg) real_yyerror((Parse_control *)pc, msg) #define YYPRINT(file, type, value) yyprint(file, type, value) +// includes + #include "compile_tools.h" #include "pa_value.h" #include "pa_request.h" @@ -74,714 +165,1068 @@ #include "pa_vvoid.h" #include "pa_vmethod_frame.h" -#define USE_CONTROL_METHOD_NAME "USE" - -static int real_yyerror(parse_control *pc, char *s); -static void yyprint(FILE *file, int type, YYSTYPE value); -static int yylex(YYSTYPE *lvalp, void *pc); +// defines +#define USE_CONTROL_METHOD_NAME "USE" +#define OPTIONS_CONTROL_METHOD_NAME "OPTIONS" +#define OPTION_ALL_VARS_LOCAL_NAME "locals" +#define OPTION_PARTIAL_CLASS "partial" +#define REM_OPERATOR_NAME "rem" + +// forwards + +static int real_yyerror(Parse_control* pc, char* s); +static void yyprint(FILE* file, int type, YYSTYPE value); +static int yylex(YYSTYPE* lvalp, void* pc); + +static const VBool vfalse(false); +static const VBool vtrue(true); +static const VVoid vvoid; // local convinient inplace typecast & var -#define PC (*(parse_control *)pc) +#undef PC +#define PC (*(Parse_control *)pc) +#undef POOL #define POOL (*PC.pool) -#undef NEW -#define NEW new(POOL) #ifndef DOXYGEN -#ifndef YYSTYPE -#define YYSTYPE int -#endif -#include -#ifndef __cplusplus -#ifndef __STDC__ -#define const + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 #endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 #endif +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +typedef int YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 214 of yacc.c. */ +#line 221 "compile.tab.C" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# endif +# else +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# 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 YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short int yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (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 int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 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_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) +#endif -#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 -}; +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif -#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 +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 51 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 470 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 62 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 89 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 172 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 263 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 289 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 48, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 46, 60, 2, 52, 43, 37, 61, + 56, 57, 40, 38, 2, 39, 55, 41, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 59, 51, + 34, 2, 35, 2, 47, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 49, 42, 50, 58, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 53, 36, 54, 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, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 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, 32, 33, 44 }; -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 +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned short int yyprhs[] = +{ + 0, 0, 3, 5, 7, 9, 12, 14, 16, 18, + 23, 25, 27, 29, 32, 35, 37, 39, 40, 49, + 51, 53, 57, 59, 61, 63, 67, 69, 71, 73, + 75, 77, 80, 82, 84, 86, 88, 90, 92, 95, + 98, 100, 104, 106, 108, 110, 113, 115, 118, 122, + 124, 126, 128, 130, 133, 136, 138, 140, 142, 143, + 144, 150, 154, 158, 160, 162, 164, 166, 168, 170, + 173, 175, 176, 177, 184, 186, 188, 191, 193, 195, + 197, 198, 199, 205, 209, 213, 215, 219, 221, 225, + 227, 231, 233, 235, 237, 239, 241, 243, 245, 248, + 250, 253, 256, 258, 260, 263, 265, 267, 269, 271, + 274, 277, 278, 279, 285, 287, 289, 292, 295, 297, + 299, 302, 305, 307, 309, 311, 313, 315, 317, 321, + 325, 329, 332, 335, 338, 341, 344, 347, 350, 353, + 357, 361, 365, 369, 373, 377, 381, 385, 389, 393, + 397, 401, 405, 409, 413, 417, 421, 425, 429, 433, + 437, 441, 445, 449, 453, 457, 461, 463, 465, 467, + 468, 470, 472 }; -#endif +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const short int yyrhs[] = +{ + 63, 0, -1, 65, -1, 64, -1, 66, -1, 64, + 66, -1, 79, -1, 67, -1, 72, -1, 47, 4, + 48, 68, -1, 150, -1, 69, -1, 70, -1, 69, + 70, -1, 71, 48, -1, 150, -1, 4, -1, -1, + 47, 4, 75, 74, 78, 48, 73, 79, -1, 150, + -1, 75, -1, 49, 76, 50, -1, 150, -1, 77, + -1, 4, -1, 77, 51, 4, -1, 150, -1, 4, + -1, 150, -1, 80, -1, 81, -1, 80, 81, -1, + 146, -1, 82, -1, 83, -1, 91, -1, 106, -1, + 84, -1, 52, 85, -1, 87, 3, -1, 86, -1, + 53, 87, 54, -1, 88, -1, 89, -1, 90, -1, + 139, 90, -1, 129, -1, 126, 129, -1, 52, 92, + 96, -1, 93, -1, 94, -1, 95, -1, 125, -1, + 55, 125, -1, 139, 125, -1, 97, -1, 100, -1, + 101, -1, -1, -1, 49, 98, 102, 99, 50, -1, + 56, 142, 57, -1, 53, 79, 54, -1, 147, -1, + 4, -1, 103, -1, 104, -1, 105, -1, 82, -1, + 81, 80, -1, 107, -1, -1, -1, 58, 108, 110, + 109, 111, 3, -1, 87, -1, 112, -1, 111, 112, + -1, 113, -1, 116, -1, 117, -1, -1, -1, 49, + 114, 118, 115, 50, -1, 56, 119, 57, -1, 53, + 120, 54, -1, 121, -1, 118, 51, 121, -1, 122, + -1, 119, 51, 122, -1, 123, -1, 120, 51, 123, + -1, 124, -1, 142, -1, 79, -1, 147, -1, 4, + -1, 103, -1, 130, -1, 126, 130, -1, 127, -1, + 126, 127, -1, 128, 55, -1, 130, -1, 130, -1, + 4, 5, -1, 4, -1, 131, -1, 132, -1, 133, + -1, 52, 136, -1, 4, 137, -1, -1, -1, 49, + 134, 80, 135, 50, -1, 4, -1, 138, -1, 137, + 138, -1, 52, 136, -1, 140, -1, 141, -1, 4, + 59, -1, 140, 59, -1, 143, -1, 144, -1, 148, + -1, 149, -1, 84, -1, 107, -1, 60, 145, 60, + -1, 61, 145, 61, -1, 56, 143, 57, -1, 39, + 143, -1, 38, 143, -1, 45, 143, -1, 46, 143, + -1, 27, 143, -1, 28, 143, -1, 29, 143, -1, + 30, 143, -1, 143, 39, 143, -1, 143, 38, 143, + -1, 143, 40, 143, -1, 143, 41, 143, -1, 143, + 43, 143, -1, 143, 42, 143, -1, 143, 19, 143, + -1, 143, 20, 143, -1, 143, 37, 143, -1, 143, + 36, 143, -1, 143, 14, 143, -1, 143, 11, 143, + -1, 143, 12, 143, -1, 143, 13, 143, -1, 143, + 34, 143, -1, 143, 35, 143, -1, 143, 15, 143, + -1, 143, 16, 143, -1, 143, 17, 143, -1, 143, + 18, 143, -1, 143, 21, 143, -1, 143, 22, 143, + -1, 143, 23, 143, -1, 143, 24, 143, -1, 143, + 25, 143, -1, 143, 26, 143, -1, 143, 31, 143, + -1, 4, -1, 79, -1, 4, -1, -1, 32, -1, + 33, -1, -1 +}; -#if YYDEBUG != 0 -static const short yyrline[] = { 0, - 115, 125, 127, 127, 128, 130, 130, 132, 199, 199, - 200, 200, 201, 202, 202, 204, 233, 233, 234, 235, - 235, 236, 236, 238, 238, 242, 242, 244, 244, 245, - 245, 246, 246, 246, 250, 257, 258, 258, 259, 260, - 262, 263, 285, 286, 286, 290, 294, 296, 297, 298, - 315, 320, 322, 324, 325, 327, 333, 341, 347, 349, - 350, 352, 358, 359, 359, 363, 369, 372, 375, 388, - 390, 390, 391, 393, 394, 396, 397, 398, 399, 401, - 403, 405, 407, 409, 411, 415, 419, 423, 425, 426, - 428, 437, 437, 439, 439, 440, 441, 449, 454, 456, - 458, 459, 460, 462, 466, 475, 481, 486, 486, 487, - 492, 494, 496, 508, 520, 525, 527, 528, 529, 530, - 531, 533, 534, 535, 536, 537, 538, 539, 540, 542, - 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, - 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, - 563, 564, 565, 566, 567, 568, 571, 580, 585, 586 +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = +{ + 0, 132, 132, 139, 141, 141, 142, 144, 144, 146, + 253, 253, 254, 254, 255, 256, 256, 258, 258, 306, + 306, 307, 308, 308, 309, 309, 311, 311, 315, 315, + 317, 317, 318, 318, 319, 319, 319, 323, 364, 365, + 365, 366, 368, 369, 370, 423, 424, 424, 428, 441, + 442, 443, 444, 470, 475, 478, 479, 480, 482, 485, + 482, 493, 501, 508, 509, 510, 512, 518, 519, 519, + 523, 535, 538, 535, 582, 584, 584, 586, 587, 588, + 590, 593, 590, 596, 597, 599, 600, 603, 604, 607, + 608, 610, 613, 627, 632, 633, 634, 639, 639, 641, + 641, 642, 643, 651, 656, 659, 660, 661, 662, 664, + 668, 677, 680, 677, 688, 693, 693, 694, 700, 701, + 703, 716, 728, 730, 731, 732, 733, 734, 735, 736, + 737, 739, 740, 741, 742, 743, 744, 745, 746, 748, + 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, + 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 777, 782, 803, 808, + 809, 810, 812 }; #endif - -#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 +#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_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"", + "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"", + "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"", + "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"", + "\"false\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'", + "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", "'['", "']'", + "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'", "':'", "'\"'", + "'''", "$accept", "all", "methods", "one_big_piece", "method", + "control_method", "maybe_control_strings", "control_strings", + "control_string", "maybe_string", "code_method", "@1", + "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", "@2", "@3", + "construct_round", "construct_curly", "any_constructor_code_value", + "constructor_code_value", "constructor_code", + "codes__excluding_sole_str_literal", "call", "call_value", "@4", "@5", + "call_name", "store_params", "store_param", "store_square_param", "@6", + "@7", "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", "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", "@8", "@9", + "subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write", + "class_prefix", "class_static_prefix", "class_constructor_prefix", + "expr_value", "expr", "double_or_STRING", "string_inside_quotes_value", + "write_string", "void_value", "true_value", "false_value", "empty", 0 }; #endif -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 +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int 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, 287, 288, 60, 62, 124, 38, 43, 45, + 42, 47, 92, 37, 289, 126, 33, 64, 10, 91, + 93, 59, 36, 123, 125, 46, 40, 41, 94, 58, + 34, 39 }; +# endif -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 +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 62, 63, 63, 64, 64, 65, 66, 66, 67, + 68, 68, 69, 69, 70, 71, 71, 73, 72, 74, + 74, 75, 76, 76, 77, 77, 78, 78, 79, 79, + 80, 80, 81, 81, 82, 82, 82, 83, 84, 85, + 85, 86, 87, 87, 88, 89, 90, 90, 91, 92, + 92, 92, 93, 94, 95, 96, 96, 96, 98, 99, + 97, 100, 101, 102, 102, 102, 103, 104, 105, 105, + 106, 108, 109, 107, 110, 111, 111, 112, 112, 112, + 114, 115, 113, 116, 117, 118, 118, 119, 119, 120, + 120, 121, 122, 123, 124, 124, 124, 125, 125, 126, + 126, 127, 128, 129, 129, 130, 130, 130, 130, 131, + 132, 134, 135, 133, 136, 137, 137, 138, 139, 139, + 140, 141, 142, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 143, 144, 145, 146, 147, + 148, 149, 150 }; -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 +/* 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, 0, 8, 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, 0, 0, + 5, 3, 3, 1, 1, 1, 1, 1, 1, 2, + 1, 0, 0, 6, 1, 1, 2, 1, 1, 1, + 0, 0, 5, 3, 3, 1, 3, 1, 3, 1, + 3, 1, 1, 1, 1, 1, 1, 1, 2, 1, + 2, 2, 1, 1, 2, 1, 1, 1, 1, 2, + 2, 0, 0, 5, 1, 1, 2, 2, 1, 1, + 2, 2, 1, 1, 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, 1, 0, + 1, 1, 0 }; -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 +/* 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[] = +{ + 172, 168, 0, 0, 71, 0, 3, 2, 4, 7, + 8, 6, 29, 30, 33, 34, 37, 35, 36, 70, + 32, 28, 0, 105, 111, 0, 0, 0, 38, 40, + 0, 42, 43, 44, 0, 49, 50, 51, 52, 0, + 99, 0, 46, 97, 106, 107, 108, 0, 118, 119, + 0, 1, 5, 31, 172, 172, 172, 104, 0, 120, + 110, 115, 0, 114, 109, 0, 0, 103, 0, 105, + 53, 0, 97, 39, 58, 172, 0, 48, 55, 56, + 57, 105, 100, 47, 98, 101, 45, 54, 121, 74, + 72, 16, 9, 11, 12, 0, 10, 24, 0, 23, + 22, 172, 20, 19, 117, 116, 112, 41, 98, 169, + 0, 166, 0, 0, 0, 0, 170, 171, 0, 0, + 0, 0, 0, 0, 172, 172, 126, 127, 0, 122, + 123, 124, 125, 0, 13, 15, 14, 21, 0, 27, + 0, 26, 0, 168, 0, 33, 59, 65, 66, 67, + 63, 62, 135, 136, 137, 138, 132, 131, 133, 134, + 0, 167, 0, 0, 61, 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, 80, 172, 0, 0, 75, 77, 78, 79, + 25, 17, 113, 69, 0, 130, 128, 129, 150, 151, + 152, 149, 155, 156, 157, 158, 145, 146, 159, 160, + 161, 162, 163, 164, 165, 153, 154, 148, 147, 140, + 139, 141, 142, 144, 143, 169, 93, 0, 89, 0, + 87, 92, 73, 76, 172, 60, 168, 96, 81, 85, + 91, 94, 172, 84, 0, 83, 18, 169, 0, 90, + 88, 86, 82 }; -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 +/* YYDEFGOTO[NTERM-NUM]. */ +static const short int yydefgoto[] = +{ + -1, 5, 6, 7, 8, 9, 92, 93, 94, 95, + 10, 244, 101, 56, 98, 99, 140, 161, 12, 13, + 14, 15, 126, 28, 29, 30, 31, 32, 33, 17, + 34, 35, 36, 37, 77, 78, 109, 204, 79, 80, + 146, 247, 148, 149, 18, 127, 50, 133, 90, 195, + 196, 197, 235, 258, 198, 199, 248, 239, 237, 249, + 240, 238, 250, 38, 66, 40, 41, 42, 67, 44, + 45, 46, 62, 142, 64, 60, 61, 68, 48, 49, + 241, 129, 130, 162, 20, 251, 131, 132, 21 }; -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 +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -107 +static const short int yypact[] = +{ + 14, -107, 13, 45, -107, 28, -15, -107, -107, -107, + -107, -107, 21, -107, -107, -107, -107, -107, -107, -107, + -107, -107, 73, 19, -107, 50, 6, 44, -107, -107, + 87, -107, -107, -107, -34, -107, -107, -107, -107, 65, + -107, 48, -107, 5, -107, -107, -107, 65, 24, -107, + 6, -107, -107, -107, 88, 109, 74, -107, 50, -107, + 76, -107, 21, -107, -107, 86, 65, 101, 65, 76, + -107, 44, 101, -107, -107, 21, 7, -107, -107, -107, + -107, 18, -107, -107, 5, -107, -107, -107, -107, -107, + -107, -107, -107, 9, -107, 94, 99, -107, 93, 112, + -107, 146, -107, -107, -107, -107, 21, -107, 101, 29, + 110, -107, 7, 7, 7, 7, -107, -107, 7, 7, + 7, 7, 52, 7, 21, 21, -107, -107, 113, 323, + -107, -107, -107, 92, -107, -107, -107, -107, 165, -107, + 144, -107, 147, 149, 21, 80, -107, -107, -107, -107, + -107, -107, 96, 96, 96, 96, -107, -107, -107, -107, + 276, -107, 138, 139, -107, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, -107, 21, 7, 35, -107, -107, -107, -107, + -107, -107, -107, 21, 154, -107, -107, -107, 419, 389, + 356, 284, 135, 135, 148, 148, 191, 191, 135, 135, + 135, 135, 148, 148, 96, 135, 135, 182, 427, 140, + 140, -107, -107, -107, -107, 37, -107, 31, -107, -30, + -107, -107, -107, -107, 21, -107, 108, -107, 155, -107, + -107, -107, 21, -107, 7, -107, -107, 37, 161, -107, + -107, -107, -107 }; - -#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 +/* YYPGOTO[NTERM-NUM]. */ +static const short int yypgoto[] = +{ + -107, -107, -107, -107, 206, -107, -107, -107, 124, -107, + -107, -107, -107, 170, -107, -107, -107, 1, -58, -7, + -106, -107, 0, -107, -107, -6, -107, -107, -21, -107, + -107, -107, -107, -107, -107, -107, -107, -107, -107, -107, + -107, 118, -107, -107, -107, 2, -107, -107, -107, -107, + 43, -107, -107, -107, -107, -107, -107, -107, -107, -17, + -13, -16, -107, -18, 4, 41, -107, -23, 3, -107, + -107, -107, -107, -107, 181, -107, 183, 239, -107, -107, + 171, 95, -107, 123, -107, 142, -107, -107, 64 }; -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 +/* 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, syntax error. */ +#define YYTABLE_NINF -173 +static const short int yytable[] = +{ + 16, 11, 19, 145, 106, 53, 43, 39, -103, 70, + 23, 111, 16, 91, 19, 74, 83, 22, 1, 75, + 65, 254, 76, 57, 57, 1, 86, 255, 51, 87, + 72, 71, 2, 143, 112, 113, 114, 115, 242, 116, + 117, 246, 84, 83, 89, 118, 119, 86, 69, 23, + 43, 39, 120, 121, 63, 24, 23, -172, 25, 122, + -102, 2, 16, 123, 19, 4, 3, 124, 125, 81, + 58, 58, 4, 3, 108, 16, 110, 19, 59, 4, + 82, 3, 252, 88, 192, 253, 203, 4, 193, 3, + 73, 194, 91, 24, 24, 4, 25, 25, 26, 53, + 27, 24, 144, 85, 25, 26, 16, 82, 19, 16, + 168, 19, 82, 97, 24, 173, 174, 25, 96, 100, + 103, 54, 55, 55, 16, 16, 19, 19, 58, 145, + -68, -68, 184, 185, 186, 187, 188, 189, 190, 191, + 107, 192, 136, 137, 16, 193, 19, -15, 194, 168, + 139, 145, 171, 172, 173, 174, -102, 135, -95, -95, + 179, 180, 168, 138, 151, 141, 181, 173, 174, 200, + 164, 184, 185, 186, 187, 188, 189, 190, 191, 181, + 188, 189, 190, 191, 184, 185, 186, 187, 188, 189, + 190, 191, 201, 16, 236, 19, 53, 202, 206, -64, + 207, 173, 174, 16, 245, 19, 257, 152, 153, 154, + 155, 262, 52, 156, 157, 158, 159, 134, 160, 185, + 186, 187, 188, 189, 190, 191, 102, 147, 144, 186, + 187, 188, 189, 190, 191, 16, 259, 19, 243, 104, + 261, 260, 47, 105, 16, 256, 19, 128, 163, 0, + 144, 150, 16, 236, 19, 0, 0, 16, 0, 19, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 173, 174, 0, 0, 181, 0, 0, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 184, 185, 186, 187, 188, 189, 190, 191, 0, 0, + 0, 0, 0, 205, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 0, 0, 0, 0, 181, 0, 0, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 165, 166, 0, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 0, 0, 0, 0, 181, 0, 0, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 165, 0, 0, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 0, 0, 0, 0, + 181, 0, 0, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 173, 174, 0, 0, + 181, 0, 0, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 0, 0, 186, 187, 188, 189, 190, + 191 }; -#define YYPURE 1 - -/* -*-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. */ +static const short int yycheck[] = +{ + 0, 0, 0, 109, 62, 12, 3, 3, 3, 27, + 4, 4, 12, 4, 12, 49, 39, 4, 4, 53, + 26, 51, 56, 5, 5, 4, 47, 57, 0, 47, + 27, 27, 47, 4, 27, 28, 29, 30, 3, 32, + 33, 4, 39, 66, 50, 38, 39, 68, 4, 4, + 47, 47, 45, 46, 4, 49, 4, 48, 52, 52, + 55, 47, 62, 56, 62, 58, 52, 60, 61, 4, + 52, 52, 58, 52, 71, 75, 75, 75, 59, 58, + 39, 52, 51, 59, 49, 54, 144, 58, 53, 52, + 3, 56, 4, 49, 49, 58, 52, 52, 53, 106, + 55, 49, 109, 55, 52, 53, 106, 66, 106, 109, + 14, 109, 71, 4, 49, 19, 20, 52, 54, 55, + 56, 48, 49, 49, 124, 125, 124, 125, 52, 235, + 50, 51, 36, 37, 38, 39, 40, 41, 42, 43, + 54, 49, 48, 50, 144, 53, 144, 48, 56, 14, + 4, 257, 17, 18, 19, 20, 55, 93, 50, 51, + 25, 26, 14, 51, 54, 101, 31, 19, 20, 4, + 57, 36, 37, 38, 39, 40, 41, 42, 43, 31, + 40, 41, 42, 43, 36, 37, 38, 39, 40, 41, + 42, 43, 48, 193, 193, 193, 203, 50, 60, 50, + 61, 19, 20, 203, 50, 203, 51, 112, 113, 114, + 115, 50, 6, 118, 119, 120, 121, 93, 123, 37, + 38, 39, 40, 41, 42, 43, 56, 109, 235, 38, + 39, 40, 41, 42, 43, 235, 252, 235, 195, 58, + 257, 254, 3, 60, 244, 244, 244, 76, 125, -1, + 257, 109, 252, 252, 252, -1, -1, 257, -1, 257, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 19, 20, -1, -1, 31, -1, -1, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 36, 37, 38, 39, 40, 41, 42, 43, -1, -1, + -1, -1, -1, 57, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + -1, -1, -1, -1, 31, -1, -1, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 11, 12, -1, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, -1, -1, -1, -1, 31, -1, -1, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 11, -1, -1, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, -1, -1, -1, -1, + 31, -1, -1, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 19, 20, -1, -1, + 31, -1, -1, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, -1, -1, 38, 39, 40, 41, 42, + 43 +}; -/* 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 */ +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 4, 47, 52, 58, 63, 64, 65, 66, 67, + 72, 79, 80, 81, 82, 83, 84, 91, 106, 107, + 146, 150, 4, 4, 49, 52, 53, 55, 85, 86, + 87, 88, 89, 90, 92, 93, 94, 95, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 139, 140, 141, + 108, 0, 66, 81, 48, 49, 75, 5, 52, 59, + 137, 138, 134, 4, 136, 87, 126, 130, 139, 4, + 125, 126, 130, 3, 49, 53, 56, 96, 97, 100, + 101, 4, 127, 129, 130, 55, 90, 125, 59, 87, + 110, 4, 68, 69, 70, 71, 150, 4, 76, 77, + 150, 74, 75, 150, 136, 138, 80, 54, 130, 98, + 79, 4, 27, 28, 29, 30, 32, 33, 38, 39, + 45, 46, 52, 56, 60, 61, 84, 107, 142, 143, + 144, 148, 149, 109, 70, 150, 48, 50, 51, 4, + 78, 150, 135, 4, 81, 82, 102, 103, 104, 105, + 147, 54, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 79, 145, 145, 57, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 31, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 49, 53, 56, 111, 112, 113, 116, 117, + 4, 48, 50, 80, 99, 57, 60, 61, 143, 143, + 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, + 143, 143, 143, 143, 143, 114, 79, 120, 123, 119, + 122, 142, 3, 112, 73, 50, 4, 103, 118, 121, + 124, 147, 51, 54, 51, 57, 79, 51, 115, 123, + 122, 121, 50 +}; -#ifdef YYSTACK_USE_ALLOCA -#define YYSTACK_ALLOC alloca -#else -#define YYSTACK_ALLOC malloc +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int #endif - -/* 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 YYEMPTY (-2) #define YYEOF 0 + #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 -/* Like YYERROR except do call yyerror. - This remains here temporarily to ease the - transition to the new meaning of YYERROR, for GCC. +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* 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); \ - yychar1 = YYTRANSLATE (yychar); \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = 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 -#ifndef YYPURE -#define YYLEX yylex() -#endif +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ -#ifdef YYPURE -#ifdef YYLSP_NEEDED -#ifdef YYLEX_PARAM -#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) -#else -#define YYLEX yylex(&yylval, &yylloc) +#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) #endif -#else /* not YYLSP_NEEDED */ + +/* YYLEX -- calling `yylex' with the right arguments. */ + #ifdef YYLEX_PARAM -#define YYLEX yylex(&yylval, YYLEX_PARAM) +# define YYLEX yylex (&yylval, YYLEX_PARAM) #else -#define YYLEX yylex(&yylval) -#endif -#endif /* not YYLSP_NEEDED */ +# define YYLEX yylex (&yylval) #endif -/* If nonreentrant, generate the variables here */ +/* Enable debugging if requested. */ +#if YYDEBUG -#ifndef YYPURE +# 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) + +# define YYDSYMPRINTF(Title, Token, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Token, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) -int yychar; /* the lookahead symbol */ -YYSTYPE yylval; /* the semantic value of the */ - /* lookahead symbol */ +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ -#ifdef YYLSP_NEEDED -YYLTYPE yylloc; /* location data for the lookahead */ - /* symbol */ +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; #endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) -int yynerrs; /* number of parse errors so far */ -#endif /* not YYPURE */ -#if YYDEBUG != 0 -int yydebug; /* nonzero means print parse trace */ -/* Since this is uninitialized, it does not stop multiple parsers - from coexisting. */ +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; #endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} 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) +# define YYDSYMPRINTF(Title, Token, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ -/* YYINITDEPTH indicates the initial size of the parser's stacks */ +/* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -#define YYINITDEPTH 200 +# define YYINITDEPTH 200 #endif -/* YYMAXDEPTH is the maximum size the stacks can grow to - (effective only if the built-in stack extension method is used). */ +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). -#if YYMAXDEPTH == 0 -#undef YYMAXDEPTH + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 +# undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH -#define YYMAXDEPTH 10000 +# 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 -/* This is the most reliable way to avoid incompatibilities - in available built-in functions on various systems. */ -static void -__yy_memcpy (to, from, count) - char *to; - char *from; - unsigned int count; -{ - register char *f = from; - register char *t = to; - register int i = count; +#if YYERROR_VERBOSE - while (i-- > 0) - *t++ = *f++; +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; } +# endif +# endif -#else /* __cplusplus */ +#endif /* !YYERROR_VERBOSE */ -/* This is the most reliable way to avoid incompatibilities - in available built-in functions on various systems. */ + + +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) static void -__yy_memcpy (char *to, char *from, unsigned int count) +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif { - register char *t = to; - register char *f = from; - register int i = count; + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + } + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - while (i-- > 0) - *t++ = *f++; + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); } +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yytype, yyvaluep) + int yytype; + YYSTYPE *yyvaluep; #endif -#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + switch (yytype) + { + + default: + break; + } +} -#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 *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef 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 */ +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM); +# else +int yyparse (); +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + + + + +/*----------. +| yyparse. | +`----------*/ -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ #ifdef YYPARSE_PARAM -int yyparse (void *); +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) #else -int yyparse (void); +int +yyparse () + #endif #endif - -int -yyparse(YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL { + /* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + register int yystate; register int yyn; - register short *yyssp; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 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 int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *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 - int yystacksize = YYINITDEPTH; - int yyfree_stacks = 0; + YYSIZE_T yystacksize = YYINITDEPTH; -#ifdef YYPURE - int yychar; - YYSTYPE yylval; - int yynerrs; -#ifdef YYLSP_NEEDED - YYLTYPE yylloc; -#endif -#endif + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; - 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; -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Starting parse\n"); -#endif + YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; @@ -793,110 +1238,97 @@ yyparse(YYPARSE_PARAM_ARG) so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss - 1; + yyssp = yyss; yyvsp = yyvs; -#ifdef YYLSP_NEEDED - yylsp = yyls; -#endif -/* 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: - *++yyssp = yystate; + goto yysetstate; - 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 +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { /* Get the current used size of the three stacks, in elements. */ - int size = yyssp - yyss + 1; + YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow - /* 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 + { + /* 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 int *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; + } #else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) - { - yyerror("parser stack overflow"); - if (yyfree_stacks) - { - free (yyss); - free (yyvs); -#ifdef YYLSP_NEEDED - free (yyls); -#endif - } - return 2; - } + if (YYMAXDEPTH <= yystacksize) + goto yyoverflowlab; yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) + if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; -#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 + + { + short int *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 #endif /* no yyoverflow */ - yyssp = yyss + size - 1; - yyvsp = yyvs + size - 1; -#ifdef YYLSP_NEEDED - yylsp = yyls + size - 1; -#endif + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Stack size increased to %d\n", yystacksize); -#endif - if (yyssp >= yyss + yystacksize - 1) + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) YYABORT; } -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Entering state %d\n", yystate); -#endif + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 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. */ @@ -905,989 +1337,1297 @@ yynewstate: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYFLAG) + if (yyn == YYPACT_NINF) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ - + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Reading a token: "); -#endif + YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ + if (yychar <= YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Now at end of input.\n"); -#endif + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE(yychar); - -#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 + yytoken = YYTRANSLATE (yychar); + YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); } - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYFLAG) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ - -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); -#endif + YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); /* 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; -/* Do the default action for the current state. */ -yydefault: +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; + goto yyreduce; -/* Do a reduction. yyn is the number of a rule to reduce with. */ + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ 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 YYDEBUG != 0 - if (yydebug) - { - int i; + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. - fprintf (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) - fprintf (stderr, "%s ", yytname[yyrhs[i]]); - fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif + 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]; - switch (yyn) { - -case 1: -#line 116 "compile.y" -{ - Method& method=*NEW Method(POOL, - PC.request->main_method_name, - Method::CT_ANY, + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +#line 132 "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.request->main_method_name, method); -; - break;} -case 8: -#line 133 "compile.y" -{ - const String& command=*LA2S(yyvsp[-2]); + PC.cclass->set_method(PC.alias_method(main_method_name), method); +;} + break; + + case 9: +#line 147 "compile.y" + { + const String& command=LA2S(*yyvsp[-2])->trim(String::TRIM_END); YYSTYPE strings_code=yyvsp[0]; - if(strings_code->size()<1*2) { + if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) { strcpy(PC.error, "@"); strcat(PC.error, command.cstr()); strcat(PC.error, " is empty"); YYERROR; } if(command==CLASS_NAME) { - if(PC.cclass->base_class()) { // already changed from default? - strcpy(PC.error, "class already have a name '"); - strncat(PC.error, PC.cclass->name().cstr(), 100); - strcat(PC.error, "'"); - YYERROR; - } - if(strings_code->size()==1*2) { + if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { // new class' name - const String *name=LA2S(strings_code); + const String& name=LA2S(*strings_code)->trim(String::TRIM_END); // creating the class - PC.cclass=NEW VClass(POOL); - PC.cclass->set_name(*name); - // append to request's classes - PC.request->classes().put(*name, PC.cclass); + VStateless_class* cclass=new VClass; + PC.cclass_new=cclass; + PC.cclass_new->set_name(name); } 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(int i=0; isize(); i+=2) - PC.request->use_file(PC.request->main_class, *LA2S(strings_code, i)); + for(size_t i=0; icount(); i+=OPERATIONS_PER_OPVALUE) + PC.request.use_file(PC.request.main_class, LA2S(*strings_code, i)->trim(String::TRIM_END), PC.request.get_used_filename(PC.file_no)); } else if(command==BASE_NAME) { + if(PC.append){ + strcpy(PC.error, "can't set base while appending methods to class '"); + strncat(PC.error, PC.cclass->name().cstr(), MAX_STRING/2); + strcat(PC.error, "'"); + YYERROR; + } + PC.class_add(); if(PC.cclass->base_class()) { // already changed from default? strcpy(PC.error, "class already have a base '"); - strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100); + strncat(PC.error, PC.cclass->base_class()->name().cstr(), MAX_STRING/2); strcat(PC.error, "'"); YYERROR; } - if(strings_code->size()==1*2) { - const String& base_name=*LA2S(strings_code); - Value *vbase_class=static_cast( - PC.request->classes().get(base_name)); - VStateless_class *base_class=vbase_class?vbase_class->get_class():0; - if(!base_class) { + if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) { + const String& base_name=LA2S(*strings_code)->trim(String::TRIM_END); + if(Value* base_class_value=PC.request.get_class(base_name)) { + // @CLASS == @BASE sanity check + if(VStateless_class *base_class=base_class_value->get_class()) { + if(PC.cclass==base_class) { + strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME); + YYERROR; + } + PC.cclass->get_class()->set_base(base_class); + } else { // they asked to derive from a class without methods ['env' & co] + strcpy(PC.error, base_name.cstr()); + strcat(PC.error, ": you can not derive from this class in @"BASE_NAME); + YYERROR; + } + } else { strcpy(PC.error, base_name.cstr()); strcat(PC.error, ": undefined class in @"BASE_NAME); YYERROR; } - // @CLASS == @BASE sanity check - if(PC.cclass==base_class) { - strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME); - YYERROR; - } - PC.cclass->set_base(base_class); } else { strcpy(PC.error, "@"BASE_NAME" must contain sole name"); YYERROR; } + } else if(command==OPTIONS_CONTROL_METHOD_NAME) { + for(size_t i=0; icount(); i+=OPERATIONS_PER_OPVALUE) { + const String& option=LA2S(*strings_code, i)->trim(String::TRIM_END); + if(option==OPTION_ALL_VARS_LOCAL_NAME){ + PC.set_all_vars_local(); + } else if(option==OPTION_PARTIAL_CLASS){ + if(PC.cclass_new){ + if(VStateless_class* existed=PC.get_existed_class(PC.cclass_new)){ + if(!PC.reuse_existed_class(existed)){ + strcpy(PC.error, "can't append methods to '"); + strncat(PC.error, PC.cclass_new->name().cstr(), MAX_STRING/2); + strcat(PC.error, "' - the class wasn't marked as partial"); + YYERROR; + } + } else { + // marks the new class as partial. we will be able to add methods here later. + PC.cclass_new->set_partial(); + } + } else { + strcpy(PC.error, "'"OPTION_PARTIAL_CLASS"' option should be used straight after @"CLASS_NAME); + YYERROR; + } + } else if(option==method_call_type_static){ + PC.set_methods_call_type(Method::CT_STATIC); + } else if(option==method_call_type_dynamic){ + PC.set_methods_call_type(Method::CT_DYNAMIC); + } else { + strcpy(PC.error, "'"); + strncat(PC.error, option.cstr(), MAX_STRING/2); + strcat(PC.error, "' invalid option. valid options are " + "'"OPTION_PARTIAL_CLASS"', '"OPTION_ALL_VARS_LOCAL_NAME"'" + ", '"METHOD_CALL_TYPE_STATIC"' and '"METHOD_CALL_TYPE_DYNAMIC"'" + ); + YYERROR; + } + } } else { strcpy(PC.error, "'"); strncat(PC.error, command.cstr(), MAX_STRING/2); strcat(PC.error, "' invalid special name. valid names are " - "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'"); + "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"', '"BASE_NAME"' and '"OPTIONS_CONTROL_METHOD_NAME"'."); YYERROR; } -; - break;} -case 12: -#line 200 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 16: -#line 205 "compile.y" -{ - const String *name=LA2S(yyvsp[-5]); - - YYSTYPE params_names_code=yyvsp[-4]; - Array *params_names=0; - if(int size=params_names_code->size()) { - params_names=NEW Array(POOL); - for(int i=0; isize()) { - locals_names=NEW Array(POOL); - for(int i=0; icount()) { + params_names=new ArrayString; + for(int i=0; icount()) { + locals_names=new ArrayString; + for(int i=0; iis_vars_local()) + all_vars_local=true; + + Method* method=new Method( + //name, + GetMethodCallType(PC, *yyvsp[-4]), 0, 0/*min,max numbered_params_count*/, params_names, locals_names, - yyvsp[0], 0); - PC.cclass->add_method(*name, method); -; - break;} -case 19: -#line 234 "compile.y" -{yyval=yyvsp[-1]; - break;} -case 23: -#line 236 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ; - break;} -case 29: -#line 244 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 35: -#line 250 "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 36: -#line 257 "compile.y" -{ yyval=yyvsp[0] ; - break;} -case 39: -#line 259 "compile.y" -{ yyval=yyvsp[-1] ; - break;} -case 42: -#line 263 "compile.y" -{ - yyval=N(POOL); - Array *diving_code=yyvsp[0]; - const String *first_name=LA2S(diving_code); - // self.xxx... -> xxx... - // OP_VALUE+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->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); + 0/*to be filled later in next {} */, 0, all_vars_local); + + *reinterpret_cast(&yyval)=method; +;} + break; + + case 18: +#line 296 "compile.y" + { + Method* method=reinterpret_cast(yyvsp[-1]); + // fill in the code + method->parser_code=yyvsp[0]; + + // register in class + const String& name=*LA2S(*yyvsp[-6]); + PC.cclass->set_method(PC.alias_method(name), method); +;} + break; + + case 21: +#line 307 "compile.y" + {yyval=yyvsp[-1];;} + break; + + case 25: +#line 309 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); ;} + break; + + case 31: +#line 317 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 37: +#line 323 "compile.y" + { + yyval=N(); + YYSTYPE code=yyvsp[0]; + size_t count=code->count(); + +#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT + if( + count!=3 + || !maybe_change_first_opcode(*code, OP::OP_VALUE__GET_ELEMENT, /*=>*/OP::OP_VALUE__GET_ELEMENT__WRITE) + ) +#endif + +#ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT + if( + count!=3 + || !maybe_change_first_opcode(*code, OP::OP_WITH_SELF__VALUE__GET_ELEMENT, /*=>*/OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE) + ) +#endif + +#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT + if( + count!=5 + || !maybe_change_first_opcode(*code, OP::OP_GET_OBJECT_ELEMENT, /*=>*/OP::OP_GET_OBJECT_ELEMENT__WRITE) + ) +#endif + +#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT + if( + count!=5 + || !maybe_change_first_opcode(*code, OP::OP_GET_OBJECT_VAR_ELEMENT, /*=>*/OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE) + ) +#endif + { + changetail_or_append(*code, + OP::OP_GET_ELEMENT, false, /*=>*/OP::OP_GET_ELEMENT__WRITE, + /*or */OP::OP_WRITE_VALUE + ); /* value=pop; wcontext.write(value) */ + } + + P(*yyval, *code); +;} + break; + + case 38: +#line 364 "compile.y" + { yyval=yyvsp[0]; ;} + break; + + case 41: +#line 366 "compile.y" + { yyval=yyvsp[-1]; ;} + break; + + case 44: +#line 370 "compile.y" + { + yyval=N(); + YYSTYPE diving_code=yyvsp[0]; + size_t count=diving_code->count(); + + if(maybe_make_self(*yyval, *diving_code, count)) { + // $self. + } else + +#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT + if(maybe_make_get_object_element(*yyval, *diving_code, count)){ + // optimization for $object.field + ^object.method[ + } else +#endif + +#ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT + if(maybe_make_get_object_var_element(*yyval, *diving_code, count)){ + // optimization for $object.$var + } else +#endif + +#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT + if( + count>=4 + && (*diving_code)[0].code==OP::OP_VALUE + && (*diving_code)[3].code==OP::OP_GET_ELEMENT + ){ + // optimization + O(*yyval, + (PC.in_call_value && count==4) + ? OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR // ^object[ : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT_OR_OPERATOR+origin+string + : OP::OP_VALUE__GET_ELEMENT // $object : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT+origin+string + ); + P(*yyval, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value + if(count>4) + P(*yyval, *diving_code, 4); // copy tail } else { - O(yyval, OP_WITH_READ); /* stack: starting context */ + O(*yyval, OP::OP_WITH_READ); /* stack: starting context */ + P(*yyval, *diving_code); + } +#else + { + O(*yyval, OP::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->size()==3) - diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR); - P(yyval, diving_code); + // ^if OP_ELEMENT => ^if OP_ELEMENT_OR_OPERATOR + // optimized OP_VALUE+origin+string+OP_GET_ELEMENT. => OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR. + if(PC.in_call_value && count==4) + diving_code->put(count-1, OP::OP_GET_ELEMENT_OR_OPERATOR); + P(*yyval, *diving_code); } +#endif /* diving code; stack: current context */ -; - break;} -case 43: -#line 285 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 45: -#line 286 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 46: -#line 290 "compile.y" -{ - yyval=yyvsp[-1]; /* stack: context,name */ - P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */ -; - break;} -case 50: -#line 298 "compile.y" -{ - yyval=N(POOL); - Array *diving_code=yyvsp[0]; - const String *first_name=LA2S(diving_code); - // $self.xxx... -> $xxx... - // OP_VALUE+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->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/); - } else { - O(yyval, OP_WITH_ROOT); /* stack: starting context */ - P(yyval, diving_code); +;} + break; + + case 45: +#line 423 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 47: +#line 424 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 48: +#line 428 "compile.y" + { + yyval=N(); +#ifdef OPTIMIZE_BYTECODE_CONSTRUCT + if(maybe_optimize_construct(*yyval, *yyvsp[-1], *yyvsp[0])){ + // $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr) + } else +#endif + { + P(*yyval, *yyvsp[-1]); /* stack: context,name */ + P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */ + } +;} + break; + + case 52: +#line 444 "compile.y" + { + yyval=N(); + YYSTYPE diving_code=yyvsp[0]; + size_t count=diving_code->count(); + + if(maybe_make_self(*yyval, *diving_code, count)) { + // $self. + } else +#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT + if( + count>=4 + && (*diving_code)[0].code==OP::OP_VALUE + && (*diving_code)[3].code==OP::OP_GET_ELEMENT + ){ + O(*yyval, OP::OP_WITH_ROOT__VALUE__GET_ELEMENT); + P(*yyval, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value + if(count>4) + P(*yyval, *diving_code, 4); // tail + } else +#endif + { + O(*yyval, OP::OP_WITH_ROOT); /* stack: starting context */ + P(*yyval, *diving_code); } /* diving code; stack: current context */ -; - break;} -case 51: -#line 315 "compile.y" -{ - yyval=N(POOL); - O(yyval, OP_WITH_WRITE); /* stack: starting context */ - P(yyval, yyvsp[0]); /* diving code; stack: context,name */ -; - break;} -case 52: -#line 320 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 56: -#line 327 "compile.y" -{ +;} + break; + + case 53: +#line 470 "compile.y" + { + yyval=N(); + O(*yyval, OP::OP_WITH_WRITE); /* stack: starting context */ + P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */ +;} + break; + + case 54: +#line 475 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 58: +#line 482 "compile.y" + { + // allow $result_or_other_variable[ letters here any time ] + *reinterpret_cast(&yyval)=PC.explicit_result; PC.explicit_result=false; +;} + break; + + case 59: +#line 485 "compile.y" + { + PC.explicit_result=*reinterpret_cast(&yyvsp[-1]); +;} + break; + + case 60: +#line 487 "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 57: -#line 333 "compile.y" -{ - yyval=N(POOL); - O(yyval, OP_PREPARE_TO_EXPRESSION); + yyval=yyvsp[-2]; // stack: context, name, value + O(*yyval, OP::OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */ +;} + break; + + case 61: +#line 493 "compile.y" + { + yyval=N(); + O(*yyval, OP::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 58: -#line 341 "compile.y" -{ + P(*yyval, *yyvsp[-1]); // stack: context, name, value + O(*yyval, OP::OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */ +;} + break; + + case 62: +#line 501 "compile.y" + { // stack: context, name - yyval=N(POOL); - OA(yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */ -; - break;} -case 62: -#line 352 "compile.y" -{ - yyval=N(POOL); - OA(yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */ + yyval=N(); + OA(*yyval, OP::OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */ +;} + break; + + case 66: +#line 512 "compile.y" + { + yyval=N(); + OA(*yyval, OP::OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */ /* some code that writes to that context */ /* context=pop; stack: context.value() */ -; - break;} -case 65: -#line 359 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 66: -#line 363 "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 67: -#line 369 "compile.y" -{ +;} + break; + + case 69: +#line 519 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 70: +#line 523 "compile.y" + { +#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR + if((*yyvsp[0]).count()) +#endif + { + yyval=yyvsp[0]; /* stack: value */ + if(!maybe_change_first_opcode(*yyval, OP::OP_CONSTRUCT_OBJECT, /*=>*/OP::OP_CONSTRUCT_OBJECT__WRITE)) + changetail_or_append(*yyval, + OP::OP_CALL, true, /*=>*/ OP::OP_CALL__WRITE, + /*or */OP::OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */ + } +;} + break; + + case 71: +#line 535 "compile.y" + { PC.in_call_value=true; - ; - break;} -case 68: -#line 372 "compile.y" -{ + ;} + break; + + case 72: +#line 538 "compile.y" + { PC.in_call_value=false; - ; - break;} -case 69: -#line 375 "compile.y" -{ /* ^field.$method{vasya} */ - yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */ - - YYSTYPE params_code=yyvsp[-1]; - if(params_code->size()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM] - if(Value *value=LA2V(params_code)) // it is OP_VALUE + 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 72: -#line 390 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 76: -#line 396 "compile.y" -{yyval=yyvsp[-1]; - break;} -case 77: -#line 397 "compile.y" -{yyval=yyvsp[-1]; - break;} -case 78: -#line 398 "compile.y" -{yyval=yyvsp[-1]; - break;} -case 80: -#line 401 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ; - break;} -case 82: -#line 405 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ; - break;} -case 84: -#line 409 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ; - break;} -case 85: -#line 411 "compile.y" -{ + ;} + break; + + case 73: +#line 541 "compile.y" + { /* ^field.$method{vasya} */ +#ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR +#ifdef OPTIMIZE_BYTECODE_GET_ELEMENT + const String* operator_name=LA2S(*yyvsp[-3], 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR); +#else + const String* operator_name=LA2S(*yyvsp[-3], 1); +#endif + if(operator_name && *operator_name==REM_OPERATOR_NAME){ + yyval=N(); + } else +#endif + { + YYSTYPE params_code=yyvsp[-1]; + if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void] + if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value? + if(value->is_void()) // value is VVoid? + params_code=0; // ^zzz[] case. don't append lone empty param. + } + /* stack: context, method_junction */ + + YYSTYPE var_code=yyvsp[-3]; + if( + var_code->count()==8 + && (*var_code)[0].code==OP::OP_VALUE__GET_CLASS + && (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT + && (*var_code)[4].code==OP::OP_VALUE + && (*var_code)[7].code==OP::OP_GET_ELEMENT + ){ + yyval=N(); + O(*yyval, OP::OP_CONSTRUCT_OBJECT); + P(*yyval, *var_code, 1/*offset*/, 2/*limit*/); // class name + P(*yyval, *var_code, 5/*offset*/, 2/*limit*/); // constructor name + OA(*yyval, params_code); + } else + { + yyval=var_code; /* with_xxx,diving code; stack: context,method_junction */ + OA(*yyval, OP::OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value + } + } +;} + break; + + case 76: +#line 584 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 80: +#line 590 "compile.y" + { + // allow ^call[ letters here any time ] + *reinterpret_cast(&yyval)=PC.explicit_result; PC.explicit_result=false; +;} + break; + + case 81: +#line 593 "compile.y" + { + PC.explicit_result=*reinterpret_cast(&yyvsp[-1]); +;} + break; + + case 82: +#line 595 "compile.y" + {yyval=yyvsp[-2];;} + break; + + case 83: +#line 596 "compile.y" + {yyval=yyvsp[-1];;} + break; + + case 84: +#line 597 "compile.y" + {yyval=yyvsp[-1];;} + break; + + case 86: +#line 600 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); ;} + break; + + case 88: +#line 604 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); ;} + break; + + case 90: +#line 608 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); ;} + break; + + case 91: +#line 610 "compile.y" + { yyval=yyvsp[0]; - O(yyval, OP_STORE_PARAM); -; - break;} -case 86: -#line 415 "compile.y" -{ - yyval=N(POOL); - OA(yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]); -; - break;} -case 87: -#line 419 "compile.y" -{ - yyval=N(POOL); - OA(yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]); -; - break;} -case 91: -#line 428 "compile.y" -{ - yyval=N(POOL); - O(yyval, OP_PREPARE_TO_EXPRESSION); - P(yyval, yyvsp[0]); - O(yyval, OP_WRITE_EXPR_RESULT); -; - break;} -case 93: -#line 437 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 95: -#line 439 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 97: -#line 441 "compile.y" -{ +;} + break; + + case 92: +#line 613 "compile.y" + { + YYSTYPE expr_code=yyvsp[0]; + if(expr_code->count()==3 + && (*expr_code)[0].code==OP::OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP::OP_VALUE+origin+Double]. no evaluating + yyval=expr_code; + } else { + YYSTYPE code=N(); + O(*code, OP::OP_PREPARE_TO_EXPRESSION); + P(*code, *expr_code); + O(*code, OP::OP_WRITE_EXPR_RESULT); + yyval=N(); + OA(*yyval, OP::OP_EXPR_CODE__STORE_PARAM, code); + } +;} + break; + + case 93: +#line 627 "compile.y" + { + yyval=N(); + OA(*yyval, OP::OP_CURLY_CODE__STORE_PARAM, yyvsp[0]); +;} + break; + + case 98: +#line 639 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 100: +#line 641 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 102: +#line 643 "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 98: -#line 449 "compile.y" -{ + O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ +;} + break; + + case 103: +#line 651 "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 104: -#line 462 "compile.y" -{ + O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */ +;} + break; + + case 109: +#line 664 "compile.y" + { yyval=yyvsp[0]; - O(yyval, OP_GET_ELEMENT); -; - break;} -case 105: -#line 466 "compile.y" -{ - Array *code; + O(*yyval, OP::OP_GET_ELEMENT); +;} + break; + + case 110: +#line 668 "compile.y" + { + YYSTYPE code; { - change_string_literal_to_write_string_literal(code=yyvsp[-1]); - P(code, yyvsp[0]); + change_string_literal_to_write_string_literal(*(code=yyvsp[-1])); + P(*code, *yyvsp[0]); } - yyval=N(POOL); - OA(yyval, OP_STRING_POOL, code); -; - break;} -case 106: -#line 475 "compile.y" -{ - yyval=N(POOL); - OA(yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */ + yyval=N(); + OA(*yyval, OP::OP_STRING_POOL, code); +;} + break; + + case 111: +#line 677 "compile.y" + { + // allow $result_or_other_variable[ letters here any time ] + *reinterpret_cast(&yyval)=PC.explicit_result; PC.explicit_result=false; +;} + break; + + case 112: +#line 680 "compile.y" + { + PC.explicit_result=*reinterpret_cast(&yyvsp[-1]); +;} + break; + + case 113: +#line 682 "compile.y" + { + yyval=N(); + OA(*yyval, OP::OP_OBJECT_POOL, yyvsp[-2]); /* stack: empty write context */ /* some code that writes to that context */ /* context=pop; stack: context.value() */ -; - break;} -case 107: -#line 481 "compile.y" -{ - yyval=N(POOL); - O(yyval, OP_WITH_READ); - P(yyval, yyvsp[0]); -; - break;} -case 109: -#line 486 "compile.y" -{ yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ; - break;} -case 110: -#line 487 "compile.y" -{ +;} + break; + + case 114: +#line 688 "compile.y" + { + yyval=N(); + O(*yyval, OP::OP_WITH_READ); + P(*yyval, *yyvsp[0]); +;} + break; + + case 116: +#line 693 "compile.y" + { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;} + break; + + case 117: +#line 694 "compile.y" + { yyval=yyvsp[0]; - O(yyval, OP_GET_ELEMENT__WRITE); -; - break;} -case 113: -#line 496 "compile.y" -{ + O(*yyval, OP::OP_GET_ELEMENT__WRITE); +;} + break; + + case 120: +#line 703 "compile.y" + { yyval=yyvsp[-1]; // stack: class name string - if(*LA2S(yyval) == BASE_NAME) { // pseude BASE class - if(VStateless_class *base=PC.cclass->base_class()) { - change_string_literal_value(yyval, base->name()); + if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class + if(VStateless_class* base=PC.cclass->base_class()) { + change_string_literal_value(*yyval, base->name()); } else { strcpy(PC.error, "no base class declared"); YYERROR; } } - O(yyval, OP_GET_CLASS); -; - break;} -case 114: -#line 508 "compile.y" -{ + // optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string + maybe_change_first_opcode(*yyval, OP::OP_VALUE, OP::OP_VALUE__GET_CLASS); +;} + break; + + case 121: +#line 716 "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 115: -#line 520 "compile.y" -{ - // see OP_PREPARE_TO_EXPRESSION!! - if((yyval=yyvsp[0])->size()==2) // only one string literal in there? - change_string_literal_to_double_literal(yyval); // make that string literal Double -; - break;} -case 119: -#line 529 "compile.y" -{ yyval = yyvsp[-1]; ; - break;} -case 120: -#line 530 "compile.y" -{ yyval = yyvsp[-1]; ; - break;} -case 121: -#line 531 "compile.y" -{ yyval = yyvsp[-1]; ; - break;} -case 122: -#line 533 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_NEG) ; - break;} -case 123: -#line 534 "compile.y" -{ yyval=yyvsp[0] ; - break;} -case 124: -#line 535 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_INV) ; - break;} -case 125: -#line 536 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_NOT) ; - break;} -case 126: -#line 537 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_DEF) ; - break;} -case 127: -#line 538 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_IN) ; - break;} -case 128: -#line 539 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_FEXISTS) ; - break;} -case 129: -#line 540 "compile.y" -{ yyval=yyvsp[0]; O(yyval, OP_DEXISTS) ; - break;} -case 130: -#line 542 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_SUB) ; - break;} -case 131: -#line 543 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_ADD) ; - break;} -case 132: -#line 544 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_MUL) ; - break;} -case 133: -#line 545 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_DIV) ; - break;} -case 134: -#line 546 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_MOD) ; - break;} -case 135: -#line 547 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_INTDIV) ; - break;} -case 136: -#line 548 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_SL) ; - break;} -case 137: -#line 549 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_SR) ; - break;} -case 138: -#line 550 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_AND) ; - break;} -case 139: -#line 551 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_OR) ; - break;} -case 140: -#line 552 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_BIN_XOR) ; - break;} -case 141: -#line 553 "compile.y" -{ yyval=yyvsp[-2]; OA(yyval, OP_NESTED_CODE, yyvsp[0]); O(yyval, OP_LOG_AND) ; - break;} -case 142: -#line 554 "compile.y" -{ yyval=yyvsp[-2]; OA(yyval, OP_NESTED_CODE, yyvsp[0]); O(yyval, OP_LOG_OR) ; - break;} -case 143: -#line 555 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_LOG_XOR) ; - break;} -case 144: -#line 556 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_LT) ; - break;} -case 145: -#line 557 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_GT) ; - break;} -case 146: -#line 558 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_LE) ; - break;} -case 147: -#line 559 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_GE) ; - break;} -case 148: -#line 560 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_EQ) ; - break;} -case 149: -#line 561 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_NUM_NE) ; - break;} -case 150: -#line 562 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_LT) ; - break;} -case 151: -#line 563 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_GT) ; - break;} -case 152: -#line 564 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_LE) ; - break;} -case 153: -#line 565 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_GE) ; - break;} -case 154: -#line 566 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_EQ) ; - break;} -case 155: -#line 567 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_STR_NE) ; - break;} -case 156: -#line 568 "compile.y" -{ yyval=yyvsp[-2]; P(yyval, yyvsp[0]); O(yyval, OP_IS) ; - break;} -case 157: -#line 571 "compile.y" -{ - yyval=N(POOL); - OA(yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */ + O(*yyval, OP::OP_PREPARE_TO_CONSTRUCT_OBJECT); +;} + break; + + case 128: +#line 735 "compile.y" + { yyval = yyvsp[-1]; ;} + break; + + case 129: +#line 736 "compile.y" + { yyval = yyvsp[-1]; ;} + break; + + case 130: +#line 737 "compile.y" + { yyval = yyvsp[-1]; ;} + break; + + case 131: +#line 739 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_NEG); ;} + break; + + case 132: +#line 740 "compile.y" + { yyval=yyvsp[0]; ;} + break; + + case 133: +#line 741 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_INV); ;} + break; + + case 134: +#line 742 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_NOT); ;} + break; + + case 135: +#line 743 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_DEF); ;} + break; + + case 136: +#line 744 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_IN); ;} + break; + + case 137: +#line 745 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_FEXISTS); ;} + break; + + case 138: +#line 746 "compile.y" + { yyval=yyvsp[0]; O(*yyval, OP::OP_DEXISTS); ;} + break; + + case 139: +#line 748 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_SUB); ;} + break; + + case 140: +#line 749 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_ADD); ;} + break; + + case 141: +#line 750 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_MUL); ;} + break; + + case 142: +#line 751 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_DIV); ;} + break; + + case 143: +#line 752 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_MOD); ;} + break; + + case 144: +#line 753 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_INTDIV); ;} + break; + + case 145: +#line 754 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_BIN_SL); ;} + break; + + case 146: +#line 755 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_BIN_SR); ;} + break; + + case 147: +#line 756 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_BIN_AND); ;} + break; + + case 148: +#line 757 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_BIN_OR); ;} + break; + + case 149: +#line 758 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_BIN_XOR); ;} + break; + + case 150: +#line 759 "compile.y" + { yyval=yyvsp[-2]; OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP::OP_LOG_AND); ;} + break; + + case 151: +#line 760 "compile.y" + { yyval=yyvsp[-2]; OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]); O(*yyval, OP::OP_LOG_OR); ;} + break; + + case 152: +#line 761 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_LOG_XOR); ;} + break; + + case 153: +#line 762 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_LT); ;} + break; + + case 154: +#line 763 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_GT); ;} + break; + + case 155: +#line 764 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_LE); ;} + break; + + case 156: +#line 765 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_GE); ;} + break; + + case 157: +#line 766 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_EQ); ;} + break; + + case 158: +#line 767 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_NUM_NE); ;} + break; + + case 159: +#line 768 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_LT); ;} + break; + + case 160: +#line 769 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_GT); ;} + break; + + case 161: +#line 770 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_LE); ;} + break; + + case 162: +#line 771 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_GE); ;} + break; + + case 163: +#line 772 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_EQ); ;} + break; + + case 164: +#line 773 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_STR_NE); ;} + break; + + case 165: +#line 774 "compile.y" + { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]); O(*yyval, OP::OP_IS); ;} + break; + + case 166: +#line 777 "compile.y" + { + // optimized OP_STRING => OP_VALUE for doubles + maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0])); +;} + break; + + case 167: +#line 782 "compile.y" + { +#ifdef OPTIMIZE_BYTECODE_STRING_POOL + // it brakes ^if(" 09 "){...} + YYSTYPE code=yyvsp[0]; + yyval=N(); + if(code->count()==3 && maybe_change_first_opcode(*code, OP::OP_STRING__WRITE, OP::OP_VALUE)){ + // optimized OP_STRING__WRITE+origin+value => OP_VALUE+origin+value without starting OP_STRING_POOL + P(*yyval, *code); + } else { + OA(*yyval, OP::OP_STRING_POOL, code); /* stack: empty write context */ + } +#else + yyval=N(); + OA(*yyval, OP::OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */ +#endif /* some code that writes to that context */ /* context=pop; stack: context.get_string() */ -; - break;} -case 158: -#line 580 "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 159: -#line 585 "compile.y" -{ yyval=VL(NEW VVoid(POOL)) ; - break;} -case 160: -#line 586 "compile.y" -{ yyval=N(POOL) ; - break;} -} - /* the action file gets copied in in place of this dollarsign */ -#line 543 "/usr/share/bison.simple" +;} + break; + + case 168: +#line 803 "compile.y" + { + // optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE + change_string_literal_to_write_string_literal(*(yyval=yyvsp[0])); +;} + break; + + case 169: +#line 808 "compile.y" + { yyval=VL(/*we know that we will not change it*/const_cast(&vvoid), 0, 0, 0); ;} + break; + + case 170: +#line 809 "compile.y" + { yyval = VL(/*we know that we will not change it*/const_cast(&vtrue), 0, 0, 0); ;} + break; + + case 171: +#line 810 "compile.y" + { yyval = VL(/*we know that we will not change it*/const_cast(&vfalse), 0, 0, 0); ;} + break; + + case 172: +#line 812 "compile.y" + { yyval=N(); ;} + break; + + + } + +/* Line 1010 of yacc.c. */ +#line 2406 "compile.tab.C" yyvsp -= yylen; yyssp -= yylen; -#ifdef YYLSP_NEEDED - yylsp -= yylen; -#endif -#if YYDEBUG != 0 - if (yydebug) - { - short *ssp1 = yyss - 1; - fprintf (stderr, "state stack now"); - while (ssp1 != yyssp) - fprintf (stderr, " %d", *++ssp1); - fprintf (stderr, "\n"); - } -#endif + + YY_STACK_PRINT (yyss, yyssp); *++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 - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTBASE]; + yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; -yyerrlab: /* here on detecting error */ - if (! yyerrstatus) - /* If not already recovering from an error, report this error. */ +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) { ++yynerrs; - -#ifdef YYERROR_VERBOSE +#if YYERROR_VERBOSE yyn = yypact[yystate]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { - 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) + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) { - strcpy(msg, "parse error"); + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); - if (count < 5) + if (yycount < 5) { - count = 0; - for (x = (yyn < 0 ? -yyn : 0); - x < (sizeof(yytname) / sizeof(char *)); x++) - if (yycheck[x + yyn] == x) + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) { - strcat(msg, count == 0 ? ", expecting `" : " or `"); - strcat(msg, yytname[x]); - strcat(msg, "'"); - count++; + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; } } - yyerror(msg); - free(msg); + yyerror (yymsg); + YYSTACK_FREE (yymsg); } else - yyerror ("parse error; also virtual memory exceeded"); + yyerror ("syntax error; also virtual memory exhausted"); } else #endif /* YYERROR_VERBOSE */ - yyerror("parse error"); + yyerror ("syntax error"); } - goto yyerrlab1; -yyerrlab1: /* here on error raised explicitly by an action */ + if (yyerrstatus == 3) { - /* if just tried and failed to reuse lookahead token after an error, discard it. */ - - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); -#endif + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[*yyssp], yyvsp); + } + } + else + { + YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); + yydestruct (yytoken, &yylval); + yychar = YYEMPTY; - yychar = YYEMPTY; + } } - /* Else will try to reuse lookahead token - after shifting the error token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; - goto yyerrhandle; -yyerrdefault: /* current state does not do anything special for the error token. */ +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: -#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; +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; #endif -yyerrpop: /* pop the current state because it cannot handle the error token */ - - if (yyssp == yyss) YYABORT; - yyvsp--; - yystate = *--yyssp; -#ifdef YYLSP_NEEDED - yylsp--; -#endif + yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; -#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: +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; + 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; + } + } - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); } - else if (yyn == 0) - goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Shifting error token, "); -#endif + YYDPRINTF ((stderr, "Shifting error token, ")); *++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; - yyabortlab: - /* YYABORT comes here. */ - if (yyfree_stacks) - { - free (yyss); - free (yyvs); -#ifdef YYLSP_NEEDED - free (yyls); +/*-------------------------------------. +| 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); #endif - } - return 1; + return yyresult; } -#line 588 "compile.y" + + +#line 814 "compile.y" #endif @@ -1907,55 +2647,66 @@ yyerrhandle: 4:[^({]=pop */ -static int yylex(YYSTYPE *lvalp, void *pc) { - #define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp] +inline void ungetc(Parse_control& pc, uint last_line_end_col) { + pc.source--; + if(pc.pos.col==0) { + --pc.pos.line; pc.pos.col=last_line_end_col; + } else + --pc.pos.col; + +} +static int yylex(YYSTYPE *lvalp, void *apc) { + register Parse_control& pc=*static_cast(apc); + + #define lexical_brackets_nestage pc.brackets_nestages[pc.ls_sp] #define RC {result=c; goto break2; } - register int c; - int result; + register int c; + int result; - if(PC.pending_state) { - result=PC.pending_state; - PC.pending_state=0; + if(pc.pending_state) { + result=pc.pending_state; + pc.pending_state=0; return result; } - const char *begin=PC.source; + const char *begin=pc.source; + Pos begin_pos=pc.pos; const char *end; - int begin_line=PC.line; int skip_analized=0; while(true) { - c=*(end=(PC.source++)); -// fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp); + c=*(end=(pc.source++)); +// fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp); - if(c=='\n') { - PC.line++; - PC.col=0; - } else - PC.col++; + if(c=='\n') + pc.pos_next_line(); + else + pc.pos_next_c(c); +// fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col); - if(c=='@' && PC.col==0+1) { - if(PC.ls==LS_DEF_SPECIAL_BODY) { + if(pc.pos.col==0+1 && c=='@') { + if(pc.ls==LS_DEF_SPECIAL_BODY) { // @SPECIAL // ... // @APPEND_CLEAN(begin, end-begin, PC.file, begin_line); + pc.string.append_strdup_know_length(begin, end-begin); } // reset piece 'begin' position & line - begin=PC.source; // ->punctuation - begin_line=PC.line; + begin=pc.source; // ->punctuation + begin_pos=pc.pos; // skip over _ after ^ - PC.source++; PC.col++; + pc.source++; pc.pos.col++; // skip analysis = forced literal continue; // converting ^#HH into char(hex(HH)) case '#': if(end!=begin) { + if(!pc.string_start) + pc.string_start=begin_pos; // append piece till ^ - PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line); + pc.string.append_strdup_know_length(begin, end-begin); } // #HH ? - if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) { - char *hex=(char *)POOL.malloc(1); - hex[0]= - hex_value[(unsigned char)PC.source[1]]*0x10+ - hex_value[(unsigned char)PC.source[2]]; - if(hex[0]==0) { + if(pc.source[1] && isxdigit(pc.source[1]) && pc.source[2] && isxdigit(pc.source[2])) { + char c=(char)( + hex_value[(unsigned char)pc.source[1]]*0x10+ + hex_value[(unsigned char)pc.source[2]]); + if(c==0) { result=BAD_HEX_LITERAL; goto break2; // wrong hex value[no ^#00 chars allowed]: bail out } // append char(hex(HH)) - PC.string->APPEND_CLEAN(hex, 1, PC.file, begin_line); + pc.string.append(c); // skip over ^#HH - PC.source+=3; - PC.col+=3; + pc.source+=3; + pc.pos.col+=3; // reset piece 'begin' position & line - begin=PC.source; // ->after ^#HH - begin_line=PC.line; + begin=pc.source; // ->after ^#HH + begin_pos=pc.pos; // skip analysis = forced literal continue; } - break; + // just escaped char + // reset piece 'begin' position & line + begin=pc.source; + begin_pos=pc.pos; + // skip over _ after ^ + pc.source++; pc.pos.col++; + // skip analysis = forced literal + continue; } break; } } // #comment start skipping - if(c=='#' && PC.col==1) { + if(c=='#' && pc.pos.col==1) { if(end!=begin) { + if(!pc.string_start) + pc.string_start=begin_pos; // append piece till # - PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line); + pc.string.append_strdup_know_length(begin, end-begin); } // fall into COMMENT lexical state [wait for \n] - push_LS(PC, LS_USER_COMMENT); + push_LS(pc, LS_USER_COMMENT); continue; } - switch(PC.ls) { + switch(pc.ls) { // USER'S = NOT OURS case LS_USER: - case LS_NAME_SQUARE_PART: // name.[here].xxx - if(PC.trim_bof) + case LS_NAME_SQUARE_PART: // name.[here].xxx + if(pc.trim_bof) switch(c) { case '\n': case ' ': case '\t': - begin=PC.source; - begin_line=PC.line; + begin=pc.source; + begin_pos=pc.pos; continue; // skip it default: - PC.trim_bof=false; + pc.trim_bof=false; } switch(c) { case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case ']': - if(PC.ls==LS_NAME_SQUARE_PART) + if(pc.ls==LS_NAME_SQUARE_PART) if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?> - pop_LS(PC); // $name.[co<]>de<]!> + pop_LS(pc); // $name.[co<]>de<]!> RC; } break; case '[': // $name.[co<[>de] - if(PC.ls==LS_NAME_SQUARE_PART) + if(pc.ls==LS_NAME_SQUARE_PART) lexical_brackets_nestage++; break; } + if(pc.explicit_result && c) + switch(c) { + case '\n': case ' ': case '\t': + begin=pc.source; + begin_pos=pc.pos; + continue; // skip it + default: + result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE; + goto break2; + } break; // #COMMENT case LS_USER_COMMENT: if(c=='\n') { // skip comment - begin=PC.source; - begin_line=PC.line; + begin=pc.source; + begin_pos=pc.pos; - pop_LS(PC); + pop_LS(pc); continue; } break; @@ -2082,17 +2855,17 @@ default: case '"': case '\'': if( - PC.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' || - PC.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') { - pop_LS(PC); //"abc". | 'abc'. + pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' || + pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') { + pop_LS(pc); //"abc". | 'abc'. RC; } break; case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; } break; @@ -2101,10 +2874,10 @@ default: case LS_DEF_NAME: switch(c) { case '[': - PC.ls=LS_DEF_PARAMS; + pc.ls=LS_DEF_PARAMS; RC; case '\n': - PC.ls=LS_DEF_SPECIAL_BODY; + pc.ls=LS_DEF_SPECIAL_BODY; RC; } break; @@ -2117,10 +2890,10 @@ default: case ';': RC; case ']': - PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT; + pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT; RC; case '\n': // wrong. bailing out - pop_LS(PC); + pop_LS(pc); RC; } break; @@ -2131,17 +2904,17 @@ default: case ';': RC; case ']': - PC.ls=LS_DEF_COMMENT; + pc.ls=LS_DEF_COMMENT; RC; case '\n': // wrong. bailing out - pop_LS(PC); + pop_LS(pc); RC; } break; case LS_DEF_COMMENT: if(c=='\n') { - pop_LS(PC); + pop_LS(pc); RC; } break; @@ -2157,31 +2930,33 @@ default: switch(c) { case ')': if(--lexical_brackets_nestage==0) - if(PC.ls==LS_METHOD_ROUND) // method round param ended - PC.ls=LS_METHOD_AFTER; // look for method end - else // PC.ls==LS_VAR_ROUND // variable constructor ended - pop_LS(PC); // return to normal life + if(pc.ls==LS_METHOD_ROUND) // method round param ended + pc.ls=LS_METHOD_AFTER; // look for method end + else // pc.ls==LS_VAR_ROUND // variable constructor ended + pop_LS(pc); // return to normal life RC; case '#': // comment start skipping if(end!=begin) { + if(!pc.string_start) + pc.string_start=begin_pos; // append piece till # - PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line); + pc.string.append_strdup_know_length(begin, end-begin); } // fall into COMMENT lexical state [wait for \n] - push_LS(PC, LS_EXPRESSION_COMMENT); + push_LS(pc, LS_EXPRESSION_COMMENT); lexical_brackets_nestage=1; continue; case '$': - push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON); + push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case '(': lexical_brackets_nestage++; RC; case '-': - switch(*PC.source) { + switch(*pc.source) { case 'f': // -f skip_analized=1; result=FEXISTS; @@ -2200,17 +2975,17 @@ default: case ';': RC; case '&': case '|': - if(*PC.source==c) { // && || + if(*pc.source==c) { // && || result=c=='&'?LAND:LOR; skip_analized=1; } else result=c; goto break2; case '!': - switch(PC.source[0]) { + switch(pc.source[0]) { case '|': // !| !|| skip_analized=1; - if(PC.source[1]=='|') { + if(pc.source[1]=='|') { skip_analized++; result=LXOR; } else @@ -2224,7 +2999,7 @@ default: RC; case '<': // <<, <=, < - switch(*PC.source) { + switch(*pc.source) { case '<': // <[<] skip_analized=1; result=NSL; break; case '=': // <[=] @@ -2234,7 +3009,7 @@ default: } goto break2; case '>': // >>, >=, > - switch(*PC.source) { + switch(*pc.source) { case '>': // >[>] skip_analized=1; result=NSR; break; case '=': // >[=] @@ -2244,7 +3019,7 @@ default: } goto break2; case '=': // == - switch(*PC.source) { + switch(*pc.source) { case '=': // =[=] skip_analized=1; result=NEQ; break; default: // =[] @@ -2253,15 +3028,15 @@ default: goto break2; case '"': - push_LS(PC, LS_EXPRESSION_STRING_QUOTED); + push_LS(pc, LS_EXPRESSION_STRING_QUOTED); RC; case '\'': - push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED); + push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED); RC; case 'l': case 'g': case 'e': case 'n': if(end==begin) // right after whitespace - if(isspace(PC.source[1])) { - switch(*PC.source) { + if(isspace(pc.source[1])) { + switch(*pc.source) { // case '?': // ok [and bad cases, yacc would bark at them] case 't': // lt gt [et nt] result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR; @@ -2280,8 +3055,8 @@ default: break; case 'i': if(end==begin) // right after whitespace - if(isspace(PC.source[1])) { - switch(PC.source[0]) { + if(isspace(pc.source[1])) { + switch(pc.source[0]) { case 'n': // in skip_analized=1; result=IN; @@ -2295,9 +3070,29 @@ default: break; case 'd': if(end==begin) // right after whitespace - if(PC.source[0]=='e' && PC.source[1]=='f') { // def - skip_analized=2; - result=DEF; + if(pc.source[0]=='e' && pc.source[1]=='f') { // def + switch(pc.source[2]){ + case ' ': case '\t': case '\n': case '"': case '\'': case '^': case '$': // non-quoted string without whitespace after 'def' is not allowed + skip_analized=2; + result=DEF; + goto break2; + } + // error: incorrect char after 'def' + } + break; + case 't': + if(end==begin) // right after whitespace + if(pc.source[0]=='r' && pc.source[1]=='u' && pc.source[2]=='e') { // true + skip_analized=3; + result=LITERAL_TRUE; + goto break2; + } + break; + case 'f': + if(end==begin) // right after whitespace + if(pc.source[0]=='a' && pc.source[1]=='l' && pc.source[2]=='s' && pc.source[3]=='e') { // false + skip_analized=4; + result=LITERAL_FALSE; goto break2; } break; @@ -2309,8 +3104,8 @@ default: // that's a leading|traling space or after-operator-space // ignoring it // reset piece 'begin' position & line - begin=PC.source; // after whitespace char - begin_line=PC.line; + begin=pc.source; // after whitespace char + begin_pos=pc.pos; continue; } break; @@ -2318,17 +3113,17 @@ default: if(c=='(') lexical_brackets_nestage++; - switch(*PC.source) { + switch(*pc.source) { case '\n': case ')': - if(*PC.source==')') + if(*pc.source==')') if(--lexical_brackets_nestage!=0) continue; // skip comment - begin=PC.source; - begin_line=PC.line; + begin=pc.source; + begin_pos=pc.pos; - pop_LS(PC); + pop_LS(pc); continue; } break; @@ -2339,28 +3134,28 @@ default: case LS_EXPRESSION_VAR_NAME_WITH_COLON: case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON: if( - PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON || - PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { + pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON || + pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { // name in expr ends also before switch(c) { // expression minus case '-': // expression integer division case '\\': - pop_LS(PC); - PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } + pop_LS(pc); + pc.ungetc(); result=EON; goto break2; } } if( - PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON || - PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { + pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON || + pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) { // name already has ':', stop before next switch(c) { case ':': - pop_LS(PC); - PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } + pop_LS(pc); + pc.ungetc(); result=EON; goto break2; } @@ -2372,52 +3167,54 @@ default: case ']': case '}': case ')': case '"': case '\'': case '<': case '>': // these stand for HTML brackets AND expression binary ops - case '+': case '*': case '/': case '%': + case '+': case '*': case '/': case '\\': case '%': case '&': case '|': case '=': case '!': // common delimiters case ',': case '?': case '#': + // mysql column separators + case '`': // before call case '^': - pop_LS(PC); - PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } + pop_LS(pc); + pc.ungetc(); result=EON; goto break2; case '[': // $name.<[>code] - if(PC.col>1/*not first column*/ && ( + if(pc.pos.col>1/*not first column*/ && ( end[-1]=='$'/*was start of get*/ || end[-1]==':'/*was class name delim */ || end[-1]=='.'/*was name delim */ )) { - push_LS(PC, LS_NAME_SQUARE_PART); + push_LS(pc, LS_NAME_SQUARE_PART); lexical_brackets_nestage=1; RC; } - PC.ls=LS_VAR_SQUARE; + pc.ls=LS_VAR_SQUARE; lexical_brackets_nestage=1; RC; case '{': if(begin==end) { // ${name}, no need of EON, switching LS - PC.ls=LS_VAR_NAME_CURLY; + pc.ls=LS_VAR_NAME_CURLY; } else { - PC.ls=LS_VAR_CURLY; + pc.ls=LS_VAR_CURLY; lexical_brackets_nestage=1; } RC; case '(': - PC.ls=LS_VAR_ROUND; + pc.ls=LS_VAR_ROUND; lexical_brackets_nestage=1; RC; case '.': // name part delim case '$': // name part subvar case ':': // class<:>name // go to _WITHOUT_COLON state variant... - if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON) - PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON; - else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON) - PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON; + if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON) + pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON; + else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON) + pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON; // ...stop before next ':' RC; } @@ -2427,11 +3224,11 @@ default: switch(c) { case '[': // ${name.<[>code]} - push_LS(PC, LS_NAME_SQUARE_PART); + push_LS(pc, LS_NAME_SQUARE_PART); lexical_brackets_nestage=1; RC; case '}': // ${name} finished, restoring LS - pop_LS(PC); + pop_LS(pc); RC; case '.': // name part delim case '$': // name part subvar @@ -2443,14 +3240,14 @@ default: case LS_VAR_SQUARE: switch(c) { case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case ']': if(--lexical_brackets_nestage==0) { - pop_LS(PC); + pop_LS(pc); RC; } break; @@ -2465,14 +3262,14 @@ default: case LS_VAR_CURLY: switch(c) { case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case '}': if(--lexical_brackets_nestage==0) { - pop_LS(PC); + pop_LS(pc); RC; } break; @@ -2487,24 +3284,24 @@ default: switch(c) { case '[': // ^name.<[>code].xxx - if(PC.col>1/*not first column*/ && ( + if(pc.pos.col>1/*not first column*/ && ( end[-1]=='^'/*was start of call*/ || // never, ^[ is literal... end[-1]==':'/*was class name delim */ || end[-1]=='.'/*was name delim */ )) { - push_LS(PC, LS_NAME_SQUARE_PART); + push_LS(pc, LS_NAME_SQUARE_PART); lexical_brackets_nestage=1; RC; } - PC.ls=LS_METHOD_SQUARE; + pc.ls=LS_METHOD_SQUARE; lexical_brackets_nestage=1; RC; case '{': - PC.ls=LS_METHOD_CURLY; + pc.ls=LS_METHOD_CURLY; lexical_brackets_nestage=1; RC; case '(': - PC.ls=LS_METHOD_ROUND; + pc.ls=LS_METHOD_ROUND; lexical_brackets_nestage=1; RC; case '.': // name part delim @@ -2512,6 +3309,7 @@ default: case ':': // ':name' or 'class:name' case '^': // ^abc^xxx wrong. bailing out case ']': case '}': case ')': // ^abc]}) wrong. bailing out + case ' ': // ^if ( wrong. bailing out RC; } break; @@ -2519,16 +3317,16 @@ default: case LS_METHOD_SQUARE: switch(c) { case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case ';': // param delim RC; case ']': if(--lexical_brackets_nestage==0) { - PC.ls=LS_METHOD_AFTER; + pc.ls=LS_METHOD_AFTER; RC; } break; @@ -2541,16 +3339,16 @@ default: case LS_METHOD_CURLY: switch(c) { case '$': - push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON); + push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON); RC; case '^': - push_LS(PC, LS_METHOD_NAME); + push_LS(pc, LS_METHOD_NAME); RC; case ';': // param delim RC; case '}': if(--lexical_brackets_nestage==0) { - PC.ls=LS_METHOD_AFTER; + pc.ls=LS_METHOD_AFTER; RC; } break; @@ -2558,26 +3356,36 @@ default: lexical_brackets_nestage++; break; } + if(pc.explicit_result && c) + switch(c) { + case '\n': case ' ': case '\t': + begin=pc.source; + begin_pos=pc.pos; + continue; // skip it + default: + result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE; + goto break2; + } break; case LS_METHOD_AFTER: if(c=='[') {/* ][ }[ )[ */ - PC.ls=LS_METHOD_SQUARE; + pc.ls=LS_METHOD_SQUARE; lexical_brackets_nestage=1; RC; } if(c=='{') {/* ]{ }{ ){ */ - PC.ls=LS_METHOD_CURLY; + pc.ls=LS_METHOD_CURLY; lexical_brackets_nestage=1; RC; } if(c=='(') {/* ]( }( )( */ - PC.ls=LS_METHOD_ROUND; + pc.ls=LS_METHOD_ROUND; lexical_brackets_nestage=1; RC; } - pop_LS(PC); - PC.source--; if(--PC.col<0) { PC.line--; PC.col=-1; } + pop_LS(pc); + pc.ungetc(); result=EON; goto break2; } @@ -2589,37 +3397,41 @@ default: break2: if(end!=begin) { // there is last piece? - if((c=='@' || c==0) && end[-1]=='\n') { // we are before LS_DEF_NAME or EOF? - // strip last \n - end--; - if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME + if(c=='@' || c==0) // we are before LS_DEF_NAME or EOF? + while(end!=begin && end[-1]=='\n') // trim all empty lines before LS_DEF_NAME and EOF end--; - } - if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment? + if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment? + if(!pc.string_start) + pc.string_start=begin_pos; // append it - PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/*, start_col*/); + pc.string.append_strdup_know_length(begin, end-begin); } } - if(PC.string->size()) { // something accumulated? - // create STRING value: array of OP_VALUE+vstring - *lvalp=VL(NEW VString(*PC.string)); + if(!pc.string.is_empty()) { // something accumulated? + // 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); // new pieces storage - PC.string=NEW String(POOL); + pc.string.clear(); + pc.string_start.clear(); // make current result be pending for next call, return STRING for now - PC.pending_state=result; result=STRING; + pc.pending_state=result; result=STRING; } if(skip_analized) { - PC.source+=skip_analized; PC.col+=skip_analized; + pc.source+=skip_analized; pc.pos.col+=skip_analized; } return result; } -static int real_yyerror(parse_control *pc, char *s) { // Called by yyparse on error +static int real_yyerror(Parse_control *pc, char *s) { // Called by yyparse on error strncpy(PC.error, s, MAX_STRING); return 1; } static void yyprint(FILE *file, int type, YYSTYPE value) { if(type==STRING) - fprintf(file, " \"%s\"", LA2S(value)->cstr()); + fprintf(file, " \"%s\"", LA2S(*value)->cstr()); } + +