[BACK]Return to compile.tab.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.tab.C between versions 1.66 and 1.151

version 1.66, 2002/09/13 14:11:43 version 1.151, 2010/09/24 09:33:33
Line 1 Line 1
   /* A Bison parser, made by GNU Bison 1.875d.  */
   
   /* 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
   
 /*  A Bison parser, made from compile.y  
     by GNU Bison version 1.28  */  
   
 #define YYBISON 1  /* Identify Bison output.  */  
   
 #define EON     257  /* Tokens.  */
 #define STRING  258  #ifndef YYTOKENTYPE
 #define BOGUS   259  # define YYTOKENTYPE
 #define BAD_STRING_COMPARISON_OPERATOR  260     /* Put the tokens into the symbol table, so that GDB and other debuggers
 #define BAD_HEX_LITERAL 261        know about them.  */
 #define BAD_METHOD_DECL_START   262     enum yytokentype {
 #define BAD_METHOD_PARAMETER_NAME_CHARACTER     263       EON = 258,
 #define BAD_MATH_OPERATOR_CHARACTER     264       STRING = 259,
 #define LAND    265       BOGUS = 260,
 #define LOR     266       BAD_STRING_COMPARISON_OPERATOR = 261,
 #define LXOR    267       BAD_HEX_LITERAL = 262,
 #define NXOR    268       BAD_METHOD_DECL_START = 263,
 #define NLE     269       BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
 #define NGE     270       BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,
 #define NEQ     271       LAND = 266,
 #define NNE     272       LOR = 267,
 #define SLT     273       LXOR = 268,
 #define SGT     274       NXOR = 269,
 #define SLE     275       NLE = 270,
 #define SGE     276       NGE = 271,
 #define SEQ     277       NEQ = 272,
 #define SNE     278       NNE = 273,
 #define DEF     279       NSL = 274,
 #define IN      280       NSR = 275,
 #define FEXISTS 281       SLT = 276,
 #define DEXISTS 282       SGT = 277,
 #define IS      283       SLE = 278,
 #define NEG     284       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
   
   
   
   
   /* Copy the first part of user declarations.  */
 #line 1 "compile.y"  #line 1 "compile.y"
   
 /** @file  /** @file
         Parser: compiler(lexical parser and grammar).          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 <paf@design.ru> (http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
   
         $Id$          $Id$
Line 55 Line 146
                 -#:     in iis make up specialized Pool object for that                  -#:     in iis make up specialized Pool object for that
 */  */
   
 #define YYSTYPE  Array/*<Operation>*/ *  #define YYSTYPE  ArrayOperation* 
 #define YYPARSE_PARAM  pc  #define YYPARSE_PARAM  pc
 #define YYLEX_PARAM  pc  #define YYLEX_PARAM  pc
 #define YYDEBUG  1  #define YYDEBUG  1
 #define YYERROR_VERBOSE 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)  #define YYPRINT(file, type, value)  yyprint(file, type, value)
   
   // includes
   
 #include "compile_tools.h"  #include "compile_tools.h"
 #include "pa_value.h"  #include "pa_value.h"
 #include "pa_request.h"  #include "pa_request.h"
Line 70 Line 163
 #include "pa_vdouble.h"  #include "pa_vdouble.h"
 #include "pa_globals.h"  #include "pa_globals.h"
 #include "pa_vvoid.h"  #include "pa_vvoid.h"
   #include "pa_vmethod_frame.h"
   
 #define SELF_ELEMENT_NAME "self"  // defines
 #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);  
   
   #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  // local convinient inplace typecast & var
 #define PC  (*(parse_control *)pc)  #undef PC
   #define PC  (*(Parse_control *)pc)
   #undef POOL
 #define POOL  (*PC.pool)  #define POOL  (*PC.pool)
 #undef NEW  
 #define NEW new(POOL)  
 #ifndef DOXYGEN  #ifndef DOXYGEN
 #ifndef YYSTYPE  
 #define YYSTYPE int  
 #endif  
 #include <stdio.h>  
   
 #ifndef __cplusplus  
 #ifndef __STDC__  /* Enabling traces.  */
 #define const  #ifndef YYDEBUG
   # define YYDEBUG 0
 #endif  #endif
   
   /* Enabling verbose error messages.  */
   #ifdef YYERROR_VERBOSE
   # undef YYERROR_VERBOSE
   # define YYERROR_VERBOSE 1
   #else
   # define YYERROR_VERBOSE 0
 #endif  #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 <stdlib.h> /* 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         248  #if defined (__STDC__) || defined (__cplusplus)
 #define YYFLAG          -32768     typedef signed char yysigned_char;
 #define YYNTBASE        58  #else
      typedef short int yysigned_char;
 #define YYTRANSLATE(x) ((unsigned)(x) <= 284 ? yytranslate[x] : 137)  #endif
   
 static const char yytranslate[] = {     0,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,    44,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,    32,    56,     2,    48,    40,    34,    57,    52,  
     53,    38,    37,     2,    36,    51,    39,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,    55,    47,    30,  
      2,    31,     2,    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,  
     45,    41,    46,    54,     2,     2,     2,     2,     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,    33,    50,    35,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     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,    42  
 };  
   
 #if YYDEBUG != 0  /* YYFINAL -- State number of the termination state. */
 static const short yyprhs[] = {     0,  #define YYFINAL  51
      0,     2,     4,     6,     9,    11,    13,    15,    20,    22,  /* YYLAST -- Last index in YYTABLE.  */
     24,    26,    29,    32,    34,    36,    44,    46,    48,    52,  #define YYLAST   470
     54,    56,    58,    62,    64,    66,    68,    70,    72,    75,  
     77,    79,    81,    83,    85,    87,    90,    93,    95,    99,  /* YYNTOKENS -- Number of terminals. */
    101,   103,   105,   108,   110,   113,   117,   119,   121,   123,  #define YYNTOKENS  62
    125,   128,   131,   133,   135,   137,   141,   145,   149,   151,  /* YYNNTS -- Number of nonterminals. */
    153,   155,   157,   159,   161,   164,   166,   167,   168,   175,  #define YYNNTS  89
    177,   179,   182,   184,   186,   188,   192,   196,   200,   202,  /* YYNRULES -- Number of rules. */
    206,   208,   212,   214,   218,   220,   222,   224,   226,   228,  #define YYNRULES  172
    230,   232,   234,   237,   239,   242,   245,   247,   249,   252,  /* YYNRULES -- Number of states. */
    254,   256,   258,   260,   263,   266,   270,   272,   274,   277,  #define YYNSTATES  263
    280,   282,   284,   287,   290,   292,   294,   296,   298,   302,  
    306,   310,   313,   316,   319,   322,   325,   328,   331,   334,  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    338,   342,   346,   350,   354,   358,   362,   366,   370,   374,  #define YYUNDEFTOK  2
    378,   382,   386,   390,   394,   398,   402,   406,   410,   414,  #define YYMAXUTOK   289
    418,   422,   426,   430,   434,   436,   438,   439  
   #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[] = {    60,  #if YYDEBUG
      0,    59,     0,    61,     0,    59,    61,     0,    73,     0,  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
     62,     0,    67,     0,    43,     4,    44,    63,     0,   136,     YYRHS.  */
      0,    64,     0,    65,     0,    64,    65,     0,    66,    44,  static const unsigned short int yyprhs[] =
      0,   136,     0,     4,     0,    43,     4,    69,    68,    72,  {
     44,    73,     0,   136,     0,    69,     0,    45,    70,    46,         0,     0,     3,     5,     7,     9,    12,    14,    16,    18,
      0,   136,     0,    71,     0,     4,     0,    71,    47,     4,        23,    25,    27,    29,    32,    35,    37,    39,    40,    49,
      0,   136,     0,     4,     0,   136,     0,    74,     0,    75,        51,    53,    57,    59,    61,    63,    67,    69,    71,    73,
      0,    74,    75,     0,   134,     0,    76,     0,    77,     0,        75,    77,    80,    82,    84,    86,    88,    90,    92,    95,
     85,     0,    98,     0,    78,     0,    48,    79,     0,    81,        98,   100,   104,   106,   108,   110,   113,   115,   118,   122,
      3,     0,    80,     0,    49,    81,    50,     0,    82,     0,       124,   126,   128,   130,   133,   136,   138,   140,   142,   143,
     83,     0,    84,     0,   128,    84,     0,   120,     0,   117,       144,   150,   154,   158,   160,   162,   164,   166,   168,   170,
    120,     0,    48,    86,    90,     0,    87,     0,    88,     0,       173,   175,   176,   177,   184,   186,   188,   191,   193,   195,
     89,     0,   116,     0,    51,   116,     0,   128,   116,     0,       197,   198,   199,   205,   209,   213,   215,   219,   221,   225,
     91,     0,    92,     0,    93,     0,    45,    94,    46,     0,       227,   231,   233,   235,   237,   239,   241,   243,   245,   248,
     52,   131,    53,     0,    49,    73,    50,     0,   135,     0,       250,   253,   256,   258,   260,   263,   265,   267,   269,   271,
      4,     0,    95,     0,    96,     0,    97,     0,    76,     0,       274,   277,   278,   279,   285,   287,   289,   292,   295,   297,
     75,    74,     0,    99,     0,     0,     0,    54,   100,   102,       299,   302,   305,   307,   309,   311,   313,   315,   317,   321,
    101,   103,     3,     0,    81,     0,   104,     0,   103,   104,       325,   329,   332,   335,   338,   341,   344,   347,   350,   353,
      0,   105,     0,   106,     0,   107,     0,    45,   108,    46,       357,   361,   365,   369,   373,   377,   381,   385,   389,   393,
      0,    52,   109,    53,     0,    49,   110,    50,     0,   111,       397,   401,   405,   409,   413,   417,   421,   425,   429,   433,
      0,   108,    47,   111,     0,   112,     0,   109,    47,   112,       437,   441,   445,   449,   453,   457,   461,   463,   465,   467,
      0,   113,     0,   110,    47,   113,     0,   114,     0,   115,       468,   470,   472
      0,    73,     0,   135,     0,     4,     0,    95,     0,   131,  
      0,   121,     0,   117,   121,     0,   118,     0,   117,   118,  
      0,   119,    51,     0,   121,     0,   121,     0,     4,     5,  
      0,     4,     0,   122,     0,   123,     0,   124,     0,    48,  
    125,     0,     4,   126,     0,    45,    74,    46,     0,     4,  
      0,   127,     0,   126,   127,     0,    48,   125,     0,   129,  
      0,   130,     0,     4,    55,     0,   129,    55,     0,   132,  
      0,     4,     0,    78,     0,    99,     0,    56,   133,    56,  
      0,    57,   133,    57,     0,    52,   132,    53,     0,    36,  
    132,     0,    37,   132,     0,    35,   132,     0,    32,   132,  
      0,    25,   132,     0,    26,   132,     0,    27,   132,     0,  
     28,   132,     0,   132,    36,   132,     0,   132,    37,   132,  
      0,   132,    38,   132,     0,   132,    39,   132,     0,   132,  
     40,   132,     0,   132,    41,   132,     0,   132,    34,   132,  
      0,   132,    33,   132,     0,   132,    14,   132,     0,   132,  
     11,   132,     0,   132,    12,   132,     0,   132,    13,   132,  
      0,   132,    30,   132,     0,   132,    31,   132,     0,   132,  
     15,   132,     0,   132,    16,   132,     0,   132,    17,   132,  
      0,   132,    18,   132,     0,   132,    19,   132,     0,   132,  
     20,   132,     0,   132,    21,   132,     0,   132,    22,   132,  
      0,   132,    23,   132,     0,   132,    24,   132,     0,   132,  
     29,   132,     0,    73,     0,     4,     0,     0,     0  
 };  };
   
 #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  /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const short yyrline[] = { 0,  static const unsigned short int yyrline[] =
    110,   120,   122,   122,   123,   125,   125,   127,   194,   194,  {
    195,   195,   196,   197,   197,   199,   228,   228,   229,   230,         0,   132,   132,   139,   141,   141,   142,   144,   144,   146,
    230,   231,   231,   233,   233,   237,   237,   239,   239,   240,       253,   253,   254,   254,   255,   256,   256,   258,   258,   306,
    240,   241,   241,   241,   245,   252,   253,   253,   254,   255,       306,   307,   308,   308,   309,   309,   311,   311,   315,   315,
    257,   258,   280,   281,   281,   285,   289,   291,   292,   293,       317,   317,   318,   318,   319,   319,   319,   323,   364,   365,
    310,   315,   317,   319,   320,   322,   328,   336,   342,   344,       365,   366,   368,   369,   370,   423,   424,   424,   428,   441,
    345,   347,   353,   354,   354,   358,   364,   367,   370,   383,       442,   443,   444,   470,   475,   478,   479,   480,   482,   485,
    385,   385,   386,   388,   389,   391,   392,   393,   394,   396,       482,   493,   501,   508,   509,   510,   512,   518,   519,   519,
    398,   400,   402,   404,   406,   410,   414,   418,   420,   421,       523,   535,   538,   535,   582,   584,   584,   586,   587,   588,
    423,   432,   432,   434,   434,   435,   436,   444,   449,   451,       590,   593,   590,   596,   597,   599,   600,   603,   604,   607,
    453,   454,   455,   457,   461,   470,   476,   481,   481,   482,       608,   610,   613,   627,   632,   633,   634,   639,   639,   641,
    487,   489,   491,   503,   515,   520,   522,   523,   524,   525,       641,   642,   643,   651,   656,   659,   660,   661,   662,   664,
    526,   528,   529,   530,   531,   532,   533,   534,   535,   537,       668,   677,   680,   677,   688,   693,   693,   694,   700,   701,
    538,   539,   540,   541,   542,   543,   544,   545,   546,   547,       703,   716,   728,   730,   731,   732,   733,   734,   735,   736,
    548,   549,   550,   551,   552,   553,   554,   555,   556,   557,       737,   739,   740,   741,   742,   743,   744,   745,   746,   748,
    558,   559,   560,   561,   564,   573,   578,   579       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  #endif
   
   #if YYDEBUG || YYERROR_VERBOSE
 #if YYDEBUG != 0 || defined (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[] = {   "$","error","$undefined.","EON","STRING",  static const char *const yytname[] =
 "BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START",  {
 "BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_MATH_OPERATOR_CHARACTER","\"&&\"",    "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
 "\"||\"","\"!||\"","\"!|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"lt\"","\"gt\"",    "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
 "\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"","\"-d\"","\"is\"",    "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
 "'<'","'>'","'!'","'|'","'&'","'~'","'-'","'+'","'*'","'/'","'%'","'\\\\'","NEG",    "BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
 "'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'","'('","')'","'^'","':'",    "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
 "'\\\"'","'\\''","all","methods","one_big_piece","method","control_method","maybe_control_strings",    "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
 "control_strings","control_string","maybe_string","code_method","maybe_bracketed_strings",    "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
 "bracketed_maybe_strings","maybe_strings","strings","maybe_comment","maybe_codes",    "\"false\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'",
 "codes","code","action","get","get_value","get_name_value","name_in_curly_rdive",    "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", "'['", "']'",
 "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",    "'''", "$accept", "all", "methods", "one_big_piece", "method",
 "name_expr_wdive_write","name_expr_wdive_class","construct","construct_square",    "control_method", "maybe_control_strings", "control_strings",
 "construct_round","construct_curly","any_constructor_code_value","constructor_code_value",    "control_string", "maybe_string", "code_method", "@1",
 "constructor_code","codes__excluding_sole_str_literal","call","call_value","@1",    "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
 "@2","call_name","store_params","store_param","store_square_param","store_round_param",    "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
 "store_curly_param","store_code_param_parts","store_expr_param_parts","store_curly_param_parts",    "get", "get_value", "get_name_value", "name_in_curly_rdive",
 "store_code_param_part","store_expr_param_part","store_curly_param_part","code_param_value",    "name_without_curly_rdive", "name_without_curly_rdive_read",
 "write_expr_value","name_expr_dive_code","name_path","name_step","name_advance1",    "name_without_curly_rdive_class", "name_without_curly_rdive_code", "put",
 "name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",    "name_expr_wdive", "name_expr_wdive_root", "name_expr_wdive_write",
 "name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",    "name_expr_wdive_class", "construct", "construct_square", "@2", "@3",
 "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",    "construct_round", "construct_curly", "any_constructor_code_value",
 "expr","string_inside_quotes_value","write_string","void_value","empty", NULL    "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  #endif
   
 static const short yyr1[] = {     0,  # ifdef YYPRINT
     58,    58,    59,    59,    60,    61,    61,    62,    63,    63,  /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
     64,    64,    65,    66,    66,    67,    68,    68,    69,    70,     token YYLEX-NUM.  */
     70,    71,    71,    72,    72,    73,    73,    74,    74,    75,  static const unsigned short int yytoknum[] =
     75,    76,    76,    76,    77,    78,    79,    79,    80,    81,  {
     81,    82,    83,    84,    84,    85,    86,    86,    86,    87,         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     88,    89,    90,    90,    90,    91,    92,    93,    94,    94,       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     94,    95,    96,    97,    97,    98,   100,   101,    99,   102,       275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
    103,   103,   104,   104,   104,   105,   106,   107,   108,   108,       285,   286,   287,   288,    60,    62,   124,    38,    43,    45,
    109,   109,   110,   110,   111,   112,   113,   114,   114,   114,        42,    47,    92,    37,   289,   126,    33,    64,    10,    91,
    115,   116,   116,   117,   117,   118,   119,   120,   120,   121,        93,    59,    36,   123,   125,    46,    40,    41,    94,    58,
    121,   121,   121,   122,   123,   124,   125,   126,   126,   127,        34,    39
    128,   128,   129,   130,   131,   132,   132,   132,   132,   132,  
    132,   132,   132,   132,   132,   132,   132,   132,   132,   132,  
    132,   132,   132,   132,   132,   132,   132,   132,   132,   132,  
    132,   132,   132,   132,   132,   132,   132,   132,   132,   132,  
    132,   132,   132,   132,   133,   134,   135,   136  
 };  };
   # endif
   
 static const short yyr2[] = {     0,  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
      1,     1,     1,     2,     1,     1,     1,     4,     1,     1,  static const unsigned char yyr1[] =
      1,     2,     2,     1,     1,     7,     1,     1,     3,     1,  {
      1,     1,     3,     1,     1,     1,     1,     1,     2,     1,         0,    62,    63,    63,    64,    64,    65,    66,    66,    67,
      1,     1,     1,     1,     1,     2,     2,     1,     3,     1,        68,    68,    69,    69,    70,    71,    71,    73,    72,    74,
      1,     1,     2,     1,     2,     3,     1,     1,     1,     1,        74,    75,    76,    76,    77,    77,    78,    78,    79,    79,
      2,     2,     1,     1,     1,     3,     3,     3,     1,     1,        80,    80,    81,    81,    82,    82,    82,    83,    84,    85,
      1,     1,     1,     1,     2,     1,     0,     0,     6,     1,        85,    86,    87,    87,    88,    89,    90,    90,    91,    92,
      1,     2,     1,     1,     1,     3,     3,     3,     1,     3,        92,    92,    93,    94,    95,    96,    96,    96,    98,    99,
      1,     3,     1,     3,     1,     1,     1,     1,     1,     1,        97,   100,   101,   102,   102,   102,   103,   104,   105,   105,
      1,     1,     2,     1,     2,     2,     1,     1,     2,     1,       106,   108,   109,   107,   110,   111,   111,   112,   112,   112,
      1,     1,     1,     2,     2,     3,     1,     1,     2,     2,       114,   115,   113,   116,   117,   118,   118,   119,   119,   120,
      1,     1,     2,     2,     1,     1,     1,     1,     3,     3,       120,   121,   122,   123,   124,   124,   124,   125,   125,   126,
      3,     2,     2,     2,     2,     2,     2,     2,     2,     3,       126,   127,   128,   129,   129,   130,   130,   130,   130,   131,
      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,       132,   134,   135,   133,   136,   137,   137,   138,   139,   139,
      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,       140,   141,   142,   143,   143,   143,   143,   143,   143,   143,
      3,     3,     3,     3,     1,     1,     0,     0       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[] = {   158,  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    156,     0,     0,    67,     2,     1,     3,     6,     7,     5,  static const unsigned char yyr2[] =
     27,    28,    31,    32,    35,    33,    34,    66,    30,    26,  {
      0,   100,     0,     0,     0,     0,    36,    38,     0,    40,         0,     2,     1,     1,     1,     2,     1,     1,     1,     4,
     41,    42,     0,    47,    48,    49,    50,     0,    94,     0,         1,     1,     1,     2,     2,     1,     1,     0,     8,     1,
     44,    92,   101,   102,   103,     0,   111,   112,     0,     4,         1,     3,     1,     1,     1,     3,     1,     1,     1,     1,
     29,   158,   158,   158,    99,     0,   113,   105,   108,     0,         1,     2,     1,     1,     1,     1,     1,     1,     2,     2,
    107,   104,     0,     0,    98,     0,   100,    51,     0,    92,         1,     3,     1,     1,     1,     2,     1,     2,     3,     1,
     37,   157,   158,     0,    46,    53,    54,    55,   100,    95,         1,     1,     1,     2,     2,     1,     1,     1,     0,     0,
     45,    93,    96,    43,    52,   114,    70,    68,    15,     8,         5,     3,     3,     1,     1,     1,     1,     1,     1,     2,
     10,    11,     0,     9,    22,     0,    21,    20,   158,    18,         1,     0,     0,     6,     1,     1,     2,     1,     1,     1,
     17,   110,   109,   106,    39,    93,   156,     0,    31,     0,         0,     0,     5,     3,     3,     1,     3,     1,     3,     1,
     61,    62,    63,    59,     0,   116,     0,     0,     0,     0,         3,     1,     1,     1,     1,     1,     1,     1,     2,     1,
      0,     0,     0,     0,     0,     0,   158,   158,   117,   118,         2,     2,     1,     1,     2,     1,     1,     1,     1,     2,
      0,   115,     0,    12,    14,    13,    19,     0,    25,     0,         2,     0,     0,     5,     1,     1,     2,     2,     1,     1,
     24,    65,    56,    58,   126,   127,   128,   129,   125,   124,         2,     2,     1,     1,     1,     1,     1,     1,     3,     3,
    122,   123,     0,   155,     0,     0,    57,     0,     0,     0,         3,     2,     2,     2,     2,     2,     2,     2,     2,     3,
      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,         3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,         3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
      0,     0,   157,   158,     0,     0,    71,    73,    74,    75,         3,     3,     3,     3,     3,     3,     1,     1,     1,     0,
     23,   158,   121,   119,   120,   139,   140,   141,   138,   144,         1,     1,     0
    145,   146,   147,   148,   149,   150,   151,   152,   153,   154,  
    142,   143,   137,   136,   130,   131,   132,   133,   134,   135,  
    156,    90,     0,    79,    85,    88,    87,     0,    83,     0,  
     81,    86,    91,    69,    72,    16,    76,   157,   158,    78,  
      0,    77,    80,    84,    82,     0,     0,     0  
 };  };
   
 static const short yydefgoto[] = {   246,  /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
      5,     6,     7,     8,    90,    91,    92,    93,     9,    99,     STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
     54,    96,    97,   140,   154,    11,    12,    13,    14,   129,     means the default is an error.  */
     27,    28,    29,    30,    31,    32,    16,    33,    34,    35,  static const unsigned char yydefact[] =
     36,    75,    76,    77,    78,   110,   222,   112,   113,    17,  {
    130,    49,   133,    88,   186,   187,   188,   189,   190,   223,       172,   168,     0,     0,    71,     0,     3,     2,     4,     7,
    230,   228,   224,   231,   229,   225,   232,    37,    64,    39,         8,     6,    29,    30,    33,    34,    37,    35,    36,    70,
     40,    41,    65,    43,    44,    45,    62,    58,    59,    66,        32,    28,     0,   105,   111,     0,     0,     0,    38,    40,
     47,    48,   233,   132,   155,    19,   226,    20         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[] = {    15,  /* YYDEFGOTO[NTERM-NUM]. */
 -32768,    12,    55,-32768,   -25,-32768,-32768,-32768,-32768,-32768,  static const short int yydefgoto[] =
     16,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  {
     54,     1,    16,    17,    93,    98,-32768,-32768,    42,-32768,        -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
 -32768,-32768,    -6,-32768,-32768,-32768,-32768,   103,-32768,    40,        10,   244,   101,    56,    98,    99,   140,   161,    12,    13,
 -32768,    37,-32768,-32768,-32768,   103,    13,-32768,    93,-32768,        14,    15,   126,    28,    29,    30,    31,    32,    33,    17,
 -32768,    97,   113,   100,-32768,    17,-32768,    99,-32768,    33,        34,    35,    36,    37,    77,    78,   109,   204,    79,    80,
 -32768,-32768,   118,   103,   121,   103,    99,-32768,    98,   121,       146,   247,   148,   149,    18,   127,    50,   133,    90,   195,
 -32768,    23,    16,    57,-32768,-32768,-32768,-32768,    19,-32768,       196,   197,   235,   258,   198,   199,   248,   239,   237,   249,
 -32768,    37,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,       240,   238,   250,    38,    66,    40,    41,    42,    67,    44,
     22,-32768,   105,   125,-32768,   104,   123,-32768,   169,-32768,        45,    46,    62,   142,    64,    60,    61,    68,    48,    49,
 -32768,-32768,-32768,-32768,-32768,   121,   142,    16,    87,   143,       241,   129,   130,   162,    20,   251,   131,   132,    21
 -32768,-32768,-32768,-32768,   140,-32768,    57,    57,    57,    57,  
     57,    57,    57,    57,    91,    57,    16,    16,-32768,-32768,  
    138,   275,    -1,-32768,-32768,-32768,-32768,   189,-32768,   178,  
 -32768,    16,-32768,-32768,    82,    82,    82,    82,    82,   196,  
 -32768,-32768,   232,-32768,   173,   200,-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,    32,    16,    57,     5,-32768,-32768,-32768,-32768,  
 -32768,    16,-32768,-32768,-32768,   365,   337,   306,   141,   393,  
    393,   406,   406,   393,   393,   393,   393,   406,   406,    82,  
    393,   393,   187,   196,   -10,   -10,-32768,-32768,-32768,-32768,  
    107,-32768,   119,-32768,-32768,-32768,-32768,   -33,-32768,    84,  
 -32768,-32768,-32768,-32768,-32768,-32768,-32768,    32,    16,-32768,  
     57,-32768,-32768,-32768,-32768,   230,   258,-32768  
 };  };
   
 static const short yypgoto[] = {-32768,  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -32768,-32768,   254,-32768,-32768,-32768,   176,-32768,-32768,-32768,     STATE-NUM.  */
    206,-32768,-32768,-32768,     3,   -18,    -7,   -71,-32768,     0,  #define YYPACT_NINF -107
 -32768,-32768,   -15,-32768,-32768,   -24,-32768,-32768,-32768,-32768,  static const short int yypact[] =
 -32768,-32768,-32768,-32768,-32768,-32768,   192,-32768,-32768,-32768,  {
      2,-32768,-32768,-32768,-32768,    88,-32768,-32768,-32768,-32768,        14,  -107,    13,    45,  -107,    28,   -15,  -107,  -107,  -107,
 -32768,-32768,    39,    34,    41,-32768,-32768,   106,     6,   -31,      -107,  -107,    21,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
 -32768,   -23,     9,-32768,-32768,-32768,   220,-32768,   221,   278,      -107,  -107,    73,    19,  -107,    50,     6,    44,  -107,  -107,
 -32768,-32768,   204,    38,   154,-32768,   211,    72        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
 };  };
   
   /* YYPGOTO[NTERM-NUM].  */
 #define YYLAST          447  static const short int yypgoto[] =
   {
       -107,  -107,  -107,  -107,   206,  -107,  -107,  -107,   124,  -107,
 static const short yytable[] = {    15,      -107,  -107,  -107,   170,  -107,  -107,  -107,     1,   -58,    -7,
    109,    18,    10,    51,    60,    55,    80,   234,    38,    63,      -106,  -107,     0,  -107,  -107,    -6,  -107,  -107,   -21,  -107,
     15,    42,    18,   239,    81,    21,   240,     2,     1,     1,      -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
     61,    84,    15,    55,    18,    89,   107,   179,   180,   181,      -107,   118,  -107,  -107,  -107,     2,  -107,  -107,  -107,  -107,
    182,    69,    80,    87,    70,   221,     1,    80,    72,   -98,        43,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,   -17,
     81,    84,    73,   183,    71,    74,    82,   184,    56,   183,       -13,   -16,  -107,   -18,     4,    41,  -107,   -23,     3,  -107,
    185,    38,    51,   184,    42,    57,   185,     2,    22,    15,      -107,  -107,  -107,  -107,   181,  -107,   183,   239,  -107,  -107,
    116,    18,     3,     3,   108,  -158,    56,    86,     4,     4,       171,    95,  -107,   123,  -107,   142,  -107,  -107,    64
      3,    15,    15,    18,    18,   115,     4,   106,   104,     3,  
      3,   117,   118,   119,   120,     4,     4,   -97,   121,   142,  
     83,   122,   123,   124,    22,   161,    22,    52,    53,    23,  
     89,    67,    24,    25,   125,    26,    79,    15,   126,    18,  
      4,   109,   127,   128,   175,   176,    95,   177,   178,   179,  
    180,   181,   182,    94,    98,   101,    15,    15,    18,    18,  
    241,    68,   -64,   -64,    51,    23,   242,    23,    24,    25,  
     24,    15,    23,    18,    53,    24,    56,    23,   136,   137,  
     24,    85,   -89,   -89,   145,   146,   147,   148,   149,   150,  
    151,   152,   135,   153,   237,   238,   109,   105,   -14,   138,  
    141,   -97,   139,   175,   176,   108,   177,   178,   179,   180,  
    181,   182,    15,    15,    18,    18,   227,   -60,   143,   144,  
    157,    15,   191,    18,   236,   196,   197,   198,   199,   200,  
    201,   202,   203,   204,   205,   206,   207,   208,   209,   210,  
    211,   212,   213,   214,   215,   216,   217,   218,   219,   220,  
    176,   192,   177,   178,   179,   180,   181,   182,   194,   247,  
    108,   177,   178,   179,   180,   181,   182,    15,    15,    18,  
     18,   227,   158,   159,   160,   161,   162,   163,   164,   165,  
    166,   167,   168,   169,   170,   171,   195,   248,    50,   100,  
    172,   173,   174,   111,   175,   176,   134,   177,   178,   179,  
    180,   181,   182,   235,   245,   102,   243,   131,   103,   244,  
     46,   156,   114,     0,   193,   158,   159,   160,   161,   162,  
    163,   164,   165,   166,   167,   168,   169,   170,   171,     0,  
      0,     0,     0,   172,   173,   174,     0,   175,   176,     0,  
    177,   178,   179,   180,   181,   182,   158,   159,     0,   161,  
    162,   163,   164,   165,   166,   167,   168,   169,   170,   171,  
      0,     0,     0,     0,   172,   173,   174,     0,   175,   176,  
      0,   177,   178,   179,   180,   181,   182,   158,     0,     0,  
    161,   162,   163,   164,   165,   166,   167,   168,   169,   170,  
    171,     0,     0,     0,     0,   172,   173,   174,     0,   175,  
    176,     0,   177,   178,   179,   180,   181,   182,   161,   162,  
    163,   164,   165,   166,   167,   168,   169,   170,   171,     0,  
      0,     0,     0,   172,   173,   174,     0,   175,   176,     0,  
    177,   178,   179,   180,   181,   182,   161,     0,     0,   164,  
    165,     0,     0,     0,     0,   170,   171,     0,     0,   161,  
      0,   172,     0,     0,     0,   175,   176,     0,   177,   178,  
    179,   180,   181,   182,   172,     0,     0,     0,   175,   176,  
      0,   177,   178,   179,   180,   181,   182  
 };  };
   
 static const short yycheck[] = {     0,  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     72,     0,     0,    11,    23,     5,    38,     3,     3,    25,     positive, shift that token.  If negative, reduce the rule which
     11,     3,    11,    47,    38,     4,    50,    43,     4,     4,     number is the opposite.  If zero, do what YYDEFACT says.
      4,    46,    23,     5,    23,     4,     4,    38,    39,    40,     If YYTABLE_NINF, syntax error.  */
     41,    26,    64,    49,    26,     4,     4,    69,    45,     3,  #define YYTABLE_NINF -173
     64,    66,    49,    45,     3,    52,    38,    49,    48,    45,  static const short int yytable[] =
     52,    46,    60,    49,    46,    55,    52,    43,     4,    60,  {
      4,    60,    48,    48,    72,    44,    48,    55,    54,    54,        16,    11,    19,   145,   106,    53,    43,    39,  -103,    70,
     48,    72,    73,    72,    73,    73,    54,    69,    46,    48,        23,   111,    16,    91,    19,    74,    83,    22,     1,    75,
     48,    25,    26,    27,    28,    54,    54,    51,    32,   108,        65,   254,    76,    57,    57,     1,    86,   255,    51,    87,
     51,    35,    36,    37,     4,    14,     4,    44,    45,    45,        72,    71,     2,   143,   112,   113,   114,   115,   242,   116,
      4,     4,    48,    49,    48,    51,     4,   108,    52,   108,       117,   246,    84,    83,    89,   118,   119,    86,    69,    23,
     54,   183,    56,    57,    33,    34,     4,    36,    37,    38,        43,    39,   120,   121,    63,    24,    23,  -172,    25,   122,
     39,    40,    41,    52,    53,    54,   127,   128,   127,   128,      -102,     2,    16,   123,    19,     4,     3,   124,   125,    81,
     47,    26,    46,    47,   142,    45,    53,    45,    48,    49,        58,    58,     4,     3,   108,    16,   110,    19,    59,     4,
     48,   142,    45,   142,    45,    48,    48,    45,    44,    46,        82,     3,   252,    88,   192,   253,   203,     4,   193,     3,
     48,    46,    46,    47,   117,   118,   119,   120,   121,   122,        73,   194,    91,    24,    24,     4,    25,    25,    26,    53,
    123,   124,    91,   126,    46,    47,   238,    50,    44,    47,        27,    24,   144,    85,    25,    26,    16,    82,    19,    16,
     99,    51,     4,    33,    34,   183,    36,    37,    38,    39,       168,    19,    82,    97,    24,   173,   174,    25,    96,   100,
     40,    41,   183,   184,   183,   184,   184,    46,    46,    50,       103,    54,    55,    55,    16,    16,    19,    19,    58,   145,
     53,   192,     4,   192,   192,   158,   159,   160,   161,   162,       -68,   -68,   184,   185,   186,   187,   188,   189,   190,   191,
    163,   164,   165,   166,   167,   168,   169,   170,   171,   172,       107,   192,   136,   137,    16,   193,    19,   -15,   194,   168,
    173,   174,   175,   176,   177,   178,   179,   180,   181,   182,       139,   145,   171,   172,   173,   174,  -102,   135,   -95,   -95,
     34,    44,    36,    37,    38,    39,    40,    41,    56,     0,       179,   180,   168,   138,   151,   141,   181,   173,   174,   200,
    238,    36,    37,    38,    39,    40,    41,   238,   239,   238,       164,   184,   185,   186,   187,   188,   189,   190,   191,   181,
    239,   239,    11,    12,    13,    14,    15,    16,    17,    18,       188,   189,   190,   191,   184,   185,   186,   187,   188,   189,
     19,    20,    21,    22,    23,    24,    57,     0,     5,    54,       190,   191,   201,    16,   236,    19,    53,   202,   206,   -64,
     29,    30,    31,    72,    33,    34,    91,    36,    37,    38,       207,   173,   174,    16,   245,    19,   257,   152,   153,   154,
     39,    40,    41,   186,   241,    56,   238,    74,    58,   239,       155,   262,    52,   156,   157,   158,   159,   134,   160,   185,
      3,   128,    72,    -1,    53,    11,    12,    13,    14,    15,       186,   187,   188,   189,   190,   191,   102,   147,   144,   186,
     16,    17,    18,    19,    20,    21,    22,    23,    24,    -1,       187,   188,   189,   190,   191,    16,   259,    19,   243,   104,
     -1,    -1,    -1,    29,    30,    31,    -1,    33,    34,    -1,       261,   260,    47,   105,    16,   256,    19,   128,   163,     0,
     36,    37,    38,    39,    40,    41,    11,    12,    -1,    14,       144,   150,    16,   236,    19,     0,     0,    16,     0,    19,
     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
     -1,    -1,    -1,    -1,    29,    30,    31,    -1,    33,    34,       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
     -1,    36,    37,    38,    39,    40,    41,    11,    -1,    -1,       228,   229,   230,   231,   232,   233,   234,   165,   166,   167,
     14,    15,    16,    17,    18,    19,    20,    21,    22,    23,       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
     24,    -1,    -1,    -1,    -1,    29,    30,    31,    -1,    33,       178,   179,   180,   173,   174,     0,     0,   181,     0,     0,
     34,    -1,    36,    37,    38,    39,    40,    41,    14,    15,       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
     16,    17,    18,    19,    20,    21,    22,    23,    24,    -1,       184,   185,   186,   187,   188,   189,   190,   191,     0,     0,
     -1,    -1,    -1,    29,    30,    31,    -1,    33,    34,    -1,         0,     0,     0,   205,   165,   166,   167,   168,   169,   170,
     36,    37,    38,    39,    40,    41,    14,    -1,    -1,    17,       171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
     18,    -1,    -1,    -1,    -1,    23,    24,    -1,    -1,    14,         0,     0,     0,     0,   181,     0,     0,   182,   183,   184,
     -1,    29,    -1,    -1,    -1,    33,    34,    -1,    36,    37,       185,   186,   187,   188,   189,   190,   191,   165,   166,     0,
     38,    39,    40,    41,    29,    -1,    -1,    -1,    33,    34,       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
     -1,    36,    37,    38,    39,    40,    41       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  static const short int yycheck[] =
    it under the terms of the GNU General Public License as published by  {
    the Free Software Foundation; either version 2, or (at your option)         0,     0,     0,   109,    62,    12,     3,     3,     3,    27,
    any later version.         4,     4,    12,     4,    12,    49,    39,     4,     4,    53,
         26,    51,    56,     5,     5,     4,    47,    57,     0,    47,
    This program is distributed in the hope that it will be useful,        27,    27,    47,     4,    27,    28,    29,    30,     3,    32,
    but WITHOUT ANY WARRANTY; without even the implied warranty of        33,     4,    39,    66,    50,    38,    39,    68,     4,     4,
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        47,    47,    45,    46,     4,    49,     4,    48,    52,    52,
    GNU General Public License for more details.        55,    47,    62,    56,    62,    58,    52,    60,    61,     4,
         52,    52,    58,    52,    71,    75,    75,    75,    59,    58,
    You should have received a copy of the GNU General Public License        39,    52,    51,    59,    49,    54,   144,    58,    53,    52,
    along with this program; if not, write to the Free Software         3,    56,     4,    49,    49,    58,    52,    52,    53,   106,
    Foundation, Inc., 59 Temple Place - Suite 330,        55,    49,   109,    55,    52,    53,   106,    66,   106,   109,
    Boston, MA 02111-1307, USA.  */        14,   109,    71,     4,    49,    19,    20,    52,    54,    55,
         56,    48,    49,    49,   124,   125,   124,   125,    52,   235,
 /* As a special exception, when this file is copied by Bison into a        50,    51,    36,    37,    38,    39,    40,    41,    42,    43,
    Bison output file, you may use that output file without restriction.        54,    49,    48,    50,   144,    53,   144,    48,    56,    14,
    This special exception was added by the Free Software Foundation         4,   257,    17,    18,    19,    20,    55,    93,    50,    51,
    in version 1.24 of Bison.  */        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  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   when the %semantic_parser declaration is not specified in the grammar.     symbol of state STATE-NUM.  */
   It was written by Richard Stallman by simplifying the hairy parser  static const unsigned char yystos[] =
   used when %semantic_parser is specified.  */  {
          0,     4,    47,    52,    58,    63,    64,    65,    66,    67,
 #ifndef YYSTACK_USE_ALLOCA        72,    79,    80,    81,    82,    83,    84,    91,   106,   107,
 #ifdef alloca       146,   150,     4,     4,    49,    52,    53,    55,    85,    86,
 #define YYSTACK_USE_ALLOCA        87,    88,    89,    90,    92,    93,    94,    95,   125,   126,
 #else /* alloca not defined */       127,   128,   129,   130,   131,   132,   133,   139,   140,   141,
 #ifdef __GNUC__       108,     0,    66,    81,    48,    49,    75,     5,    52,    59,
 #define YYSTACK_USE_ALLOCA       137,   138,   134,     4,   136,    87,   126,   130,   139,     4,
 #define alloca __builtin_alloca       125,   126,   130,     3,    49,    53,    56,    96,    97,   100,
 #else /* not GNU C.  */       101,     4,   127,   129,   130,    55,    90,   125,    59,    87,
 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))       110,     4,    68,    69,    70,    71,   150,     4,    76,    77,
 #define YYSTACK_USE_ALLOCA       150,    74,    75,   150,   136,   138,    80,    54,   130,    98,
 #include <alloca.h>        79,     4,    27,    28,    29,    30,    32,    33,    38,    39,
 #else /* not sparc */        45,    46,    52,    56,    60,    61,    84,   107,   142,   143,
 /* We think this test detects Watcom and Microsoft C.  */       144,   148,   149,   109,    70,   150,    48,    50,    51,     4,
 /* This used to test MSDOS, but that is a bad idea        78,   150,   135,     4,    81,    82,   102,   103,   104,   105,
    since that symbol is in the user namespace.  */       147,    54,   143,   143,   143,   143,   143,   143,   143,   143,
 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)       143,    79,   145,   145,    57,    11,    12,    13,    14,    15,
 #if 0 /* No need for malloc.h, which pollutes the namespace;        16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
          instead, just don't use alloca.  */        26,    31,    34,    35,    36,    37,    38,    39,    40,    41,
 #include <malloc.h>        42,    43,    49,    53,    56,   111,   112,   113,   116,   117,
 #endif         4,    48,    50,    80,    99,    57,    60,    61,   143,   143,
 #else /* not MSDOS, or __TURBOC__ */       143,   143,   143,   143,   143,   143,   143,   143,   143,   143,
 #if defined(_AIX)       143,   143,   143,   143,   143,   143,   143,   143,   143,   143,
 /* I don't know what this was needed for, but it pollutes the namespace.       143,   143,   143,   143,   143,   114,    79,   120,   123,   119,
    So I turned it off.   rms, 2 May 1997.  */       122,   142,     3,   112,    73,    50,     4,   103,   118,   121,
 /* #include <malloc.h>  */       124,   147,    51,    54,    51,    57,    79,    51,   115,   123,
  #pragma alloca       122,   121,    50
 #define YYSTACK_USE_ALLOCA  };
 #else /* not MSDOS, or __TURBOC__, or _AIX */  
 #if 0  
 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,  
                  and on HPUX 10.  Eventually we can turn this on.  */  
 #define YYSTACK_USE_ALLOCA  
 #define alloca __builtin_alloca  
 #endif /* __hpux */  
 #endif  
 #endif /* not _AIX */  
 #endif /* not MSDOS, or __TURBOC__ */  
 #endif /* not sparc */  
 #endif /* not GNU C */  
 #endif /* alloca not defined */  
 #endif /* YYSTACK_USE_ALLOCA not defined */  
   
 #ifdef YYSTACK_USE_ALLOCA  #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 #define YYSTACK_ALLOC alloca  # define YYSIZE_T __SIZE_TYPE__
 #else  #endif
 #define YYSTACK_ALLOC malloc  #if ! defined (YYSIZE_T) && defined (size_t)
   # define YYSIZE_T size_t
   #endif
   #if ! defined (YYSIZE_T)
   # if defined (__STDC__) || defined (__cplusplus)
   #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
   #  define YYSIZE_T size_t
   # endif
   #endif
   #if ! defined (YYSIZE_T)
   # define YYSIZE_T unsigned int
 #endif  #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 yyerrok         (yyerrstatus = 0)
 #define yyclearin       (yychar = YYEMPTY)  #define yyclearin       (yychar = YYEMPTY)
 #define YYEMPTY         -2  #define YYEMPTY         (-2)
 #define YYEOF           0  #define YYEOF           0
   
 #define YYACCEPT        goto yyacceptlab  #define YYACCEPT        goto yyacceptlab
 #define YYABORT         goto yyabortlab  #define YYABORT         goto yyabortlab
 #define YYERROR         goto yyerrlab1  #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.  /* 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.  */     Once GCC version 2 has supplanted version 1, this can go.  */
   
 #define YYFAIL          goto yyerrlab  #define YYFAIL          goto yyerrlab
   
 #define YYRECOVERING()  (!!yyerrstatus)  #define YYRECOVERING()  (!!yyerrstatus)
 #define YYBACKUP(token, value) \  
   #define YYBACKUP(Token, Value)                                  \
 do                                                              \  do                                                              \
   if (yychar == YYEMPTY && yylen == 1)                          \    if (yychar == YYEMPTY && yylen == 1)                          \
     { yychar = (token), yylval = (value);                       \      {                                                           \
       yychar1 = YYTRANSLATE (yychar);                           \        yychar = (Token);                                         \
         yylval = (Value);                                         \
         yytoken = YYTRANSLATE (yychar);                           \
       YYPOPSTACK;                                               \        YYPOPSTACK;                                               \
       goto yybackup;                                            \        goto yybackup;                                            \
     }                                                           \      }                                                           \
   else                                                          \    else                                                          \
     { yyerror ("syntax error: cannot back up"); YYERROR; }      \      {                                                           \
         yyerror ("syntax error: cannot back up");\
         YYERROR;                                                  \
       }                                                           \
 while (0)  while (0)
   
 #define YYTERROR        1  #define YYTERROR        1
 #define YYERRCODE       256  #define YYERRCODE       256
   
 #ifndef YYPURE  /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 #define YYLEX           yylex()     are run).  */
 #endif  
   
 #ifdef YYPURE  #ifndef YYLLOC_DEFAULT
 #ifdef YYLSP_NEEDED  # define YYLLOC_DEFAULT(Current, Rhs, N)                \
 #ifdef YYLEX_PARAM     ((Current).first_line   = (Rhs)[1].first_line,       \
 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)      (Current).first_column = (Rhs)[1].first_column,     \
 #else      (Current).last_line    = (Rhs)[N].last_line,        \
 #define YYLEX           yylex(&yylval, &yylloc)      (Current).last_column  = (Rhs)[N].last_column)
 #endif  #endif
 #else /* not YYLSP_NEEDED */  
   /* YYLEX -- calling `yylex' with the right arguments.  */
   
 #ifdef YYLEX_PARAM  #ifdef YYLEX_PARAM
 #define YYLEX           yylex(&yylval, YYLEX_PARAM)  # define YYLEX yylex (&yylval, YYLEX_PARAM)
 #else  #else
 #define YYLEX           yylex(&yylval)  # define YYLEX yylex (&yylval)
 #endif  
 #endif /* not YYLSP_NEEDED */  
 #endif  #endif
   
 /* If nonreentrant, generate the variables here */  /* Enable debugging if requested.  */
   #if YYDEBUG
   
 #ifndef YYPURE  # ifndef YYFPRINTF
   #  include <stdio.h> /* 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           */  | yy_stack_print -- Print the state stack from its BOTTOM up to its |
                                 /*  lookahead symbol                    */  | TOP (included).                                                   |
   `------------------------------------------------------------------*/
   
 #ifdef YYLSP_NEEDED  #if defined (__STDC__) || defined (__cplusplus)
 YYLTYPE yylloc;                 /*  location data for the lookahead     */  static void
                                 /*  symbol                              */  yy_stack_print (short int *bottom, short int *top)
   #else
   static void
   yy_stack_print (bottom, top)
       short int *bottom;
       short int *top;
 #endif  #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     */  | Report that the YYRULE is going to be reduced.  |
 /* Since this is uninitialized, it does not stop multiple parsers  `------------------------------------------------*/
    from coexisting.  */  
   #if defined (__STDC__) || defined (__cplusplus)
   static void
   yy_reduce_print (int yyrule)
   #else
   static void
   yy_reduce_print (yyrule)
       int yyrule;
 #endif  #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]]);
   }
   
 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */  # 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 -- initial size of the parser's stacks.  */
 #ifndef YYINITDEPTH  #ifndef YYINITDEPTH
 #define YYINITDEPTH 200  # define YYINITDEPTH 200
 #endif  #endif
   
 /*  YYMAXDEPTH is the maximum size the stacks can grow to  /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
     (effective only if the built-in stack extension method is used).  */     if the built-in stack extension method is used).
   
      Do not make this value too large; the results are undefined if
      SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
      evaluated with infinite-precision integer arithmetic.  */
   
 #if YYMAXDEPTH == 0  #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
 #undef YYMAXDEPTH  # undef YYMAXDEPTH
 #endif  #endif
   
 #ifndef YYMAXDEPTH  #ifndef YYMAXDEPTH
 #define YYMAXDEPTH 10000  # define YYMAXDEPTH 10000
 #endif  #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  #if YYERROR_VERBOSE
    in available built-in functions on various systems.  */  
 static void  # ifndef yystrlen
 __yy_memcpy (to, from, count)  #  if defined (__GLIBC__) && defined (_STRING_H)
      char *to;  #   define yystrlen strlen
      char *from;  #  else
      unsigned int count;  /* Return the length of YYSTR.  */
 {  static YYSIZE_T
   register char *f = from;  #   if defined (__STDC__) || defined (__cplusplus)
   register char *t = to;  yystrlen (const char *yystr)
   register int i = count;  #   else
   yystrlen (yystr)
        const char *yystr;
   #   endif
   {
     register const char *yys = yystr;
   
   while (i-- > 0)    while (*yys++ != '\0')
     *t++ = *f++;      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;
   
 #else /* __cplusplus */    while ((*yyd++ = *yys++) != '\0')
       continue;
   
 /* This is the most reliable way to avoid incompatibilities    return yyd - 1;
    in available built-in functions on various systems.  */  }
   #  endif
   # endif
   
   #endif /* !YYERROR_VERBOSE */
   
   
   
   #if YYDEBUG
   /*--------------------------------.
   | Print this symbol on YYOUTPUT.  |
   `--------------------------------*/
   
   #if defined (__STDC__) || defined (__cplusplus)
   static void
   yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
   #else
 static void  static void
 __yy_memcpy (char *to, char *from, unsigned int count)  yysymprint (yyoutput, yytype, yyvaluep)
       FILE *yyoutput;
       int yytype;
       YYSTYPE *yyvaluep;
   #endif
 {  {
   register char *t = to;    /* Pacify ``unused variable'' warnings.  */
   register char *f = from;    (void) yyvaluep;
   register int i = count;  
     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)    switch (yytype)
     *t++ = *f++;      {
         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
 #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  /* Prevent warnings from -Wmissing-prototypes.  */
    into yyparse.  The argument should have type void *.  
    It should actually point to an object.  
    Grammar actions can access the variable by casting it  
    to the proper pointer type.  */  
   
 #ifdef YYPARSE_PARAM  #ifdef YYPARSE_PARAM
 #ifdef __cplusplus  # if defined (__STDC__) || defined (__cplusplus)
 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM  int yyparse (void *YYPARSE_PARAM);
 #define YYPARSE_PARAM_DECL  # else
 #else /* not __cplusplus */  int yyparse ();
 #define YYPARSE_PARAM_ARG YYPARSE_PARAM  # endif
 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;  #else /* ! YYPARSE_PARAM */
 #endif /* not __cplusplus */  #if defined (__STDC__) || defined (__cplusplus)
 #else /* not YYPARSE_PARAM */  int yyparse (void);
 #define YYPARSE_PARAM_ARG  #else
 #define YYPARSE_PARAM_DECL  int yyparse ();
 #endif /* not YYPARSE_PARAM */  #endif
   #endif /* ! YYPARSE_PARAM */
   
   
   
   
   
   
   /*----------.
   | yyparse.  |
   `----------*/
   
 /* Prevent warning if -Wstrict-prototypes.  */  
 #ifdef __GNUC__  
 #ifdef YYPARSE_PARAM  #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  #else
 int yyparse (void);  int
   yyparse ()
   
 #endif  #endif
 #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 yystate;
   register int yyn;    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;    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--)  #define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif  
   
   int yystacksize = YYINITDEPTH;    YYSIZE_T yystacksize = YYINITDEPTH;
   int yyfree_stacks = 0;  
   
 #ifdef YYPURE    /* The variables used to return semantic value and location from the
   int yychar;       action routines.  */
   YYSTYPE yylval;    YYSTYPE yyval;
   int yynerrs;  
 #ifdef YYLSP_NEEDED  
   YYLTYPE yylloc;  
 #endif  
 #endif  
   
   YYSTYPE yyval;                /*  the variable used to return         */  
                                 /*  semantic values from the action     */  
                                 /*  routines                            */  
   
     /* When reducing, the number of symbols on the RHS of the reduced
        rule.  */
   int yylen;    int yylen;
   
 #if YYDEBUG != 0    YYDPRINTF ((stderr, "Starting parse\n"));
   if (yydebug)  
     fprintf(stderr, "Starting parse\n");  
 #endif  
   
   yystate = 0;    yystate = 0;
   yyerrstatus = 0;    yyerrstatus = 0;
Line 778  yyparse(YYPARSE_PARAM_ARG) Line 1238  yyparse(YYPARSE_PARAM_ARG)
      so that they stay on the same level as the state stack.       so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */       The wasted elements are never initialized.  */
   
   yyssp = yyss - 1;    yyssp = yyss;
   yyvsp = yyvs;    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)  /*------------------------------------------------------------.
     {  | yynewstate -- Push a new state, which is found in yystate.  |
       /* Give user a chance to reallocate the stack */  `------------------------------------------------------------*/
       /* Use copies of these so that the &'s don't force the real ones into memory. */   yynewstate:
       YYSTYPE *yyvs1 = yyvs;    /* In all cases, when you get here, the value and location stacks
       short *yyss1 = yyss;       have just been pushed. so pushing a state here evens the stacks.
 #ifdef YYLSP_NEEDED       */
       YYLTYPE *yyls1 = yyls;    yyssp++;
 #endif  
   
    yysetstate:
     *yyssp = yystate;
   
     if (yyss + yystacksize - 1 <= yyssp)
       {
       /* Get the current used size of the three stacks, in elements.  */        /* Get the current used size of the three stacks, in elements.  */
       int size = yyssp - yyss + 1;        YYSIZE_T yysize = yyssp - yyss + 1;
   
 #ifdef yyoverflow  #ifdef yyoverflow
       /* Each stack pointer address is followed by the size of        {
          the data in use in that stack, in bytes.  */          /* Give user a chance to reallocate the stack. Use copies of
 #ifdef YYLSP_NEEDED             these so that the &'s don't force the real ones into
       /* This used to be a conditional around just the two extra args,             memory.  */
          but that might be undefined if yyoverflow is a macro.  */          YYSTYPE *yyvs1 = yyvs;
       yyoverflow("parser stack overflow",          short int *yyss1 = yyss;
                  &yyss1, size * sizeof (*yyssp),  
                  &yyvs1, size * sizeof (*yyvsp),  
                  &yyls1, size * sizeof (*yylsp),          /* Each stack pointer address is followed by the size of the
                  &yystacksize);             data in use in that stack, in bytes.  This used to be a
 #else             conditional around just the two extra args, but that might
       yyoverflow("parser stack overflow",             be undefined if yyoverflow is a macro.  */
                  &yyss1, size * sizeof (*yyssp),          yyoverflow ("parser stack overflow",
                  &yyvs1, size * sizeof (*yyvsp),                      &yyss1, yysize * sizeof (*yyssp),
                  &yystacksize);                      &yyvs1, yysize * sizeof (*yyvsp),
 #endif  
                       &yystacksize);
       yyss = yyss1; yyvs = yyvs1;  
 #ifdef YYLSP_NEEDED          yyss = yyss1;
       yyls = yyls1;          yyvs = yyvs1;
 #endif        }
 #else /* no yyoverflow */  #else /* no yyoverflow */
   # ifndef YYSTACK_RELOCATE
         goto yyoverflowlab;
   # else
       /* Extend the stack our own way.  */        /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)        if (YYMAXDEPTH <= yystacksize)
         {          goto yyoverflowlab;
           yyerror("parser stack overflow");  
           if (yyfree_stacks)  
             {  
               free (yyss);  
               free (yyvs);  
 #ifdef YYLSP_NEEDED  
               free (yyls);  
 #endif  
             }  
           return 2;  
         }  
       yystacksize *= 2;        yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)        if (YYMAXDEPTH < yystacksize)
         yystacksize = YYMAXDEPTH;          yystacksize = YYMAXDEPTH;
 #ifndef YYSTACK_USE_ALLOCA  
       yyfree_stacks = 1;        {
 #endif          short int *yyss1 = yyss;
       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));          union yyalloc *yyptr =
       __yy_memcpy ((char *)yyss, (char *)yyss1,            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
                    size * (unsigned int) sizeof (*yyssp));          if (! yyptr)
       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));            goto yyoverflowlab;
       __yy_memcpy ((char *)yyvs, (char *)yyvs1,          YYSTACK_RELOCATE (yyss);
                    size * (unsigned int) sizeof (*yyvsp));          YYSTACK_RELOCATE (yyvs);
 #ifdef YYLSP_NEEDED  
       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));  #  undef YYSTACK_RELOCATE
       __yy_memcpy ((char *)yyls, (char *)yyls1,          if (yyss1 != yyssa)
                    size * (unsigned int) sizeof (*yylsp));            YYSTACK_FREE (yyss1);
 #endif        }
   # endif
 #endif /* no yyoverflow */  #endif /* no yyoverflow */
   
       yyssp = yyss + size - 1;        yyssp = yyss + yysize - 1;
       yyvsp = yyvs + size - 1;        yyvsp = yyvs + yysize - 1;
 #ifdef YYLSP_NEEDED  
       yylsp = yyls + size - 1;  
 #endif  
   
 #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;          YYABORT;
     }      }
   
 #if YYDEBUG != 0    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
   if (yydebug)  
     fprintf(stderr, "Entering state %d\n", yystate);  
 #endif  
   
   goto yybackup;    goto yybackup;
  yybackup:  
   /*-----------.
   | yybackup.  |
   `-----------*/
   yybackup:
   
 /* Do appropriate processing given the current state.  */  /* Do appropriate processing given the current state.  */
 /* Read a lookahead token if we need one and don't already have one.  */  /* Read a lookahead token if we need one and don't already have one.  */
Line 890  yynewstate: Line 1337  yynewstate:
   /* First try to decide what to do without reference to lookahead token.  */    /* First try to decide what to do without reference to lookahead token.  */
   
   yyn = yypact[yystate];    yyn = yypact[yystate];
   if (yyn == YYFLAG)    if (yyn == YYPACT_NINF)
     goto yydefault;      goto yydefault;
   
   /* Not known => get a lookahead token if don't already have one.  */    /* Not known => get a lookahead token if don't already have one.  */
   
   /* yychar is either YYEMPTY or YYEOF    /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
      or a valid token in external form.  */  
   
   if (yychar == YYEMPTY)    if (yychar == YYEMPTY)
     {      {
 #if YYDEBUG != 0        YYDPRINTF ((stderr, "Reading a token: "));
       if (yydebug)  
         fprintf(stderr, "Reading a token: ");  
 #endif  
       yychar = YYLEX;        yychar = YYLEX;
     }      }
   
   /* Convert token to internal form (in yychar1) for indexing tables with */    if (yychar <= YYEOF)
   
   if (yychar <= 0)              /* This means end of input. */  
     {      {
       yychar1 = 0;        yychar = yytoken = YYEOF;
       yychar = YYEOF;           /* Don't call YYLEX any more */        YYDPRINTF ((stderr, "Now at end of input.\n"));
   
 #if YYDEBUG != 0  
       if (yydebug)  
         fprintf(stderr, "Now at end of input.\n");  
 #endif  
     }      }
   else    else
     {      {
       yychar1 = YYTRANSLATE(yychar);        yytoken = YYTRANSLATE (yychar);
         YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
 #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  
     }      }
   
   yyn += yychar1;    /* If the proper action on seeing token YYTOKEN is to reduce or to
   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)       detect an error, take that action.  */
     yyn += yytoken;
     if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;      goto yydefault;
   
   yyn = yytable[yyn];    yyn = yytable[yyn];
     if (yyn <= 0)
   /* yyn is what to do for this token type in this state.  
      Negative => reduce, -yyn is rule number.  
      Positive => shift, yyn is new state.  
        New state is final state => don't bother to shift,  
        just return success.  
      0, or most negative number => error.  */  
   
   if (yyn < 0)  
     {      {
       if (yyn == YYFLAG)        if (yyn == 0 || yyn == YYTABLE_NINF)
         goto yyerrlab;          goto yyerrlab;
       yyn = -yyn;        yyn = -yyn;
       goto yyreduce;        goto yyreduce;
     }      }
   else if (yyn == 0)  
     goto yyerrlab;  
   
   if (yyn == YYFINAL)    if (yyn == YYFINAL)
     YYACCEPT;      YYACCEPT;
   
   /* Shift the lookahead token.  */    /* Shift the lookahead token.  */
     YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
 #if YYDEBUG != 0  
   if (yydebug)  
     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);  
 #endif  
   
   /* Discard the token being shifted unless it is eof.  */    /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)    if (yychar != YYEOF)
     yychar = YYEMPTY;      yychar = YYEMPTY;
   
   *++yyvsp = yylval;    *++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;    yystate = yyn;
   goto yynewstate;    goto yynewstate;
   
 /* Do the default action for the current state.  */  
 yydefault:  
   
   /*-----------------------------------------------------------.
   | yydefault -- do the default action for the current state.  |
   `-----------------------------------------------------------*/
   yydefault:
   yyn = yydefact[yystate];    yyn = yydefact[yystate];
   if (yyn == 0)    if (yyn == 0)
     goto yyerrlab;      goto yyerrlab;
     goto yyreduce;
   
 /* Do a reduction.  yyn is the number of a rule to reduce with.  */  
   /*-----------------------------.
   | yyreduce -- Do a reduction.  |
   `-----------------------------*/
 yyreduce:  yyreduce:
     /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];    yylen = yyr2[yyn];
   if (yylen > 0)  
     yyval = yyvsp[1-yylen]; /* implement default value of the action */  
   
 #if YYDEBUG != 0  
   if (yydebug)  
     {  
       int i;  
   
       fprintf (stderr, "Reducing via rule %d (line %d), ",  
                yyn, yyrline[yyn]);  
   
       /* Print the symbols being reduced, and their result.  */    /* If YYLEN is nonzero, implement the default value of the action:
       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)       `$$ = $1'.
         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:    YY_REDUCE_PRINT (yyn);
 #line 111 "compile.y"    switch (yyn)
 {      {
         Method& method=*NEW Method(POOL,           case 2:
                 PC.request->main_method_name,   #line 132 "compile.y"
                 Method::CT_ANY,      {
           Method* method=new Method(Method::CT_ANY,
                 0, 0, /*min, max numbered_params_count*/                  0, 0, /*min, max numbered_params_count*/
                 0/*param_names*/, 0/*local_names*/,                   0/*param_names*/, 0/*local_names*/, 
                 yyvsp[0]/*parser_code*/, 0/*native_code*/);                  yyvsp[0]/*parser_code*/, 0/*native_code*/);
         PC.cclass->add_method(PC.request->main_method_name, method);          PC.cclass->set_method(PC.alias_method(main_method_name), method);
 ;  ;}
     break;}      break;
 case 8:  
 #line 128 "compile.y"    case 9:
 {  #line 147 "compile.y"
         const String& command=*LA2S(yyvsp[-2]);      {
           const String& command=*LA2S(*yyvsp[-2]);
         YYSTYPE strings_code=yyvsp[0];          YYSTYPE strings_code=yyvsp[0];
         if(strings_code->size()<1*2) {          if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
                 strcpy(PC.error, "@");                  strcpy(PC.error, "@");
                 strcat(PC.error, command.cstr());                  strcat(PC.error, command.cstr());
                 strcat(PC.error, " is empty");                  strcat(PC.error, " is empty");
                 YYERROR;                  YYERROR;
         }          }
         if(command==CLASS_NAME) {          if(command==CLASS_NAME) {
                 if(PC.cclass->base_class()) { // already changed from default?                  if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                         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) {  
                         // new class' name                          // new class' name
                         const String *name=LA2S(strings_code);                          const String& name=*LA2S(*strings_code);
                         // creating the class                          // creating the class
                         PC.cclass=NEW VClass(POOL);                          VStateless_class* cclass=new VClass;
                         PC.cclass->set_name(*name);                          PC.cclass_new=cclass;
                         // append to request's classes                          PC.cclass_new->set_name(name);
                         PC.request->classes().put(*name, PC.cclass);  
                 } else {                  } 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;                          YYERROR;
                 }                  }
         } else if(command==USE_CONTROL_METHOD_NAME) {          } else if(command==USE_CONTROL_METHOD_NAME) {
                 for(int i=0; i<strings_code->size(); i+=2)                   for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) 
                         PC.request->use_file(*LA2S(strings_code, i));                          PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i), PC.request.get_used_filename(PC.file_no));
         } else if(command==BASE_NAME) {          } 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?                  if(PC.cclass->base_class()) { // already changed from default?
                         strcpy(PC.error, "class already have a base '");                          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, "'");                          strcat(PC.error, "'");
                         YYERROR;                          YYERROR;
                 }                  }
                 if(strings_code->size()==1*2) {                  if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                         const String& base_name=*LA2S(strings_code);                          const String& base_name=*LA2S(*strings_code);
                         Value *vbase_class=static_cast<VClass *>(                          if(Value* base_class_value=PC.request.get_class(base_name)) {
                                 PC.request->classes().get(base_name));                                  // @CLASS == @BASE sanity check
                         VStateless_class *base_class=vbase_class?vbase_class->get_class():0;                                  if(VStateless_class *base_class=base_class_value->get_class()) {
                         if(!base_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());                                  strcpy(PC.error, base_name.cstr());
                                 strcat(PC.error, ": undefined class in @"BASE_NAME);                                  strcat(PC.error, ": undefined class in @"BASE_NAME);
                                 YYERROR;                                  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 {                  } else {
                         strcpy(PC.error, "@"BASE_NAME" must contain sole name");                          strcpy(PC.error, "@"BASE_NAME" must contain sole name");
                         YYERROR;                          YYERROR;
                 }                  }
           } else if(command==OPTIONS_CONTROL_METHOD_NAME) {
                   for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) {
                           const String& option=*LA2S(*strings_code, i);
                           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 {          } else {
                 strcpy(PC.error, "'");                  strcpy(PC.error, "'");
                 strncat(PC.error, command.cstr(), MAX_STRING/2);                  strncat(PC.error, command.cstr(), MAX_STRING/2);
                 strcat(PC.error, "' invalid special name. valid names are "                  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;                  YYERROR;
         }          }
 ;  ;}
     break;}      break;
 case 12:  
 #line 195 "compile.y"    case 13:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  
     break;}  
 case 16:  
 #line 200 "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; i<size; i+=2)  
                         *params_names+=LA2S(params_names_code, i);  
         }  
   
         YYSTYPE locals_names_code=yyvsp[-3];  
         Array *locals_names=0;  
         if(int size=locals_names_code->size()) {  
                 locals_names=NEW Array(POOL);  
                 for(int i=0; i<size; i+=2)  
                         *locals_names+=LA2S(locals_names_code, i);  
         }  
   
         Method& method=*NEW Method(POOL,   
                 *name,   
                 Method::CT_ANY,  
                 0, 0/*min,max numbered_params_count*/,   
                 params_names, locals_names,   
                 yyvsp[0], 0);  
         PC.cclass->add_method(*name, method);  
 ;  
     break;}  
 case 19:  
 #line 229 "compile.y"  
 {yyval=yyvsp[-1];  
     break;}  
 case 23:  
 #line 231 "compile.y"  
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;  
     break;}  
 case 29:  
 #line 239 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  
     break;}  
 case 35:  
 #line 245 "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 252 "compile.y"  
 { yyval=yyvsp[0] ;  
     break;}  
 case 39:  
 #line 254 "compile.y"  #line 254 "compile.y"
 { yyval=yyvsp[-1] ;      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
     break;}      break;
 case 42:  
     case 17:
 #line 258 "compile.y"  #line 258 "compile.y"
 {      { 
         yyval=N(POOL);           PC.class_add();
         Array *diving_code=yyvsp[0];          PC.explicit_result=false;
         const String *first_name=LA2S(diving_code);  
         // self.xxx... -> xxx...          YYSTYPE params_names_code=yyvsp[-3];
         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...          ArrayString* params_names=0;
         if(first_name && *first_name==SELF_ELEMENT_NAME) {          if(int size=params_names_code->count()) {
                 O(yyval, OP_WITH_SELF); /* stack: starting context */                  params_names=new ArrayString;
                 P(yyval, diving_code,                   for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE)
                         /* skip over... */                          *params_names+=LA2S(*params_names_code, i);
                         diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);          }
   
           YYSTYPE locals_names_code=yyvsp[-2];
           ArrayString* locals_names=0;
           bool all_vars_local=false;
           if(int size=locals_names_code->count()) {
                   locals_names=new ArrayString;
                   for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
                           const String* local_name=LA2S(*locals_names_code, i);
                           if(*local_name==RESULT_VAR_NAME)
                                   PC.explicit_result=true;
                           else if(*local_name==OPTION_ALL_VARS_LOCAL_NAME)
                                   all_vars_local=true;
                           else
                                   *locals_names+=local_name;
                   }
           }
           if(!all_vars_local && PC.cclass && PC.cclass->is_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, 
                   0/*to be filled later in next {} */, 0, all_vars_local);
   
           *reinterpret_cast<Method**>(&yyval)=method;
   ;}
       break;
   
     case 18:
   #line 296 "compile.y"
       {
                   Method* method=reinterpret_cast<Method*>(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 {          } 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                  // ^if OP_ELEMENT => ^if OP_ELEMENT_OR_OPERATOR
                 // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_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 && diving_code->size()==3)                  if(PC.in_call_value && count==4)
                         diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);                          diving_code->put(count-1, OP::OP_GET_ELEMENT_OR_OPERATOR);
                 P(yyval, diving_code);                  P(*yyval, *diving_code);
         }          }
   #endif
         /* diving code; stack: current context */          /* diving code; stack: current context */
 ;  ;}
     break;}      break;
 case 43:  
 #line 280 "compile.y"    case 45:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 423 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 case 45:      break;
 #line 281 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 47:
     break;}  #line 424 "compile.y"
 case 46:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 #line 285 "compile.y"      break;
 {  
         yyval=yyvsp[-1]; /* stack: context,name */    case 48:
         P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */  #line 428 "compile.y"
 ;      {
     break;}          yyval=N();
 case 50:  #ifdef OPTIMIZE_BYTECODE_CONSTRUCT
 #line 293 "compile.y"          if(maybe_optimize_construct(*yyval, *yyvsp[-1], *yyvsp[0])){
 {                  // $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr)
         yyval=N(POOL);          } else 
         Array *diving_code=yyvsp[0];  #endif
         const String *first_name=LA2S(diving_code);          {
         // $self.xxx... -> $xxx...                  P(*yyval, *yyvsp[-1]); /* stack: context,name */
         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...                  P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
         if(first_name && *first_name==SELF_ELEMENT_NAME) {          }
                 O(yyval, OP_WITH_SELF); /* stack: starting context */  ;}
                 P(yyval, diving_code,       break;
                         /* skip over... */  
                         diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);    case 52:
         } else {  #line 444 "compile.y"
                 O(yyval, OP_WITH_ROOT); /* stack: starting context */      {
                 P(yyval, diving_code);          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 */          /* diving code; stack: current context */
 ;  ;}
     break;}      break;
 case 51:  
 #line 310 "compile.y"    case 53:
 {  #line 470 "compile.y"
         yyval=N(POOL);       {
         O(yyval, OP_WITH_WRITE); /* stack: starting context */          yyval=N(); 
         P(yyval, yyvsp[0]); /* diving code; stack: context,name */          O(*yyval, OP::OP_WITH_WRITE); /* stack: starting context */
 ;          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
     break;}  ;}
 case 52:      break;
 #line 315 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 54:
     break;}  #line 475 "compile.y"
 case 56:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 #line 322 "compile.y"      break;
 {  
     case 58:
   #line 482 "compile.y"
       {
           // allow $result_or_other_variable[ letters here any time ]
           *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
   ;}
       break;
   
     case 59:
   #line 485 "compile.y"
       {
           PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
   ;}
       break;
   
     case 60:
   #line 487 "compile.y"
       {
         // stack: context, name          // stack: context, name
         yyval=yyvsp[-1]; // stack: context, name, value          yyval=yyvsp[-2]; // stack: context, name, value
         O(yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */          O(*yyval, OP::OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
 ;  ;}
     break;}      break;
 case 57:  
 #line 328 "compile.y"    case 61:
 {   #line 493 "compile.y"
         yyval=N(POOL);       { 
         O(yyval, OP_PREPARE_TO_EXPRESSION);          yyval=N(); 
           O(*yyval, OP::OP_PREPARE_TO_EXPRESSION);
         // stack: context, name          // stack: context, name
         P(yyval, yyvsp[-1]); // stack: context, name, value          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) */          O(*yyval, OP::OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
 ;  ;}
     break;}      break;
 case 58:  
 #line 336 "compile.y"    case 62:
 {  #line 501 "compile.y"
       {
         // stack: context, name          // stack: context, name
         yyval=N(POOL);           yyval=N(); 
         OA(yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */          OA(*yyval, OP::OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
 ;  ;}
     break;}      break;
 case 62:  
 #line 347 "compile.y"    case 66:
 {  #line 512 "compile.y"
         yyval=N(POOL);       {
         OA(yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */          yyval=N(); 
           OA(*yyval, OP::OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
         /* some code that writes to that context */          /* some code that writes to that context */
         /* context=pop; stack: context.value() */          /* context=pop; stack: context.value() */
 ;  ;}
     break;}      break;
 case 65:  
 #line 354 "compile.y"    case 69:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 519 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 case 66:      break;
 #line 358 "compile.y"  
 {    case 70:
         yyval=yyvsp[0]; /* stack: value */  #line 523 "compile.y"
         changetail_or_append(yyval,       {
                 OP_CALL, true,  /*->*/ OP_CALL__WRITE,  #ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
                 /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */          if((*yyvsp[0]).count())
 ;  #endif
     break;}          {
 case 67:                  yyval=yyvsp[0]; /* stack: value */
 #line 364 "compile.y"                  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;                                           PC.in_call_value=true; 
                         ;                          ;}
     break;}      break;
 case 68:  
 #line 367 "compile.y"    case 72:
 {  #line 538 "compile.y"
       {
                                 PC.in_call_value=false;                                  PC.in_call_value=false;
                         ;                          ;}
     break;}      break;
 case 69:  
 #line 370 "compile.y"  
 { /* ^field.$method{vasya} */  
         yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */  
   
         YYSTYPE params_code=yyvsp[-1];    case 73:
         if(params_code->size()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]  #line 541 "compile.y"
                 if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?      { /* ^field.$method{vasya} */
                         if(!value->is_defined()) // value is VVoid?  #ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
                                 params_code=0; // ^zzz[] case. don't append lone empty param.  #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
         }          const String* operator_name=LA2S(*yyvsp[-3], 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR);
         /* stack: context, method_junction */  #else
         OA(yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value          const String* operator_name=LA2S(*yyvsp[-3], 1);
 ;  #endif
     break;}          if(operator_name && *operator_name==REM_OPERATOR_NAME){
 case 72:                  yyval=N();
 #line 385 "compile.y"          } else 
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #endif
     break;}                  {
 case 76:                          YYSTYPE params_code=yyvsp[-1];
 #line 391 "compile.y"                          if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void]
 {yyval=yyvsp[-1];                                  if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
     break;}                                          if(value->is_void()) // value is VVoid?
 case 77:                                                  params_code=0; // ^zzz[] case. don't append lone empty param.
 #line 392 "compile.y"                          }
 {yyval=yyvsp[-1];                          /* stack: context, method_junction */
     break;}  
 case 78:                          YYSTYPE var_code=yyvsp[-3];
 #line 393 "compile.y"                          if(
 {yyval=yyvsp[-1];                                  var_code->count()==8
     break;}                                  && (*var_code)[0].code==OP::OP_VALUE__GET_CLASS
 case 80:                                  && (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT
 #line 396 "compile.y"                                  && (*var_code)[4].code==OP::OP_VALUE
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;                                  && (*var_code)[7].code==OP::OP_GET_ELEMENT
     break;}                          ){
 case 82:                                  yyval=N();
 #line 400 "compile.y"                                  O(*yyval, OP::OP_CONSTRUCT_OBJECT);
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;                                  P(*yyval, *var_code, 1/*offset*/, 2/*limit*/); // class name
     break;}                                  P(*yyval, *var_code, 5/*offset*/, 2/*limit*/); // constructor name
 case 84:                                  OA(*yyval, params_code);
 #line 404 "compile.y"                          } else 
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;                                  {
     break;}                                          yyval=var_code; /* with_xxx,diving code; stack: context,method_junction */
 case 85:                                          OA(*yyval, OP::OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
 #line 406 "compile.y"                                  }
 {                  }
   ;}
       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<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
   ;}
       break;
   
     case 81:
   #line 593 "compile.y"
       {
           PC.explicit_result=*reinterpret_cast<bool*>(&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];          yyval=yyvsp[0];
         O(yyval, OP_STORE_PARAM);  ;}
 ;      break;
     break;}  
 case 86:    case 92:
 #line 410 "compile.y"  #line 613 "compile.y"
 {      {
         yyval=N(POOL);           YYSTYPE expr_code=yyvsp[0];
         OA(yyval, OP_EXPR_CODE__STORE_PARAM, 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
     break;}                  yyval=expr_code; 
 case 87:          } else {
 #line 414 "compile.y"                  YYSTYPE code=N();
 {                  O(*code, OP::OP_PREPARE_TO_EXPRESSION);
         yyval=N(POOL);                   P(*code, *expr_code);
         OA(yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);                  O(*code, OP::OP_WRITE_EXPR_RESULT);
 ;                  yyval=N(); 
     break;}                  OA(*yyval, OP::OP_EXPR_CODE__STORE_PARAM, code);
 case 91:          }
 #line 423 "compile.y"  ;}
 {      break;
         yyval=N(POOL);   
         O(yyval, OP_PREPARE_TO_EXPRESSION);    case 93:
         P(yyval, yyvsp[0]);  #line 627 "compile.y"
         O(yyval, OP_WRITE_EXPR_RESULT);      {
 ;          yyval=N(); 
     break;}          OA(*yyval, OP::OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
 case 93:  ;}
 #line 432 "compile.y"      break;
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  
     break;}    case 98:
 case 95:  #line 639 "compile.y"
 #line 434 "compile.y"      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;      break;
     break;}  
 case 97:    case 100:
 #line 436 "compile.y"  #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          // 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          // so we'll not check for operator call possibility as we do in name_advance2
   
         /* stack: context */          /* stack: context */
         yyval=yyvsp[0]; /* stack: context,name */          yyval=yyvsp[0]; /* stack: context,name */
         O(yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */          O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 ;  ;}
     break;}      break;
 case 98:  
 #line 444 "compile.y"    case 103:
 {  #line 651 "compile.y"
       {
         /* stack: context */          /* stack: context */
         yyval=yyvsp[0]; /* stack: context,name */          yyval=yyvsp[0]; /* stack: context,name */
         O(yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */          O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 ;  ;}
     break;}      break;
 case 104:  
 #line 457 "compile.y"    case 109:
 {  #line 664 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT);          O(*yyval, OP::OP_GET_ELEMENT);
 ;  ;}
     break;}      break;
 case 105:  
 #line 461 "compile.y"    case 110:
 {  #line 668 "compile.y"
         Array *code;      {
           YYSTYPE code;
         {          {
                 change_string_literal_to_write_string_literal(code=yyvsp[-1]);                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
                 P(code, yyvsp[0]);                  P(*code, *yyvsp[0]);
         }          }
         yyval=N(POOL);           yyval=N(); 
         OA(yyval, OP_STRING_POOL, code);          OA(*yyval, OP::OP_STRING_POOL, code);
 ;  ;}
     break;}      break;
 case 106:  
 #line 470 "compile.y"    case 111:
 {  #line 677 "compile.y"
         yyval=N(POOL);       {
         OA(yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */          // allow $result_or_other_variable[ letters here any time ]
           *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
   ;}
       break;
   
     case 112:
   #line 680 "compile.y"
       {
           PC.explicit_result=*reinterpret_cast<bool*>(&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 */          /* some code that writes to that context */
         /* context=pop; stack: context.value() */          /* context=pop; stack: context.value() */
 ;  ;}
     break;}      break;
 case 107:  
 #line 476 "compile.y"    case 114:
 {  #line 688 "compile.y"
         yyval=N(POOL);       {
         O(yyval, OP_WITH_READ);          yyval=N(); 
         P(yyval, yyvsp[0]);          O(*yyval, OP::OP_WITH_READ);
 ;          P(*yyval, *yyvsp[0]);
     break;}  ;}
 case 109:      break;
 #line 481 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 116:
     break;}  #line 693 "compile.y"
 case 110:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]); ;}
 #line 482 "compile.y"      break;
 {  
     case 117:
   #line 694 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT__WRITE);          O(*yyval, OP::OP_GET_ELEMENT__WRITE);
 ;  ;}
     break;}      break;
 case 113:  
 #line 491 "compile.y"    case 120:
 {  #line 703 "compile.y"
       {
         yyval=yyvsp[-1]; // stack: class name string          yyval=yyvsp[-1]; // stack: class name string
         if(*LA2S(yyval) == BASE_NAME) { // pseude BASE class          if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
                 if(VStateless_class *base=PC.cclass->base_class()) {                  if(VStateless_class* base=PC.cclass->base_class()) {
                         change_string_literal_value(yyval, base->name());                          change_string_literal_value(*yyval, base->name());
                 } else {                  } else {
                         strcpy(PC.error, "no base class declared");                          strcpy(PC.error, "no base class declared");
                         YYERROR;                          YYERROR;
                 }                  }
         }          }
         O(yyval, OP_GET_CLASS);          // 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 114:      break;
 #line 503 "compile.y"  
 {    case 121:
   #line 716 "compile.y"
       {
         yyval=yyvsp[-1];          yyval=yyvsp[-1];
         if(!PC.in_call_value) {          if(!PC.in_call_value) {
                 strcpy(PC.error, ":: not allowed here");                  strcpy(PC.error, ":: not allowed here");
                 YYERROR;                  YYERROR;
         }          }
         O(yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);          O(*yyval, OP::OP_PREPARE_TO_CONSTRUCT_OBJECT);
 ;  ;}
     break;}      break;
 case 115:  
 #line 515 "compile.y"    case 128:
 {  #line 735 "compile.y"
         // see OP_PREPARE_TO_EXPRESSION!!      { yyval = yyvsp[-1]; ;}
         if((yyval=yyvsp[0])->size()==2) // only one string literal in there?      break;
                 change_string_literal_to_double_literal(yyval); // make that string literal Double  
 ;    case 129:
     break;}  #line 736 "compile.y"
 case 119:      { yyval = yyvsp[-1]; ;}
 #line 524 "compile.y"      break;
 { yyval = yyvsp[-1]; ;  
     break;}    case 130:
 case 120:  #line 737 "compile.y"
 #line 525 "compile.y"      { yyval = yyvsp[-1]; ;}
 { yyval = yyvsp[-1]; ;      break;
     break;}  
 case 121:    case 131:
 #line 526 "compile.y"  #line 739 "compile.y"
 { yyval = yyvsp[-1]; ;      { yyval=yyvsp[0];  O(*yyval, OP::OP_NEG); ;}
     break;}      break;
 case 122:  
 #line 528 "compile.y"    case 132:
 { yyval=yyvsp[0];  O(yyval, OP_NEG) ;  #line 740 "compile.y"
     break;}      { yyval=yyvsp[0]; ;}
 case 123:      break;
 #line 529 "compile.y"  
 { yyval=yyvsp[0] ;    case 133:
     break;}  #line 741 "compile.y"
 case 124:      { yyval=yyvsp[0];    O(*yyval, OP::OP_INV); ;}
 #line 530 "compile.y"      break;
 { yyval=yyvsp[0];        O(yyval, OP_INV) ;  
     break;}    case 134:
 case 125:  #line 742 "compile.y"
 #line 531 "compile.y"      { yyval=yyvsp[0];  O(*yyval, OP::OP_NOT); ;}
 { yyval=yyvsp[0];  O(yyval, OP_NOT) ;      break;
     break;}  
 case 126:    case 135:
 #line 532 "compile.y"  #line 743 "compile.y"
 { yyval=yyvsp[0];  O(yyval, OP_DEF) ;      { yyval=yyvsp[0];  O(*yyval, OP::OP_DEF); ;}
     break;}      break;
 case 127:  
 #line 533 "compile.y"    case 136:
 { yyval=yyvsp[0];  O(yyval, OP_IN) ;  #line 744 "compile.y"
     break;}      { yyval=yyvsp[0];  O(*yyval, OP::OP_IN); ;}
 case 128:      break;
 #line 534 "compile.y"  
 { yyval=yyvsp[0];  O(yyval, OP_FEXISTS) ;    case 137:
     break;}  #line 745 "compile.y"
 case 129:      { yyval=yyvsp[0];  O(*yyval, OP::OP_FEXISTS); ;}
 #line 535 "compile.y"      break;
 { yyval=yyvsp[0];  O(yyval, OP_DEXISTS) ;  
     break;}    case 138:
 case 130:  #line 746 "compile.y"
 #line 537 "compile.y"      { yyval=yyvsp[0];  O(*yyval, OP::OP_DEXISTS); ;}
 {       yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_SUB) ;      break;
     break;}  
 case 131:    case 139:
 #line 538 "compile.y"  #line 748 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_ADD) ;      {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_SUB); ;}
     break;}      break;
 case 132:  
 #line 539 "compile.y"    case 140:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MUL) ;  #line 749 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_ADD); ;}
 case 133:      break;
 #line 540 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_DIV) ;    case 141:
     break;}  #line 750 "compile.y"
 case 134:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MUL); ;}
 #line 541 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MOD) ;  
     break;}    case 142:
 case 135:  #line 751 "compile.y"
 #line 542 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_DIV); ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_INTDIV) ;      break;
     break;}  
 case 136:    case 143:
 #line 543 "compile.y"  #line 752 "compile.y"
 { yyval=yyvsp[-2];      P(yyval, yyvsp[0]);  O(yyval, OP_BIN_AND) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MOD); ;}
     break;}      break;
 case 137:  
 #line 544 "compile.y"    case 144:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_OR) ;  #line 753 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_INTDIV); ;}
 case 138:      break;
 #line 545 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_XOR) ;    case 145:
     break;}  #line 754 "compile.y"
 case 139:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SL); ;}
 #line 546 "compile.y"      break;
 { yyval=yyvsp[-2];  OA(yyval, OP_NESTED_CODE, yyvsp[0]);  O(yyval, OP_LOG_AND) ;  
     break;}    case 146:
 case 140:  #line 755 "compile.y"
 #line 547 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SR); ;}
 { yyval=yyvsp[-2];  OA(yyval, OP_NESTED_CODE, yyvsp[0]);  O(yyval, OP_LOG_OR) ;      break;
     break;}  
 case 141:    case 147:
 #line 548 "compile.y"  #line 756 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_XOR) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_AND); ;}
     break;}      break;
 case 142:  
 #line 549 "compile.y"    case 148:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LT) ;  #line 757 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_OR); ;}
 case 143:      break;
 #line 550 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GT) ;    case 149:
     break;}  #line 758 "compile.y"
 case 144:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_XOR); ;}
 #line 551 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LE) ;  
     break;}    case 150:
 case 145:  #line 759 "compile.y"
 #line 552 "compile.y"      { yyval=yyvsp[-2];  OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP::OP_LOG_AND); ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GE) ;      break;
     break;}  
 case 146:    case 151:
 #line 553 "compile.y"  #line 760 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_EQ) ;      { yyval=yyvsp[-2];  OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP::OP_LOG_OR); ;}
     break;}      break;
 case 147:  
 #line 554 "compile.y"    case 152:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_NE) ;  #line 761 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_LOG_XOR); ;}
 case 148:      break;
 #line 555 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LT) ;    case 153:
     break;}  #line 762 "compile.y"
 case 149:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LT); ;}
 #line 556 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GT) ;  
     break;}    case 154:
 case 150:  #line 763 "compile.y"
 #line 557 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_GT); ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LE) ;      break;
     break;}  
 case 151:    case 155:
 #line 558 "compile.y"  #line 764 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GE) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LE); ;}
     break;}      break;
 case 152:  
 #line 559 "compile.y"    case 156:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_EQ) ;  #line 765 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_GE); ;}
 case 153:      break;
 #line 560 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_NE) ;    case 157:
     break;}  #line 766 "compile.y"
 case 154:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_EQ); ;}
 #line 561 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_IS) ;  
     break;}    case 158:
 case 155:  #line 767 "compile.y"
 #line 564 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_NE); ;}
 {      break;
         yyval=N(POOL);  
         OA(yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */    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 */          /* some code that writes to that context */
         /* context=pop; stack: context.get_string() */          /* context=pop; stack: context.get_string() */
 ;  ;}
     break;}      break;
 case 156:  
 #line 573 "compile.y"    case 168:
 {  #line 803 "compile.y"
         // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE      {
         change_string_literal_to_write_string_literal(yyval=yyvsp[0])          // optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE
 ;          change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]));
     break;}  ;}
 case 157:      break;
 #line 578 "compile.y"  
 { yyval=VL(NEW VVoid(POOL)) ;    case 169:
     break;}  #line 808 "compile.y"
 case 158:      { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0); ;}
 #line 579 "compile.y"      break;
 { yyval=N(POOL) ;  
     break;}    case 170:
 }  #line 809 "compile.y"
    /* the action file gets copied in in place of this dollarsign */      { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vtrue), 0, 0, 0); ;}
 #line 543 "/usr/share/bison.simple"      break;
   
     case 171:
   #line 810 "compile.y"
       { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&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;    yyvsp -= yylen;
   yyssp -= yylen;    yyssp -= yylen;
 #ifdef YYLSP_NEEDED  
   yylsp -= yylen;  
 #endif  
   
 #if YYDEBUG != 0  
   if (yydebug)    YY_STACK_PRINT (yyss, yyssp);
     {  
       short *ssp1 = yyss - 1;  
       fprintf (stderr, "state stack now");  
       while (ssp1 != yyssp)  
         fprintf (stderr, " %d", *++ssp1);  
       fprintf (stderr, "\n");  
     }  
 #endif  
   
   *++yyvsp = yyval;    *++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.    /* Now `shift' the result of the reduction.  Determine what state
      Determine what state that goes to,       that goes to, based on the state we popped back to and the rule
      based on the state we popped back to       number reduced by.  */
      and the rule number reduced by.  */  
   
   yyn = yyr1[yyn];    yyn = yyr1[yyn];
   
   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)    if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     yystate = yytable[yystate];      yystate = yytable[yystate];
   else    else
     yystate = yydefgoto[yyn - YYNTBASE];      yystate = yydefgoto[yyn - YYNTOKENS];
   
   goto yynewstate;    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;        ++yynerrs;
   #if YYERROR_VERBOSE
 #ifdef YYERROR_VERBOSE  
       yyn = yypact[yystate];        yyn = yypact[yystate];
   
       if (yyn > YYFLAG && yyn < YYLAST)        if (YYPACT_NINF < yyn && yyn < YYLAST)
         {          {
           int size = 0;            YYSIZE_T yysize = 0;
           char *msg;            int yytype = YYTRANSLATE (yychar);
           int x, count;            const char* yyprefix;
             char *yymsg;
           count = 0;            int yyx;
           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */  
           for (x = (yyn < 0 ? -yyn : 0);            /* Start YYX at -YYN if negative to avoid negative indexes in
                x < (sizeof(yytname) / sizeof(char *)); x++)               YYCHECK.  */
             if (yycheck[x + yyn] == x)            int yyxbegin = yyn < 0 ? -yyn : 0;
               size += strlen(yytname[x]) + 15, count++;  
           msg = (char *) malloc(size + 15);            /* Stay within bounds of both yycheck and yytname.  */
           if (msg != 0)            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;                    yyprefix = ", expecting ";
                   for (x = (yyn < 0 ? -yyn : 0);                    for (yyx = yyxbegin; yyx < yyxend; ++yyx)
                        x < (sizeof(yytname) / sizeof(char *)); x++)                      if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                     if (yycheck[x + yyn] == x)  
                       {                        {
                         strcat(msg, count == 0 ? ", expecting `" : " or `");                          yyp = yystpcpy (yyp, yyprefix);
                         strcat(msg, yytname[x]);                          yyp = yystpcpy (yyp, yytname[yyx]);
                         strcat(msg, "'");                          yyprefix = " or ";
                         count++;  
                       }                        }
                 }                  }
               yyerror(msg);                yyerror (yymsg);
               free(msg);                YYSTACK_FREE (yymsg);
             }              }
           else            else
             yyerror ("parse error; also virtual memory exceeded");              yyerror ("syntax error; also virtual memory exhausted");
         }          }
       else        else
 #endif /* YYERROR_VERBOSE */  #endif /* YYERROR_VERBOSE */
         yyerror("parse error");          yyerror ("syntax error");
     }      }
   
   goto yyerrlab1;  
 yyerrlab1:   /* here on error raised explicitly by an action */  
   
   if (yyerrstatus == 3)    if (yyerrstatus == 3)
     {      {
       /* if just tried and failed to reuse lookahead token after an error, discard it.  */        /* If just tried and failed to reuse lookahead token after an
            error, discard it.  */
       /* return failure if at end of input */  
       if (yychar == YYEOF)  
         YYABORT;  
   
 #if YYDEBUG != 0        if (yychar <= YYEOF)
       if (yydebug)          {
         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);            /* If at end of input, pop the error token,
 #endif               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    /* Else will try to reuse lookahead token after shifting the error
      after shifting the error token.  */       token.  */
     goto yyerrlab1;
   yyerrstatus = 3;              /* Each real token shifted decrements this */  
   
   goto yyerrhandle;  
   
 yyerrdefault:  /* current state does not do anything special for the error token. */  /*---------------------------------------------------.
   | yyerrorlab -- error raised explicitly by YYERROR.  |
   `---------------------------------------------------*/
   yyerrorlab:
   
 #if 0  #ifdef __GNUC__
   /* This is wrong; only states that explicitly want error tokens    /* Pacify GCC when the user code never invokes YYERROR and the label
      should shift them.  */       yyerrorlab therefore never appears in user code.  */
   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/    if (0)
   if (yyn) goto yydefault;       goto yyerrorlab;
 #endif  #endif
   
 yyerrpop:   /* pop the current state because it cannot handle the error token */    yyvsp -= yylen;
     yyssp -= yylen;
   if (yyssp == yyss) YYABORT;    yystate = *yyssp;
   yyvsp--;    goto yyerrlab1;
   yystate = *--yyssp;  
 #ifdef YYLSP_NEEDED  
   yylsp--;  
 #endif  
   
 #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];    for (;;)
   if (yyn == YYFLAG)      {
     goto yyerrdefault;        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;        /* Pop the current state because it cannot handle the error token.  */
   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)        if (yyssp == yyss)
     goto yyerrdefault;          YYABORT;
   
   yyn = yytable[yyn];        YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
   if (yyn < 0)        yydestruct (yystos[yystate], yyvsp);
     {        YYPOPSTACK;
       if (yyn == YYFLAG)        yystate = *yyssp;
         goto yyerrpop;        YY_STACK_PRINT (yyss, yyssp);
       yyn = -yyn;  
       goto yyreduce;  
     }      }
   else if (yyn == 0)  
     goto yyerrpop;  
   
   if (yyn == YYFINAL)    if (yyn == YYFINAL)
     YYACCEPT;      YYACCEPT;
   
 #if YYDEBUG != 0    YYDPRINTF ((stderr, "Shifting error token, "));
   if (yydebug)  
     fprintf(stderr, "Shifting error token, ");  
 #endif  
   
   *++yyvsp = yylval;    *++yyvsp = yylval;
 #ifdef YYLSP_NEEDED  
   *++yylsp = yylloc;  
 #endif  
   
   yystate = yyn;    yystate = yyn;
   goto yynewstate;    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.  */  | yyacceptlab -- YYACCEPT comes here.  |
   if (yyfree_stacks)  `-------------------------------------*/
     {  yyacceptlab:
       free (yyss);    yyresult = 0;
       free (yyvs);    goto yyreturn;
 #ifdef YYLSP_NEEDED  
       free (yyls);  /*-----------------------------------.
   | 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  #endif
     }    return yyresult;
   return 1;  
 }  }
 #line 581 "compile.y"  
   
   #line 814 "compile.y"
   
 #endif  #endif
   
Line 1884  yyerrhandle: Line 2647  yyerrhandle:
                 4:[^({]=pop                  4:[^({]=pop
 */  */
   
 static int yylex(YYSTYPE *lvalp, void *pc) {  inline void ungetc(Parse_control& pc, uint last_line_end_col) {
         #define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp]          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<Parse_control*>(apc);
   
           #define lexical_brackets_nestage pc.brackets_nestages[pc.ls_sp]
         #define RC {result=c; goto break2; }          #define RC {result=c; goto break2; }
   
     register int c;          register int c;
     int result;          int result;
                   
         if(PC.pending_state) {          if(pc.pending_state) {
                 result=PC.pending_state;                  result=pc.pending_state;
                 PC.pending_state=0;                  pc.pending_state=0;
                 return result;                  return result;
         }          }
                   
         const char *begin=PC.source;          const char *begin=pc.source;
           Pos begin_pos=pc.pos;
         const char *end;          const char *end;
         int begin_line=PC.line;  
         int skip_analized=0;          int skip_analized=0;
         while(true) {          while(true) {
                 c=*(end=(PC.source++));                  c=*(end=(pc.source++));
 //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp);  //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp);
   
                 if(c=='\n') {                  if(c=='\n')
                         PC.line++;                          pc.pos_next_line();
                         PC.col=0;                  else
                 } else                          pc.pos_next_c(c);
                         PC.col++;  //              fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col);
   
                 if(c=='@' && PC.col==0+1) {                  if(pc.pos.col==0+1 && c=='@') {
                         if(PC.ls==LS_DEF_SPECIAL_BODY) {                          if(pc.ls==LS_DEF_SPECIAL_BODY) {
                                 // @SPECIAL                                  // @SPECIAL
                                 // ...                                  // ...
                                 // @<here =                                   // @<here = 
                                 pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state                                  pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state
                         } // continuing checks                          } // continuing checks
                         if(PC.ls==LS_USER) {                          if(pc.ls==LS_USER) {
                                 push_LS(PC, LS_DEF_NAME);                                  push_LS(pc, LS_DEF_NAME);
                                 RC;                                  RC;
                         } else // @ in first column inside some code [when could that be?]                          } else // @ in first column inside some code [when could that be?]
                                 result=BAD_METHOD_DECL_START;                                  result=BAD_METHOD_DECL_START;
                         goto break2;                          goto break2;
                 } else if(c=='^')                  }
                         switch(PC.ls) {                  if(c=='^') {
                           if(pc.ls==LS_METHOD_AFTER) {
                                   // handle after-method situation
                                   pop_LS(pc);
                                   result=EON;
                                   skip_analized=-1; // return to punctuation afterwards to assure it's literality
                                   goto break2;
                           }
                           switch(pc.ls) {
 case LS_EXPRESSION_VAR_NAME_WITH_COLON:  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
 case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
 case LS_VAR_NAME_SIMPLE_WITH_COLON:  case LS_VAR_NAME_SIMPLE_WITH_COLON:
Line 1937  case LS_DEF_COMMENT: Line 2718  case LS_DEF_COMMENT:
         // no literals in names, please          // no literals in names, please
         break;          break;
 default:  default:
                         switch(*PC.source) {                          switch(*pc.source) {
                         // ^escaping some punctuators                          // ^escaping some punctuators
                         case '^': case '$': case ';':                          case '^': case '$': case ';': case '@':
                         case '(': case ')':                          case '(': case ')':
                         case '[': case ']':                          case '[': case ']':
                         case '{': case '}':                          case '{': case '}':
                         case '"':  case ':':                          case '"':  case ':':
                                 if(end!=begin) {                                  if(end!=begin) {
                                           if(!pc.string_start)
                                                   pc.string_start=begin_pos;
                                         // append piece till ^                                          // append piece till ^
                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);                                          pc.string.append_strdup_know_length(begin, end-begin);
                                 }                                  }
                                 // reset piece 'begin' position & line                                  // reset piece 'begin' position & line
                                 end=begin=PC.source; // ^                                  begin=pc.source; // ->punctuation
                                 begin_line=PC.line;                                  begin_pos=pc.pos;
                                 if(PC.ls==LS_METHOD_AFTER) {                                  // skip over _ after ^
                                         pop_LS(PC);                                  pc.source++;  pc.pos.col++;
                                         result=EON;                                  // skip analysis = forced literal
                                         skip_analized=-1; // return to ^ afterwards to assure it's literality                                  continue;
                                         goto break2;  
                                 } else {  
                                         // skip over _ after ^  
                                         PC.source++;  PC.col++;  
                                         // skip analysis = forced literal  
                                         continue;  
                                 }  
   
                         // converting ^#HH into char(hex(HH))                          // converting ^#HH into char(hex(HH))
                         case '#':                          case '#':
                                 if(end!=begin) {                                  if(end!=begin) {
                                           if(!pc.string_start)
                                                   pc.string_start=begin_pos;
                                         // append piece till ^                                          // append piece till ^
                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);                                          pc.string.append_strdup_know_length(begin, end-begin);
                                 }                                  }
                                 // #HH ?                                  // #HH ?
                                 if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) {                                  if(pc.source[1] && isxdigit(pc.source[1]) && pc.source[2] && isxdigit(pc.source[2])) {
                                         char *hex=(char *)POOL.malloc(1);                                          char c=(char)(
                                         hex[0]=                                                  hex_value[(unsigned char)pc.source[1]]*0x10+
                                                 hex_value[(unsigned char)PC.source[1]]*0x10+                                                  hex_value[(unsigned char)pc.source[2]]);
                                                 hex_value[(unsigned char)PC.source[2]];                                          if(c==0) {
                                         if(hex[0]==0) {  
                                                 result=BAD_HEX_LITERAL;                                                  result=BAD_HEX_LITERAL;
                                                 goto break2; // wrong hex value[no ^#00 chars allowed]: bail out                                                  goto break2; // wrong hex value[no ^#00 chars allowed]: bail out
                                         }                                          }
                                         // append char(hex(HH))                                          // append char(hex(HH))
                                         PC.string->APPEND_CLEAN(hex, 1, PC.file, begin_line);                                          pc.string.append(c);
                                         // skip over ^#HH                                          // skip over ^#HH
                                         PC.source+=3;                                          pc.source+=3;
                                         PC.col+=3;                                          pc.pos.col+=3;
                                         // reset piece 'begin' position & line                                          // reset piece 'begin' position & line
                                         begin=PC.source; // ^                                          begin=pc.source; // ->after ^#HH
                                         begin_line=PC.line;                                          begin_pos=pc.pos;
                                           // skip analysis = forced literal
                                         continue;                                          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;                          break;
                           }
                 }                  }
                 // #comment  start skipping                  // #comment  start skipping
                 if(c=='#' && PC.col==1) {                  if(c=='#' && pc.pos.col==1) {
                         if(end!=begin) {                          if(end!=begin) {
                                   if(!pc.string_start)
                                           pc.string_start=begin_pos;
                                 // append piece till #                                  // 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]                          // fall into COMMENT lexical state [wait for \n]
                         push_LS(PC, LS_USER_COMMENT);                          push_LS(pc, LS_USER_COMMENT);
                         continue;                          continue;
                 }                  }
                 switch(PC.ls) {                  switch(pc.ls) {
   
                 // USER'S = NOT OURS                  // USER'S = NOT OURS
                 case LS_USER:                  case LS_USER:
         case LS_NAME_SQUARE_PART: // name.[here].xxx                  case LS_NAME_SQUARE_PART: // name.[here].xxx
                         if(PC.trim_bof)                          if(pc.trim_bof)
                                 switch(c) {                                  switch(c) {
                                 case '\n': case ' ': case '\t':                                  case '\n': case ' ': case '\t':
                                         begin=PC.source;                                          begin=pc.source;
                                         begin_line=PC.line;                                          begin_pos=pc.pos;
                                         continue; // skip it                                          continue; // skip it
                                 default:                                  default:
                                         PC.trim_bof=false;                                          pc.trim_bof=false;
                                 }                                  }
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case ']':                          case ']':
                                 if(PC.ls==LS_NAME_SQUARE_PART)                                  if(pc.ls==LS_NAME_SQUARE_PART)
                                         if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>                                          if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
                                                 pop_LS(PC); // $name.[co<]>de<]!>                                                  pop_LS(pc); // $name.[co<]>de<]!>
                                                 RC;                                                  RC;
                                         }                                          }
                                 break;                                  break;
                         case '[': // $name.[co<[>de]                          case '[': // $name.[co<[>de]
                                 if(PC.ls==LS_NAME_SQUARE_PART)                                  if(pc.ls==LS_NAME_SQUARE_PART)
                                         lexical_brackets_nestage++;                                          lexical_brackets_nestage++;
                                 break;                                  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;                          break;
                                                   
                 // #COMMENT                  // #COMMENT
                 case LS_USER_COMMENT:                  case LS_USER_COMMENT:
                         if(c=='\n') {                          if(c=='\n') {
                                 // skip comment                                  // skip comment
                                 begin=PC.source;                                  begin=pc.source;
                                 begin_line=PC.line;                                  begin_pos=pc.pos;
   
                                 pop_LS(PC);                                  pop_LS(pc);
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
Line 2057  default: Line 2855  default:
                         case '"':                          case '"':
                         case '\'':                          case '\'':
                                 if(                                  if(
                                         PC.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' ||                                          pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' ||
                                         PC.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {                                          pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {
                                         pop_LS(PC); //"abc". | 'abc'.                                          pop_LS(pc); //"abc". | 'abc'.
                                         RC;                                          RC;
                                 }                                  }
                                 break;                                  break;
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2076  default: Line 2874  default:
                 case LS_DEF_NAME:                  case LS_DEF_NAME:
                         switch(c) {                          switch(c) {
                         case '[':                          case '[':
                                 PC.ls=LS_DEF_PARAMS;                                  pc.ls=LS_DEF_PARAMS;
                                 RC;                                  RC;
                         case '\n':                          case '\n':
                                 PC.ls=LS_DEF_SPECIAL_BODY;                                  pc.ls=LS_DEF_SPECIAL_BODY;
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2092  default: Line 2890  default:
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case ']':                          case ']':
                                 PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;                                  pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
                                 RC;                                  RC;
                         case '\n': // wrong. bailing out                          case '\n': // wrong. bailing out
                                 pop_LS(PC);                                  pop_LS(pc);
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2106  default: Line 2904  default:
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case ']':                          case ']':
                                 PC.ls=LS_DEF_COMMENT;                                  pc.ls=LS_DEF_COMMENT;
                                 RC;                                  RC;
                         case '\n': // wrong. bailing out                          case '\n': // wrong. bailing out
                                 pop_LS(PC);                                  pop_LS(pc);
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
   
                 case LS_DEF_COMMENT:                  case LS_DEF_COMMENT:
                         if(c=='\n') {                          if(c=='\n') {
                                 pop_LS(PC);                                  pop_LS(pc);
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2132  default: Line 2930  default:
                         switch(c) {                          switch(c) {
                         case ')':                          case ')':
                                 if(--lexical_brackets_nestage==0)                                  if(--lexical_brackets_nestage==0)
                                         if(PC.ls==LS_METHOD_ROUND) // method round param ended                                          if(pc.ls==LS_METHOD_ROUND) // method round param ended
                                                 PC.ls=LS_METHOD_AFTER; // look for method end                                                  pc.ls=LS_METHOD_AFTER; // look for method end
                                         else // PC.ls==LS_VAR_ROUND // variable constructor ended                                          else // pc.ls==LS_VAR_ROUND // variable constructor ended
                                                 pop_LS(PC); // return to normal life                                                  pop_LS(pc); // return to normal life
                                 RC;                                  RC;
                         case '#': // comment start skipping                          case '#': // comment start skipping
                                 if(end!=begin) {                                  if(end!=begin) {
                                           if(!pc.string_start)
                                                   pc.string_start=begin_pos;
                                         // append piece till #                                          // 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]                                  // fall into COMMENT lexical state [wait for \n]
                                 push_LS(PC, LS_EXPRESSION_COMMENT);                                  push_LS(pc, LS_EXPRESSION_COMMENT);
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 continue;                                  continue;
                         case '$':                          case '$':
                                 push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);                                                           push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON);                         
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case '(':                          case '(':
                                 lexical_brackets_nestage++;                                  lexical_brackets_nestage++;
                                 RC;                                  RC;
                         case '-':                          case '-':
                                 switch(*PC.source) {                                  switch(*pc.source) {
                                 case 'f': // -f                                  case 'f': // -f
                                         skip_analized=1;                                          skip_analized=1;
                                         result=FEXISTS;                                          result=FEXISTS;
Line 2175  default: Line 2975  default:
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case '&': case '|':                          case '&': case '|':
                                 if(*PC.source==c) { // && ||                                  if(*pc.source==c) { // && ||
                                         result=c=='&'?LAND:LOR;                                          result=c=='&'?LAND:LOR;
                                         skip_analized=1;                                          skip_analized=1;
                                 } else                                  } else
                                         result=c;                                          result=c;
                                 goto break2;                                  goto break2;
                         case '!':                          case '!':
                                 switch(PC.source[0]) {                                   switch(pc.source[0]) { 
                                 case '|': // !| !||                                  case '|': // !| !||
                                         skip_analized=1;                                          skip_analized=1;
                                         if(PC.source[1]=='|') {                                          if(pc.source[1]=='|') {
                                                 skip_analized++;                                                  skip_analized++;
                                                 result=LXOR;                                                  result=LXOR;
                                         } else                                          } else
Line 2197  default: Line 2997  default:
                                         goto break2;                                          goto break2;
                                 }                                  }
                                 RC;                                  RC;
                         case '<': case '>': case '=':   
                                 if(*PC.source=='=') { // <= >= ==                          case '<': // <<, <=, <
                                         skip_analized=1;                                  switch(*pc.source) {
                                         switch(c) {                                  case '<': // <[<]
                                         case '<': result=NLE; break;                                          skip_analized=1; result=NSL; break;
                                         case '>': result=NGE; break;                                  case '=': // <[=]
                                         case '=': result=NEQ; break;                                          skip_analized=1; result=NLE; break;
                                         }                                  default: // <[]
                                 } else                                          result=c; break;
                                         result=c;                                  }
                                 goto break2;                                  goto break2;
                           case '>': // >>, >=, >
                                   switch(*pc.source) {
                                   case '>': // >[>]
                                           skip_analized=1; result=NSR; break;
                                   case '=': // >[=]
                                           skip_analized=1; result=NGE; break;
                                   default: // >[]
                                           result=c; break;
                                   }
                                   goto break2;
                           case '=': // ==
                                   switch(*pc.source) {
                                   case '=': // =[=]
                                           skip_analized=1; result=NEQ; break;
                                   default: // =[]
                                           result=c; break; // not used now
                                   }
                                   goto break2;
   
                         case '"':                          case '"':
                                 push_LS(PC, LS_EXPRESSION_STRING_QUOTED);                                  push_LS(pc, LS_EXPRESSION_STRING_QUOTED);
                                 RC;                                  RC;
                         case '\'':                          case '\'':
                                 push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED);                                  push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED);
                                 RC;                                  RC;
                         case 'l': case 'g': case 'e': case 'n':                          case 'l': case 'g': case 'e': case 'n':
                                 if(end==begin) // right after whitespace                                  if(end==begin) // right after whitespace
                                         if(isspace(PC.source[1])) {                                          if(isspace(pc.source[1])) {
                                                 switch(*PC.source) {                                                  switch(*pc.source) {
                                                         //                                      case '?': // ok [and bad cases, yacc would bark at them]                                                          //                                      case '?': // ok [and bad cases, yacc would bark at them]
                                                 case 't': // lt gt [et nt]                                                  case 't': // lt gt [et nt]
                                                         result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;                                                          result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;
Line 2236  default: Line 3055  default:
                                 break;                                  break;
                         case 'i':                          case 'i':
                                 if(end==begin) // right after whitespace                                  if(end==begin) // right after whitespace
                                         if(isspace(PC.source[1])) {                                          if(isspace(pc.source[1])) {
                                                 switch(PC.source[0]) {                                                  switch(pc.source[0]) {
                                                 case 'n': // in                                                  case 'n': // in
                                                         skip_analized=1;                                                          skip_analized=1;
                                                         result=IN;                                                          result=IN;
Line 2251  default: Line 3070  default:
                                 break;                                  break;
                         case 'd':                          case 'd':
                                 if(end==begin) // right after whitespace                                  if(end==begin) // right after whitespace
                                         if(PC.source[0]=='e' && PC.source[1]=='f') { // def                                          if(pc.source[0]=='e' && pc.source[1]=='f') { // def
                                                 skip_analized=2;                                                  switch(pc.source[2]){
                                                 result=DEF;                                                  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;                                                  goto break2;
                                         }                                          }
                                 break;                                  break;
Line 2265  default: Line 3104  default:
                                 // that's a leading|traling space or after-operator-space                                  // that's a leading|traling space or after-operator-space
                                 // ignoring it                                  // ignoring it
                                 // reset piece 'begin' position & line                                  // reset piece 'begin' position & line
                                 begin=PC.source; // after whitespace char                                  begin=pc.source; // after whitespace char
                                 begin_line=PC.line;                                  begin_pos=pc.pos;
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
Line 2274  default: Line 3113  default:
                         if(c=='(')                          if(c=='(')
                                 lexical_brackets_nestage++;                                  lexical_brackets_nestage++;
                                                   
                         switch(*PC.source) {                          switch(*pc.source) {
                         case '\n': case ')':                          case '\n': case ')':
                                 if(*PC.source==')')                                  if(*pc.source==')')
                                         if(--lexical_brackets_nestage!=0)                                          if(--lexical_brackets_nestage!=0)
                                                 continue;                                                  continue;
   
                                 // skip comment                                  // skip comment
                                 begin=PC.source;                                  begin=pc.source;
                                 begin_line=PC.line;                                  begin_pos=pc.pos;
   
                                 pop_LS(PC);                                  pop_LS(pc);
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
Line 2295  default: Line 3134  default:
                 case LS_EXPRESSION_VAR_NAME_WITH_COLON:                   case LS_EXPRESSION_VAR_NAME_WITH_COLON: 
                 case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:                  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
                         if(                          if(
                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||                                  pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {                                  pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                 // name in expr ends also before                                   // name in expr ends also before 
                                 switch(c) {                                  switch(c) {
                                 // expression minus                                  // expression minus
                                 case '-':                                   case '-': 
                                 // expression integer division                                  // expression integer division
                                 case '\\':                                  case '\\':
                                         pop_LS(PC);                                          pop_LS(pc);
                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }                                          pc.ungetc();
                                         result=EON;                                          result=EON;
                                         goto break2;                                          goto break2;
                                 }                                  }
                         }                          }
                         if(                          if(
                                 PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||                                  pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||
                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {                                  pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                 // name already has ':', stop before next                                   // name already has ':', stop before next 
                                 switch(c) {                                  switch(c) {
                                 case ':':                                   case ':': 
                                         pop_LS(PC);                                          pop_LS(pc);
                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }                                          pc.ungetc();
                                         result=EON;                                          result=EON;
                                         goto break2;                                          goto break2;
                                 }                                  }
Line 2328  default: Line 3167  default:
                         case ']': case '}': case ')':                           case ']': case '}': case ')': 
                         case '"': case '\'':                          case '"': case '\'':
                         case '<': case '>':  // these stand for HTML brackets AND expression binary ops                          case '<': case '>':  // these stand for HTML brackets AND expression binary ops
                         case '+': case '*': case '/': case '%':                           case '+': case '*': case '/': case '\\': case '%': 
                         case '&': case '|':                           case '&': case '|': 
                         case '=': case '!':                          case '=': case '!':
                         // common delimiters                          // common delimiters
                         case ',': case '?': case '#':                          case ',': case '?': case '#':
                           // mysql column separators
                           case '`':
                         // before call                          // before call
                         case '^':                           case '^': 
                                 pop_LS(PC);                                  pop_LS(pc);
                                 PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }                                  pc.ungetc();
                                 result=EON;                                  result=EON;
                                 goto break2;                                  goto break2;
                         case '[':                          case '[':
                                 // $name.<[>code]                                  // $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 start of get*/ ||
                                         end[-1]==':'/*was class name delim */ ||                                          end[-1]==':'/*was class name delim */ ||
                                         end[-1]=='.'/*was 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;                                          lexical_brackets_nestage=1;
                                         RC;                                          RC;
                                 }                                  }
                                 PC.ls=LS_VAR_SQUARE;                                  pc.ls=LS_VAR_SQUARE;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '{':                          case '{':
                                 if(begin==end) { // ${name}, no need of EON, switching LS                                  if(begin==end) { // ${name}, no need of EON, switching LS
                                         PC.ls=LS_VAR_NAME_CURLY;                                           pc.ls=LS_VAR_NAME_CURLY; 
                                 } else {                                  } else {
                                         PC.ls=LS_VAR_CURLY;                                          pc.ls=LS_VAR_CURLY;
                                         lexical_brackets_nestage=1;                                          lexical_brackets_nestage=1;
                                 }                                  }
   
                                 RC;                                  RC;
                         case '(':                          case '(':
                                 PC.ls=LS_VAR_ROUND;                                  pc.ls=LS_VAR_ROUND;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '.': // name part delim                          case '.': // name part delim
                         case '$': // name part subvar                          case '$': // name part subvar
                         case ':': // class<:>name                          case ':': // class<:>name
                                 // go to _WITHOUT_COLON state variant...                                  // go to _WITHOUT_COLON state variant...
                                 if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)                                  if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
                                         PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;                                          pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
                                 else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)                                  else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
                                         PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;                                          pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
                                 // ...stop before next ':'                                  // ...stop before next ':'
                                 RC;                                  RC;
                         }                          }
Line 2383  default: Line 3224  default:
                         switch(c) {                          switch(c) {
                         case '[':                          case '[':
                                 // ${name.<[>code]}                                  // ${name.<[>code]}
                                 push_LS(PC, LS_NAME_SQUARE_PART);                                  push_LS(pc, LS_NAME_SQUARE_PART);
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '}': // ${name} finished, restoring LS                          case '}': // ${name} finished, restoring LS
                                 pop_LS(PC);                                  pop_LS(pc);
                                 RC;                                  RC;
                         case '.': // name part delim                          case '.': // name part delim
                         case '$': // name part subvar                          case '$': // name part subvar
Line 2399  default: Line 3240  default:
                 case LS_VAR_SQUARE:                  case LS_VAR_SQUARE:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case ']':                          case ']':
                                 if(--lexical_brackets_nestage==0) {                                  if(--lexical_brackets_nestage==0) {
                                         pop_LS(PC);                                          pop_LS(pc);
                                         RC;                                          RC;
                                 }                                  }
                                 break;                                  break;
Line 2421  default: Line 3262  default:
                 case LS_VAR_CURLY:                  case LS_VAR_CURLY:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case '}':                          case '}':
                                 if(--lexical_brackets_nestage==0) {                                  if(--lexical_brackets_nestage==0) {
                                         pop_LS(PC);                                          pop_LS(pc);
                                         RC;                                          RC;
                                 }                                  }
                                 break;                                  break;
Line 2443  default: Line 3284  default:
                         switch(c) {                          switch(c) {
                         case '[':                          case '[':
                                 // ^name.<[>code].xxx                                  // ^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 start of call*/ || // never, ^[ is literal...
                                         end[-1]==':'/*was class name delim */ ||                                          end[-1]==':'/*was class name delim */ ||
                                         end[-1]=='.'/*was 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;                                          lexical_brackets_nestage=1;
                                         RC;                                          RC;
                                 }                                  }
                                 PC.ls=LS_METHOD_SQUARE;                                  pc.ls=LS_METHOD_SQUARE;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '{':                          case '{':
                                 PC.ls=LS_METHOD_CURLY;                                  pc.ls=LS_METHOD_CURLY;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '(':                          case '(':
                                 PC.ls=LS_METHOD_ROUND;                                  pc.ls=LS_METHOD_ROUND;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '.': // name part delim                           case '.': // name part delim 
Line 2468  default: Line 3309  default:
                         case ':': // ':name' or 'class:name'                          case ':': // ':name' or 'class:name'
                         case '^': // ^abc^xxx wrong. bailing out                          case '^': // ^abc^xxx wrong. bailing out
                         case ']': case '}': case ')': // ^abc]}) wrong. bailing out                          case ']': case '}': case ')': // ^abc]}) wrong. bailing out
                           case ' ': // ^if ( wrong. bailing out
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2475  default: Line 3317  default:
                 case LS_METHOD_SQUARE:                  case LS_METHOD_SQUARE:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case ';': // param delim                          case ';': // param delim
                                 RC;                                  RC;
                         case ']':                          case ']':
                                 if(--lexical_brackets_nestage==0) {                                  if(--lexical_brackets_nestage==0) {
                                         PC.ls=LS_METHOD_AFTER;                                          pc.ls=LS_METHOD_AFTER;
                                         RC;                                          RC;
                                 }                                  }
                                 break;                                  break;
Line 2497  default: Line 3339  default:
                 case LS_METHOD_CURLY:                  case LS_METHOD_CURLY:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);                                  push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                 RC;                                  RC;
                         case '^':                          case '^':
                                 push_LS(PC, LS_METHOD_NAME);                                  push_LS(pc, LS_METHOD_NAME);
                                 RC;                                  RC;
                         case ';': // param delim                          case ';': // param delim
                                 RC;                                  RC;
                         case '}':                          case '}':
                                 if(--lexical_brackets_nestage==0) {                                  if(--lexical_brackets_nestage==0) {
                                         PC.ls=LS_METHOD_AFTER;                                          pc.ls=LS_METHOD_AFTER;
                                         RC;                                          RC;
                                 }                                  }
                                 break;                                  break;
Line 2514  default: Line 3356  default:
                                 lexical_brackets_nestage++;                                  lexical_brackets_nestage++;
                                 break;                                  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;                          break;
   
                 case LS_METHOD_AFTER:                  case LS_METHOD_AFTER:
                         if(c=='[') {/* ][ }[ )[ */                          if(c=='[') {/* ][ }[ )[ */
                                 PC.ls=LS_METHOD_SQUARE;                                  pc.ls=LS_METHOD_SQUARE;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         }                                                                    }                                          
                         if(c=='{') {/* ]{ }{ ){ */                          if(c=='{') {/* ]{ }{ ){ */
                                 PC.ls=LS_METHOD_CURLY;                                  pc.ls=LS_METHOD_CURLY;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         }                                                                    }                                          
                         if(c=='(') {/* ]( }( )( */                          if(c=='(') {/* ]( }( )( */
                                 PC.ls=LS_METHOD_ROUND;                                  pc.ls=LS_METHOD_ROUND;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         }                                                                    }                                          
                         pop_LS(PC);                          pop_LS(pc);
                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }                          pc.ungetc();
                         result=EON;                          result=EON;
                         goto break2;                          goto break2;
                 }                  }
Line 2545  default: Line 3397  default:
   
 break2:  break2:
         if(end!=begin) { // there is last piece?          if(end!=begin) { // there is last piece?
                 if((c=='@' || c==0) && end[-1]=='\n') { // we are before LS_DEF_NAME or EOF?                  if(c=='@' || c==0) // we are before LS_DEF_NAME or EOF?
                         // strip last \n                          while(end!=begin && end[-1]=='\n') // trim all empty lines before LS_DEF_NAME and EOF
                         end--;  
                         if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME  
                                 end--;                                  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                          // 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?          if(!pc.string.is_empty()) { // something accumulated?
                 // create STRING value: array of OP_VALUE+vstring                  // create STRING value: array of OP_VALUE+origin+vstring
                 *lvalp=VL(NEW VString(*PC.string));                  *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                  // 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                  // 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) {          if(skip_analized) {
                 PC.source+=skip_analized;  PC.col+=skip_analized;                  pc.source+=skip_analized;  pc.pos.col+=skip_analized;
         }          }
         return result;          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);             strncpy(PC.error, s, MAX_STRING);
            return 1;             return 1;
 }  }
   
 static void yyprint(FILE *file, int type, YYSTYPE value) {  static void yyprint(FILE *file, int type, YYSTYPE value) {
         if(type==STRING)          if(type==STRING)
                 fprintf(file, " \"%s\"", LA2S(value)->cstr());                  fprintf(file, " \"%s\"", LA2S(*value)->cstr());
 }  }
   
   
Removed from v.1.66  
changed lines
  Added in v.1.151

E-mail: