[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.4 and 1.113

version 1.4, 2001/08/10 12:53:32 version 1.113, 2006/04/09 13:48:50
Line 1 Line 1
   /* A Bison parser, made by GNU Bison 1.875c.  */
   
   /* Skeleton parser for Yacc-like parsing with Bison,
      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 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 LAND    262     enum yytokentype {
 #define LOR     263       EON = 258,
 #define LXOR    264       STRING = 259,
 #define NLE     265       BOGUS = 260,
 #define NGE     266       BAD_STRING_COMPARISON_OPERATOR = 261,
 #define NEQ     267       BAD_HEX_LITERAL = 262,
 #define NNE     268       BAD_METHOD_DECL_START = 263,
 #define SLT     269       BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
 #define SGT     270       BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,
 #define SLE     271       LAND = 266,
 #define SGE     272       LOR = 267,
 #define SEQ     273       LXOR = 268,
 #define SNE     274       NXOR = 269,
 #define DEF     275       NLE = 270,
 #define IN      276       NGE = 271,
 #define FEXISTS 277       NEQ = 272,
 #define DEXISTS 278       NNE = 273,
 #define IS      279       NSL = 274,
 #define NEG     280       NSR = 275,
        SLT = 276,
        SGT = 277,
        SLE = 278,
        SGE = 279,
        SEQ = 280,
        SNE = 281,
        DEF = 282,
        IN = 283,
        FEXISTS = 284,
        DEXISTS = 285,
        IS = 286,
        LITERAL_TRUE = 287,
        LITERAL_FALSE = 288,
        NUNARY = 289
      };
   #endif
   #define EON 258
   #define STRING 259
   #define BOGUS 260
   #define BAD_STRING_COMPARISON_OPERATOR 261
   #define BAD_HEX_LITERAL 262
   #define BAD_METHOD_DECL_START 263
   #define BAD_METHOD_PARAMETER_NAME_CHARACTER 264
   #define BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE 265
   #define LAND 266
   #define LOR 267
   #define LXOR 268
   #define NXOR 269
   #define NLE 270
   #define NGE 271
   #define NEQ 272
   #define NNE 273
   #define NSL 274
   #define NSR 275
   #define SLT 276
   #define SGT 277
   #define SLE 278
   #define SGE 279
   #define SEQ 280
   #define SNE 281
   #define DEF 282
   #define IN 283
   #define FEXISTS 284
   #define DEXISTS 285
   #define IS 286
   #define LITERAL_TRUE 287
   #define LITERAL_FALSE 288
   #define NUNARY 289
   
   
   
   
   /* Copy the first part of user declarations.  */
   #line 1 "compile.y"
   
 #line 8 "compile.y"  /** @file
           Parser: compiler(lexical parser and grammar).
   
 static char *RCSId="$Id$";           Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
   
           $Id$
   */
   
 /**  /**
         @todo parser4:           @todo parser4: 
Line 44  static char *RCSId="$Id$"; Line 146  static char *RCSId="$Id$";
                 -#:     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 59  static char *RCSId="$Id$"; Line 163  static char *RCSId="$Id$";
 #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"
   
   // defines
   
 #define SELF_ELEMENT_NAME "self"  
 #define USE_CONTROL_METHOD_NAME "USE"  #define USE_CONTROL_METHOD_NAME "USE"
   
 static int real_yyerror(parse_control *pc, char *s);  // forwards
 static void yyprint(FILE *file, int type, YYSTYPE value);  
 static int yylex(YYSTYPE *lvalp, void *pc);  
   
   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 217 "compile.tab.C"
   
   #if ! defined (yyoverflow) || YYERROR_VERBOSE
   
   /* 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 malloc
   #  define YYSTACK_FREE free
   # 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 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) + 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         244  #if defined (__STDC__) || defined (__cplusplus)
 #define YYFLAG          -32768     typedef signed char yysigned_char;
 #define YYNTBASE        54  #else
      typedef short yysigned_char;
 #define YYTRANSLATE(x) ((unsigned)(x) <= 280 ? yytranslate[x] : 133)  #endif
   
 static const char yytranslate[] = {     0,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,    40,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,    28,    52,    29,    44,    37,    31,    53,    48,  
     49,    35,    34,     2,    33,    47,    36,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,    51,    43,    26,  
      2,    27,     2,    39,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
     41,     2,    42,    50,     2,     2,     2,     2,     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,    30,    46,    32,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,  
      2,     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,    38  
 };  
   
 #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,   335,  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    339,   343,   347,   351,   355,   359,   363,   367,   371,   375,  #define YYUNDEFTOK  2
    379,   383,   387,   391,   395,   399,   403,   407,   411,   415,  #define YYMAXUTOK   289
    419,   423,   427,   429,   431,   432  
   #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[] = {    56,  #if YYDEBUG
      0,    55,     0,    57,     0,    55,    57,     0,    69,     0,  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
     58,     0,    63,     0,    39,     4,    40,    59,     0,   132,     YYRHS.  */
      0,    60,     0,    61,     0,    60,    61,     0,    62,    40,  static const unsigned short yyprhs[] =
      0,   132,     0,     4,     0,    39,     4,    65,    64,    68,  {
     40,    69,     0,   132,     0,    65,     0,    41,    66,    42,         0,     0,     3,     5,     7,     9,    12,    14,    16,    18,
      0,   132,     0,    67,     0,     4,     0,    67,    43,     4,        23,    25,    27,    29,    32,    35,    37,    39,    40,    49,
      0,   132,     0,     4,     0,   132,     0,    70,     0,    71,        51,    53,    57,    59,    61,    63,    67,    69,    71,    73,
      0,    70,    71,     0,   130,     0,    72,     0,    73,     0,        75,    77,    80,    82,    84,    86,    88,    90,    92,    95,
     81,     0,    94,     0,    74,     0,    44,    75,     0,    77,        98,   100,   104,   106,   108,   110,   113,   115,   118,   122,
      3,     0,    76,     0,    45,    77,    46,     0,    78,     0,       124,   126,   128,   130,   133,   136,   138,   140,   142,   143,
     79,     0,    80,     0,   124,    80,     0,   116,     0,   113,       144,   150,   154,   158,   160,   162,   164,   166,   168,   170,
    116,     0,    44,    82,    86,     0,    83,     0,    84,     0,       173,   175,   176,   177,   184,   186,   188,   191,   193,   195,
     85,     0,   112,     0,    47,   112,     0,   124,   112,     0,       197,   198,   199,   205,   209,   213,   215,   219,   221,   225,
     87,     0,    88,     0,    89,     0,    41,    90,    42,     0,       227,   231,   233,   235,   237,   239,   241,   243,   245,   248,
     48,   127,    49,     0,    45,    69,    46,     0,   131,     0,       250,   253,   256,   258,   260,   263,   265,   267,   269,   271,
      4,     0,    91,     0,    92,     0,    93,     0,    72,     0,       274,   277,   278,   279,   285,   287,   289,   292,   295,   297,
     71,    70,     0,    95,     0,     0,     0,    50,    96,    98,       299,   302,   305,   307,   309,   311,   313,   315,   317,   321,
     97,    99,     3,     0,    77,     0,   100,     0,    99,   100,       325,   329,   332,   335,   338,   341,   344,   347,   350,   353,
      0,   101,     0,   102,     0,   103,     0,    41,   104,    42,       357,   361,   365,   369,   373,   377,   381,   385,   389,   393,
      0,    48,   105,    49,     0,    45,   106,    46,     0,   107,       397,   401,   405,   409,   413,   417,   421,   425,   429,   433,
      0,   104,    43,   107,     0,   108,     0,   105,    43,   108,       437,   441,   445,   449,   453,   457,   461,   463,   465,   467,
      0,   109,     0,   106,    43,   109,     0,   110,     0,   111,       468,   470,   472
      0,    69,     0,   131,     0,     4,     0,    91,     0,   127,  
      0,   117,     0,   113,   117,     0,   114,     0,   113,   114,  
      0,   115,    47,     0,   117,     0,   117,     0,     4,     5,  
      0,     4,     0,   118,     0,   119,     0,   120,     0,    44,  
    121,     0,     4,   122,     0,    48,    70,    49,     0,     4,  
      0,   123,     0,   122,   123,     0,    44,   121,     0,   125,  
      0,   126,     0,     4,    51,     0,   125,    51,     0,   128,  
      0,     4,     0,    74,     0,    95,     0,    52,   129,    52,  
      0,    53,   129,    53,     0,    48,   128,    49,     0,    33,  
    128,     0,    32,   128,     0,    28,   128,     0,    21,   128,  
      0,    22,   128,     0,    23,   128,     0,    24,   128,     0,  
    128,    33,   128,     0,   128,    34,   128,     0,   128,    35,  
    128,     0,   128,    36,   128,     0,   128,    37,   128,     0,  
    128,    31,   128,     0,   128,    30,   128,     0,   128,    29,  
    128,     0,   128,     8,   128,     0,   128,     9,   128,     0,  
    128,    10,   128,     0,   128,    26,   128,     0,   128,    27,  
    128,     0,   128,    11,   128,     0,   128,    12,   128,     0,  
    128,    13,   128,     0,   128,    14,   128,     0,   128,    15,  
    128,     0,   128,    16,   128,     0,   128,    17,   128,     0,  
    128,    18,   128,     0,   128,    19,   128,     0,   128,    20,  
    128,     0,   128,    25,   128,     0,    69,     0,     4,     0,  
      0,     0  
 };  };
   
 #endif  /* YYRHS -- A `-1'-separated list of the rules' RHS. */
   static const short 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 yyrline[] =
    106,   116,   118,   118,   119,   121,   121,   123,   189,   189,  {
    190,   190,   191,   192,   192,   194,   223,   223,   224,   225,         0,   128,   128,   135,   137,   137,   138,   140,   140,   142,
    225,   226,   226,   228,   228,   232,   232,   234,   234,   235,       214,   214,   215,   215,   216,   217,   217,   219,   219,   259,
    235,   236,   236,   236,   240,   244,   245,   245,   246,   247,       259,   260,   261,   261,   262,   262,   264,   264,   268,   268,
    249,   250,   265,   266,   266,   270,   274,   276,   277,   278,       270,   270,   271,   271,   272,   272,   272,   276,   283,   284,
    293,   298,   300,   301,   302,   305,   311,   317,   323,   325,       284,   285,   287,   288,   289,   311,   312,   312,   316,   321,
    326,   328,   334,   335,   335,   339,   343,   344,   345,   359,       322,   323,   324,   341,   346,   349,   350,   351,   353,   356,
    361,   361,   362,   364,   365,   367,   368,   369,   370,   372,       353,   364,   372,   379,   380,   381,   383,   389,   390,   390,
    374,   376,   378,   380,   382,   386,   390,   394,   396,   397,       394,   400,   403,   400,   419,   421,   421,   423,   424,   425,
    399,   406,   406,   408,   408,   409,   410,   415,   420,   422,       427,   430,   427,   433,   434,   436,   437,   440,   441,   444,
    424,   425,   426,   428,   432,   440,   446,   451,   451,   452,       445,   447,   451,   466,   471,   472,   473,   478,   478,   480,
    457,   459,   461,   465,   477,   481,   483,   484,   485,   486,       480,   481,   482,   490,   495,   498,   499,   500,   501,   503,
    487,   489,   490,   491,   492,   493,   494,   495,   497,   498,       507,   516,   519,   516,   527,   532,   532,   533,   539,   540,
    499,   500,   501,   502,   503,   504,   505,   506,   507,   508,       542,   554,   566,   568,   569,   570,   571,   572,   573,   574,
    509,   510,   511,   512,   513,   514,   515,   516,   517,   518,       575,   577,   578,   579,   580,   581,   582,   583,   584,   586,
    519,   520,   523,   532,   537,   538       587,   588,   589,   590,   591,   592,   593,   594,   595,   596,
        597,   598,   599,   600,   601,   602,   603,   604,   605,   606,
        607,   608,   609,   610,   611,   612,   615,   620,   629,   634,
        635,   636,   638
 };  };
 #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","\"&&\"","\"||\"",  {
 "\"##\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"lt\"","\"gt\"","\"le\"","\"ge\"",    "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
 "\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"","\"-d\"","\"is\"","'<'","'>'",    "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
 "'!'","'#'","'|'","'&'","'~'","'-'","'+'","'*'","'/'","'%'","NEG","'@'","'\\n'",    "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
 "'['","']'","';'","'$'","'{'","'}'","'.'","'('","')'","'^'","':'","'\\\"'","'\\''",    "BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
 "all","methods","one_big_piece","method","control_method","maybe_control_strings",    "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
 "control_strings","control_string","maybe_string","code_method","maybe_bracketed_strings",    "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
 "bracketed_maybe_strings","maybe_strings","strings","maybe_comment","maybe_codes",    "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
 "codes","code","action","get","get_value","get_name_value","name_in_curly_rdive",    "\"false\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'",
 "name_without_curly_rdive","name_without_curly_rdive_read","name_without_curly_rdive_class",    "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", "'['", "']'",
 "name_without_curly_rdive_code","put","name_expr_wdive","name_expr_wdive_root",    "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'", "':'", "'\"'",
 "name_expr_wdive_write","name_expr_wdive_class","construct","construct_square",    "'''", "$accept", "all", "methods", "one_big_piece", "method",
 "construct_round","construct_curly","any_constructor_code_value","constructor_code_value",    "control_method", "maybe_control_strings", "control_strings",
 "constructor_code","codes__excluding_sole_str_literal","call","call_value","@1",    "control_string", "maybe_string", "code_method", "@1",
 "@2","call_name","store_params","store_param","store_square_param","store_round_param",    "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
 "store_curly_param","store_code_param_parts","store_expr_param_parts","store_curly_param_parts",    "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
 "store_code_param_part","store_expr_param_part","store_curly_param_part","code_param_value",    "get", "get_value", "get_name_value", "name_in_curly_rdive",
 "write_expr_value","name_expr_dive_code","name_path","name_step","name_advance1",    "name_without_curly_rdive", "name_without_curly_rdive_read",
 "name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",    "name_without_curly_rdive_class", "name_without_curly_rdive_code", "put",
 "name_curly_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",    "name_expr_wdive", "name_expr_wdive_root", "name_expr_wdive_write",
 "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",    "name_expr_wdive_class", "construct", "construct_square", "@2", "@3",
 "expr","string_inside_quotes_value","write_string","void_value","empty", NULL    "construct_round", "construct_curly", "any_constructor_code_value",
     "constructor_code_value", "constructor_code",
     "codes__excluding_sole_str_literal", "call", "call_value", "@4", "@5",
     "call_name", "store_params", "store_param", "store_square_param", "@6",
     "@7", "store_round_param", "store_curly_param", "store_code_param_parts",
     "store_expr_param_parts", "store_curly_param_parts",
     "store_code_param_part", "store_expr_param_part",
     "store_curly_param_part", "code_param_value", "name_expr_dive_code",
     "name_path", "name_step", "name_advance1", "name_advance2",
     "name_expr_value", "name_expr_subvar_value",
     "name_expr_with_subvar_value", "name_square_code_value", "@8", "@9",
     "subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write",
     "class_prefix", "class_static_prefix", "class_constructor_prefix",
     "expr_value", "expr", "double_or_STRING", "string_inside_quotes_value",
     "write_string", "void_value", "true_value", "false_value", "empty", 0
 };  };
 #endif  #endif
   
 static const short yyr1[] = {     0,  # ifdef YYPRINT
     54,    54,    55,    55,    56,    57,    57,    58,    59,    59,  /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
     60,    60,    61,    62,    62,    63,    64,    64,    65,    66,     token YYLEX-NUM.  */
     66,    67,    67,    68,    68,    69,    69,    70,    70,    71,  static const unsigned short yytoknum[] =
     71,    72,    72,    72,    73,    74,    75,    75,    76,    77,  {
     77,    78,    79,    80,    80,    81,    82,    82,    82,    83,         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     84,    85,    86,    86,    86,    87,    88,    89,    90,    90,       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     90,    91,    92,    93,    93,    94,    96,    97,    95,    98,       275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     99,    99,   100,   100,   100,   101,   102,   103,   104,   104,       285,   286,   287,   288,    60,    62,   124,    38,    43,    45,
    105,   105,   106,   106,   107,   108,   109,   110,   110,   110,        42,    47,    92,    37,   289,   126,    33,    64,    10,    91,
    111,   112,   112,   113,   113,   114,   115,   116,   116,   117,        93,    59,    36,   123,   125,    46,    40,    41,    94,    58,
    117,   117,   117,   118,   119,   120,   121,   122,   122,   123,        34,    39
    124,   124,   125,   126,   127,   128,   128,   128,   128,   128,  
    128,   128,   128,   128,   128,   128,   128,   128,   128,   128,  
    128,   128,   128,   128,   128,   128,   128,   128,   128,   128,  
    128,   128,   128,   128,   128,   128,   128,   128,   128,   128,  
    128,   128,   129,   130,   131,   132  
 };  };
   # 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,     3,     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,     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[] = {   156,  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    154,     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,   156,   156,   156,    99,     0,   113,   105,   108,   107,         1,     2,     1,     1,     1,     1,     1,     1,     2,     2,
    104,     0,     0,    98,     0,   100,    51,     0,    92,     0,         1,     3,     1,     1,     1,     2,     1,     2,     3,     1,
     37,   155,   156,     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,   156,    18,         1,     0,     0,     6,     1,     1,     2,     1,     1,     1,
     17,   110,   109,    39,    93,   106,   154,     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,   156,   156,   117,   118,     0,         2,     2,     1,     1,     2,     1,     1,     1,     1,     2,
    115,     0,    12,    14,    13,    19,     0,    25,     0,    24,         2,     0,     0,     5,     1,     1,     2,     2,     1,     1,
     65,    56,    58,   125,   126,   127,   128,   124,   123,   122,         2,     2,     1,     1,     1,     1,     1,     1,     3,     3,
      0,   153,     0,     0,    57,     0,     0,     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,   155,         3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
    156,     0,     0,    71,    73,    74,    75,    23,   156,   121,         3,     3,     3,     3,     3,     3,     1,     1,     1,     0,
    119,   120,   137,   138,   139,   142,   143,   144,   145,   146,         1,     1,     0
    147,   148,   149,   150,   151,   152,   140,   141,   136,   135,  
    134,   129,   130,   131,   132,   133,   154,    90,     0,    79,  
     85,    88,    87,     0,    83,     0,    81,    86,    91,    69,  
     72,    16,    76,   155,   156,    78,     0,    77,    80,    84,  
     82,     0,     0,     0  
 };  };
   
 static const short yydefgoto[] = {   242,  /* 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,   139,   152,    11,    12,    13,    14,   128,     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,   218,   112,   113,    17,  {
    129,    49,   132,    88,   183,   184,   185,   186,   187,   219,       172,   168,     0,     0,    71,     0,     3,     2,     4,     7,
    226,   224,   220,   227,   225,   221,   228,    37,    63,    39,         8,     6,    29,    30,    33,    34,    37,    35,    36,    70,
     40,    41,    64,    43,    44,    45,    61,    58,    59,    65,        32,    28,     0,   105,   111,     0,     0,     0,    38,    40,
     47,    48,   229,   131,   153,    19,   222,    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[] = {     6,  /* YYDEFGOTO[NTERM-NUM]. */
 -32768,    14,    57,-32768,   -17,-32768,-32768,-32768,-32768,-32768,  static const short yydefgoto[] =
     16,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  {
     73,    35,    23,    51,    76,    16,-32768,-32768,    80,-32768,        -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
 -32768,-32768,   -24,-32768,-32768,-32768,-32768,    77,-32768,    47,        10,   244,   101,    56,    98,    99,   140,   161,    12,    13,
 -32768,    22,-32768,-32768,-32768,    77,    46,-32768,    51,-32768,        14,    15,   126,    28,    29,    30,    31,    32,    33,    17,
 -32768,    96,   107,    88,-32768,    23,-32768,    71,-32768,-32768,        34,    35,    36,    37,    77,    78,   109,   204,    79,    80,
 -32768,   141,    77,    90,    77,    71,-32768,    76,    90,     8,       146,   247,   148,   149,    18,   127,    50,   133,    90,   195,
 -32768,    38,    16,    15,-32768,-32768,-32768,-32768,     9,-32768,       196,   197,   235,   258,   198,   199,   248,   239,   237,   249,
 -32768,    22,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,       240,   238,   250,    38,    66,    40,    41,    42,    67,    44,
     94,-32768,    83,   142,-32768,   144,   145,-32768,   186,-32768,        45,    46,    62,   142,    64,    60,    61,    68,    48,    49,
 -32768,-32768,-32768,-32768,    90,-32768,   150,    16,   123,   152,       241,   129,   130,   162,    20,   251,   131,   132,    21
 -32768,-32768,-32768,-32768,   173,-32768,    15,    15,    15,    15,  
     15,    15,    15,    74,    15,    16,    16,-32768,-32768,   171,  
    274,    91,-32768,-32768,-32768,-32768,   217,-32768,   182,-32768,  
     16,-32768,-32768,   140,   140,   140,   140,   140,   118,-32768,  
    232,-32768,   180,   170,-32768,    15,    15,    15,    15,    15,  
     15,    15,    15,    15,    15,    15,    15,    15,    15,    15,  
     15,    15,    15,    15,    15,    15,    15,    15,    15,    40,  
     16,    15,    48,-32768,-32768,-32768,-32768,-32768,    16,-32768,  
 -32768,-32768,   361,   334,   304,   386,   386,   113,   113,   386,  
    386,   386,   386,   113,   113,   140,   386,   386,   194,   239,  
    118,    -4,    -4,-32768,-32768,-32768,   125,-32768,   136,-32768,  
 -32768,-32768,-32768,    60,-32768,   -20,-32768,-32768,-32768,-32768,  
 -32768,-32768,-32768,    40,    16,-32768,    15,-32768,-32768,-32768,  
 -32768,   233,   236,-32768  
 };  };
   
 static const short yypgoto[] = {-32768,  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -32768,-32768,   248,-32768,-32768,-32768,   163,-32768,-32768,-32768,     STATE-NUM.  */
    201,-32768,-32768,-32768,     2,   -21,    -8,   -71,-32768,     0,  #define YYPACT_NINF -107
 -32768,-32768,    67,-32768,-32768,   -30,-32768,-32768,-32768,-32768,  static const short yypact[] =
 -32768,-32768,-32768,-32768,-32768,-32768,   184,-32768,-32768,-32768,  {
      4,-32768,-32768,-32768,-32768,    81,-32768,-32768,-32768,-32768,        14,  -107,    13,    45,  -107,    28,   -15,  -107,  -107,  -107,
 -32768,-32768,    26,    34,    42,-32768,-32768,   -12,    82,    72,      -107,  -107,    21,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
 -32768,    54,     3,-32768,-32768,-32768,   222,-32768,   221,   277,      -107,  -107,    73,    19,  -107,    50,     6,    44,  -107,  -107,
 -32768,-32768,   223,    39,   168,-32768,   224,   -45        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          423  static const short 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,    10,    51,    18,    70,    42,    94,    98,   101,     1,      -106,  -107,     0,  -107,  -107,    -6,  -107,  -107,   -21,  -107,
     15,     1,    67,    55,    18,    84,    72,    21,   116,     1,      -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
     73,     2,   237,    74,   -98,    15,    60,    69,   238,    18,      -107,   118,  -107,  -107,  -107,     2,  -107,  -107,  -107,  -107,
    177,   178,   179,    85,    84,   117,   118,   119,   120,    55,        43,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,   -17,
     82,   107,   121,   217,     2,   134,   122,   123,    42,     3,       -13,   -16,  -107,   -18,     4,    41,  -107,   -23,     3,  -107,
    230,     3,    56,   140,    22,     4,   106,     4,   124,     3,      -107,  -107,  -107,  -107,   181,  -107,   183,   239,  -107,  -107,
     22,    51,   125,   108,     4,     4,   126,   127,   -97,    15,       171,    95,  -107,   123,  -107,   142,  -107,  -107,    64
    105,    15,    15,    18,   115,    18,    18,    22,    56,    66,  
     79,     3,    71,     3,    38,    57,   141,     4,   180,     4,  
     62,    81,   181,    83,    23,   182,    86,    89,    26,    89,  
     23,    24,   235,    25,    26,   236,    68,    15,   109,    80,  
     95,    18,    52,    53,    56,    87,    81,    23,    24,    23,  
     23,    26,   135,    26,    26,    15,    15,    38,    53,    18,  
     18,   180,    51,  -156,    80,   181,   -97,   169,   182,    80,  
     15,   172,   173,   174,    18,   175,   176,   177,   178,   179,  
    175,   176,   177,   178,   179,   144,   145,   146,   147,   148,  
    149,   150,   109,   151,   -64,   -64,   -89,   -89,   172,   173,  
    174,   108,   175,   176,   177,   178,   179,   233,   234,    15,  
     15,   -14,   223,    18,    18,   136,   104,   137,    15,   138,  
    232,   -60,    18,   142,   193,   194,   195,   196,   197,   198,  
    199,   200,   201,   202,   203,   204,   205,   206,   207,   208,  
    209,   210,   211,   212,   213,   214,   215,   216,   143,   155,  
    188,   189,   192,   173,   174,   108,   175,   176,   177,   178,  
    179,   191,   243,    15,    15,   244,   223,    18,    18,   156,  
    157,   158,   159,   160,   161,   162,   163,   164,   165,   166,  
    167,   168,    50,   133,   100,   111,   169,   170,   171,   239,  
    172,   173,   174,   231,   175,   176,   177,   178,   179,   174,  
    241,   175,   176,   177,   178,   179,   240,   102,   103,    46,  
    190,   156,   157,   158,   159,   160,   161,   162,   163,   164,  
    165,   166,   167,   168,   154,   114,   130,     0,   169,   170,  
    171,     0,   172,   173,   174,     0,   175,   176,   177,   178,  
    179,   156,   157,     0,   159,   160,   161,   162,   163,   164,  
    165,   166,   167,   168,     0,     0,     0,     0,   169,   170,  
    171,     0,   172,   173,   174,     0,   175,   176,   177,   178,  
    179,   156,     0,     0,   159,   160,   161,   162,   163,   164,  
    165,   166,   167,   168,     0,     0,     0,     0,   169,   170,  
    171,     0,   172,   173,   174,     0,   175,   176,   177,   178,  
    179,   159,   160,   161,   162,   163,   164,   165,   166,   167,  
    168,     0,     0,     0,     0,   169,   170,   171,     0,   172,  
    173,   174,     0,   175,   176,   177,   178,   179,   161,   162,  
      0,     0,     0,     0,   167,   168,     0,     0,     0,     0,  
    169,     0,     0,     0,   172,   173,   174,     0,   175,   176,  
    177,   178,   179  
 };  };
   
 static const short yycheck[] = {     0,  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     72,     0,    11,     0,    26,     3,    52,    53,    54,     4,     positive, shift that token.  If negative, reduce the rule which
     11,     4,    25,     5,    11,    46,    41,     4,     4,     4,     number is the opposite.  If zero, do what YYDEFACT says.
     45,    39,    43,    48,     3,    26,     4,    25,    49,    26,     If YYTABLE_NINF, syntax error.  */
     35,    36,    37,    46,    65,    21,    22,    23,    24,     5,  #define YYTABLE_NINF -173
     38,     4,    28,     4,    39,    91,    32,    33,    46,    44,  static const short yytable[] =
      3,    44,    44,    99,     4,    50,    49,    50,    44,    44,  {
      4,    70,    48,    72,    50,    50,    52,    53,    47,    70,        16,    11,    19,   145,   106,    53,    43,    39,  -103,    70,
     68,    72,    73,    70,    73,    72,    73,     4,    44,     4,        23,   111,    16,    91,    19,    74,    83,    22,     1,    75,
      4,    44,     3,    44,     3,    51,   108,    50,    41,    50,        65,   254,    76,    57,    57,     1,    86,   255,    51,    87,
     24,    38,    45,    47,    44,    48,    51,     4,    48,     4,        72,    71,     2,   143,   112,   113,   114,   115,   242,   116,
     44,    45,    43,    47,    48,    46,    25,   108,   180,    38,       117,   246,    84,    83,    89,   118,   119,    86,    69,    23,
      4,   108,    40,    41,    44,    49,    63,    44,    45,    44,        43,    39,   120,   121,    63,    24,    23,  -172,    25,   122,
     44,    48,    40,    48,    48,   126,   127,    46,    41,   126,      -102,     2,    16,   123,    19,     4,     3,   124,   125,    81,
    127,    41,   141,    40,    63,    45,    47,    25,    48,    68,        58,    58,     4,     3,   108,    16,   110,    19,    59,     4,
    141,    29,    30,    31,   141,    33,    34,    35,    36,    37,        82,     3,   252,    88,   192,   253,   203,     4,   193,     3,
     33,    34,    35,    36,    37,   117,   118,   119,   120,   121,        73,   194,    91,    24,    24,     4,    25,    25,    26,    53,
    122,   123,   234,   125,    42,    43,    42,    43,    29,    30,        27,    24,   144,    85,    25,    26,    16,    82,    19,    16,
     31,   180,    33,    34,    35,    36,    37,    42,    43,   180,       168,    19,    82,    97,    24,   173,   174,    25,    96,   100,
    181,    40,   181,   180,   181,    42,    46,    43,   189,     4,       103,    54,    55,    55,    16,    16,    19,    19,    58,   145,
    189,    42,   189,    42,   156,   157,   158,   159,   160,   161,       -68,   -68,   184,   185,   186,   187,   188,   189,   190,   191,
    162,   163,   164,   165,   166,   167,   168,   169,   170,   171,       107,   192,   136,   137,    16,   193,    19,   -15,   194,   168,
    172,   173,   174,   175,   176,   177,   178,   179,    46,    49,       139,   145,   171,   172,   173,   174,  -102,   135,   -95,   -95,
      4,    40,    53,    30,    31,   234,    33,    34,    35,    36,       179,   180,   168,   138,   151,   141,   181,   173,   174,   200,
     37,    52,     0,   234,   235,     0,   235,   234,   235,     8,       164,   184,   185,   186,   187,   188,   189,   190,   191,   181,
      9,    10,    11,    12,    13,    14,    15,    16,    17,    18,       188,   189,   190,   191,   184,   185,   186,   187,   188,   189,
     19,    20,     5,    91,    54,    72,    25,    26,    27,   234,       190,   191,   201,    16,   236,    19,    53,   202,   206,   -64,
     29,    30,    31,   183,    33,    34,    35,    36,    37,    31,       207,   173,   174,    16,   245,    19,   257,   152,   153,   154,
    237,    33,    34,    35,    36,    37,   235,    56,    58,     3,       155,   262,    52,   156,   157,   158,   159,   134,   160,   185,
     49,     8,     9,    10,    11,    12,    13,    14,    15,    16,       186,   187,   188,   189,   190,   191,   102,   147,   144,   186,
     17,    18,    19,    20,   127,    72,    74,    -1,    25,    26,       187,   188,   189,   190,   191,    16,   259,    19,   243,   104,
     27,    -1,    29,    30,    31,    -1,    33,    34,    35,    36,       261,   260,    47,   105,    16,   256,    19,   128,   163,     0,
     37,     8,     9,    -1,    11,    12,    13,    14,    15,    16,       144,   150,    16,   236,    19,     0,     0,    16,     0,    19,
     17,    18,    19,    20,    -1,    -1,    -1,    -1,    25,    26,       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
     27,    -1,    29,    30,    31,    -1,    33,    34,    35,    36,       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
     37,     8,    -1,    -1,    11,    12,    13,    14,    15,    16,       228,   229,   230,   231,   232,   233,   234,   165,   166,   167,
     17,    18,    19,    20,    -1,    -1,    -1,    -1,    25,    26,       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
     27,    -1,    29,    30,    31,    -1,    33,    34,    35,    36,       178,   179,   180,   173,   174,     0,     0,   181,     0,     0,
     37,    11,    12,    13,    14,    15,    16,    17,    18,    19,       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
     20,    -1,    -1,    -1,    -1,    25,    26,    27,    -1,    29,       184,   185,   186,   187,   188,   189,   190,   191,     0,     0,
     30,    31,    -1,    33,    34,    35,    36,    37,    13,    14,         0,     0,     0,   205,   165,   166,   167,   168,   169,   170,
     -1,    -1,    -1,    -1,    19,    20,    -1,    -1,    -1,    -1,       171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
     25,    -1,    -1,    -1,    29,    30,    31,    -1,    33,    34,         0,     0,     0,     0,   181,     0,     0,   182,   183,   184,
     35,    36,    37       185,   186,   187,   188,   189,   190,   191,   165,   166,     0,
        168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
        178,   179,   180,     0,     0,     0,     0,   181,     0,     0,
        182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
        165,     0,     0,   168,   169,   170,   171,   172,   173,   174,
        175,   176,   177,   178,   179,   180,     0,     0,     0,     0,
        181,     0,     0,   182,   183,   184,   185,   186,   187,   188,
        189,   190,   191,   168,   169,   170,   171,   172,   173,   174,
        175,   176,   177,   178,   179,   180,   173,   174,     0,     0,
        181,     0,     0,   182,   183,   184,   185,   186,   187,   188,
        189,   190,   191,     0,     0,   186,   187,   188,   189,   190,
        191
 };  };
 #define YYPURE 1  
   
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */  
 #line 3 "D:/cygwin/usr/share/bison.simple"  
 /* This file comes from bison-1.28.  */  
   
 /* Skeleton output parser for bison,  static const short yycheck[] =
    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.  {
          0,     0,     0,   109,    62,    12,     3,     3,     3,    27,
    This program is free software; you can redistribute it and/or modify         4,     4,    12,     4,    12,    49,    39,     4,     4,    53,
    it under the terms of the GNU General Public License as published by        26,    51,    56,     5,     5,     4,    47,    57,     0,    47,
    the Free Software Foundation; either version 2, or (at your option)        27,    27,    47,     4,    27,    28,    29,    30,     3,    32,
    any later version.        33,     4,    39,    66,    50,    38,    39,    68,     4,     4,
         47,    47,    45,    46,     4,    49,     4,    48,    52,    52,
    This program is distributed in the hope that it will be useful,        55,    47,    62,    56,    62,    58,    52,    60,    61,     4,
    but WITHOUT ANY WARRANTY; without even the implied warranty of        52,    52,    58,    52,    71,    75,    75,    75,    59,    58,
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        39,    52,    51,    59,    49,    54,   144,    58,    53,    52,
    GNU General Public License for more details.         3,    56,     4,    49,    49,    58,    52,    52,    53,   106,
         55,    49,   109,    55,    52,    53,   106,    66,   106,   109,
    You should have received a copy of the GNU General Public License        14,   109,    71,     4,    49,    19,    20,    52,    54,    55,
    along with this program; if not, write to the Free Software        56,    48,    49,    49,   124,   125,   124,   125,    52,   235,
    Foundation, Inc., 59 Temple Place - Suite 330,        50,    51,    36,    37,    38,    39,    40,    41,    42,    43,
    Boston, MA 02111-1307, USA.  */        54,    49,    48,    50,   144,    53,   144,    48,    56,    14,
          4,   257,    17,    18,    19,    20,    55,    93,    50,    51,
 /* As a special exception, when this file is copied by Bison into a        25,    26,    14,    51,    54,   101,    31,    19,    20,     4,
    Bison output file, you may use that output file without restriction.        57,    36,    37,    38,    39,    40,    41,    42,    43,    31,
    This special exception was added by the Free Software Foundation        40,    41,    42,    43,    36,    37,    38,    39,    40,    41,
    in version 1.24 of Bison.  */        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 *bottom, short *top)
   #else
   static void
   yy_stack_print (bottom, top)
       short *bottom;
       short *top;
 #endif  #endif
   {
     YYFPRINTF (stderr, "Stack now");
     for (/* Nothing. */; bottom <= top; ++bottom)
       YYFPRINTF (stderr, " %d", *bottom);
     YYFPRINTF (stderr, "\n");
   }
   
 int yynerrs;                    /*  number of parse errors so far       */  # define YY_STACK_PRINT(Bottom, Top)                            \
 #endif  /* not YYPURE */  do {                                                            \
     if (yydebug)                                                  \
       yy_stack_print ((Bottom), (Top));                           \
   } while (0)
   
 #if YYDEBUG != 0  
 int yydebug;                    /*  nonzero means print parse trace     */  /*------------------------------------------------.
 /* Since this is uninitialized, it does not stop multiple parsers  | Report that the YYRULE is going to be reduced.  |
    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]]);
   }
   
   # define YY_REDUCE_PRINT(Rule)          \
   do {                                    \
     if (yydebug)                          \
       yy_reduce_print (Rule);             \
   } while (0)
   
   /* Nonzero means print parse trace.  It is left uninitialized so that
      multiple parsers can coexist.  */
   int yydebug;
   #else /* !YYDEBUG */
   # define YYDPRINTF(Args)
   # define YYDSYMPRINT(Args)
   # define YYDSYMPRINTF(Title, Token, Value, Location)
   # define YY_STACK_PRINT(Bottom, Top)
   # define YY_REDUCE_PRINT(Rule)
   #endif /* !YYDEBUG */
   
 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */  
   
   /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef YYINITDEPTH  #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).
   
 #if YYMAXDEPTH == 0     Do not make this value too large; the results are undefined if
 #undef YYMAXDEPTH     SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
      evaluated with infinite-precision integer arithmetic.  */
   
   #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
   # 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 (*yys++ != '\0')
       continue;
   
   while (i-- > 0)    return yys - yystr - 1;
     *t++ = *f++;  
 }  }
   #  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 "D:/cygwin/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;
     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 yyssa[YYINITDEPTH];
     short *yyss = yyssa;
   register short *yyssp;    register short *yyssp;
   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                     */    /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */    YYSTYPE yyvsa[YYINITDEPTH];
     YYSTYPE *yyvs = yyvsa;
     register YYSTYPE *yyvsp;
   
   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 761  yyparse(YYPARSE_PARAM_ARG) Line 1227  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  .  */    goto yysetstate;
 /* 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;  /*------------------------------------------------------------.
   | yynewstate -- Push a new state, which is found in yystate.  |
   `------------------------------------------------------------*/
    yynewstate:
     /* In all cases, when you get here, the value and location stacks
        have just been pushed. so pushing a state here evens the stacks.
        */
     yyssp++;
   
   if (yyssp >= yyss + yystacksize - 1)   yysetstate:
     {    *yyssp = 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. */  
       YYSTYPE *yyvs1 = yyvs;  
       short *yyss1 = yyss;  
 #ifdef YYLSP_NEEDED  
       YYLTYPE *yyls1 = yyls;  
 #endif  
   
     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 *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 *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 873  yynewstate: Line 1325  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 107 "compile.y"    switch (yyn)
 {      {
         Method& method=*NEW Method(POOL,           case 2:
                 *main_method_name,   #line 128 "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(*main_method_name, method);          PC.cclass->add_method(PC.alias_method(main_method_name), method);
 ;  ;}
     break;}      break;
 case 8:  
 #line 124 "compile.y"    case 9:
 {  #line 143 "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()) { // already changed from default?                  if(PC.cclass->base_class()) { // already changed from default?
                         strcpy(PC.error, "class already have a name '");                          strcpy(PC.error, "class already have a name '");
                         strncat(PC.error, PC.cclass->name().cstr(), 100);                          strncat(PC.error, PC.cclass->name().cstr(), 100);
                         strcat(PC.error, "'");                          strcat(PC.error, "'");
                         YYERROR;                          YYERROR;
                 }                  }
                 if(strings_code->size()==1*2) {                  if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                         // 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=cclass;
                           PC.cclass->set_name(name);
                         // append to request's classes                          // append to request's classes
                         PC.request->classes().put(*name, PC.cclass);                          PC.request.classes().put(name, 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));
         } else if(command==BASE_NAME) {          } else if(command==BASE_NAME) {
                 if(PC.cclass->base()) { // 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()->name().cstr(), 100);                          strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100);
                         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);
                         VClass *base=static_cast<VClass *>(                          if(Value* base_class_value=PC.request.classes().get(base_name)) {
                                 PC.request->classes().get(base_name));                                  // @CLASS == @BASE sanity check
                         if(!base) {                                  if(VStateless_class *base_class=base_class_value->get_class()) {
                                           if(PC.cclass==base_class) {
                                                   strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
                                                   YYERROR;
                                           }
                                           PC.cclass->get_class()->set_base(base_class);
                                   } else { // they asked to derive from a class without methods ['env' & co]
                                           strcpy(PC.error, base_name.cstr());
                                           strcat(PC.error, ": you can not derive from this class in @"BASE_NAME);
                                           YYERROR;
                                   }
                           } else {
                                 strcpy(PC.error, base_name.cstr());                                  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) {  
                                 strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);  
                                 YYERROR;  
                         }  
                         PC.cclass->set_base(*base);  
                 } else {                  } else {
                         strcpy(PC.error, "@"BASE_NAME" must contain sole name");                          strcpy(PC.error, "@"BASE_NAME" must contain sole name");
                         YYERROR;                          YYERROR;
Line 1077  case 8: Line 1498  case 8:
                         "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
                 YYERROR;                  YYERROR;
         }          }
 ;  ;}
     break;}      break;
 case 12:  
 #line 190 "compile.y"    case 13:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 215 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 case 16:      break;
 #line 195 "compile.y"  
 {    case 17:
         const String *name=LA2S(yyvsp[-5]);  #line 219 "compile.y"
       { 
         YYSTYPE params_names_code=yyvsp[-4];          PC.explicit_result=false;
         Array *params_names=0;          const String& name=*LA2S(*yyvsp[-4]);
         if(int size=params_names_code->size()) {  
                 params_names=NEW Array(POOL);          YYSTYPE params_names_code=yyvsp[-3];
                 for(int i=0; i<size; i+=2)          ArrayString* params_names=0;
                         *params_names+=LA2S(params_names_code, i);          if(int size=params_names_code->count()) {
                   params_names=new ArrayString;
                   for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE)
                           *params_names+=LA2S(*params_names_code, i);
         }          }
   
         YYSTYPE locals_names_code=yyvsp[-3];          YYSTYPE locals_names_code=yyvsp[-2];
         Array *locals_names=0;          ArrayString* locals_names=0;
         if(int size=locals_names_code->size()) {          if(int size=locals_names_code->count()) {
                 locals_names=NEW Array(POOL);                  locals_names=new ArrayString;
                 for(int i=0; i<size; i+=2)                  for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
                         *locals_names+=LA2S(locals_names_code, i);                          const String* local_name=LA2S(*locals_names_code, i);
                           if(*local_name==RESULT_VAR_NAME)
                                   PC.explicit_result=true;
                           else
                                   *locals_names+=local_name;
                   }
         }          }
   
         Method& method=*NEW Method(POOL,           Method* method=new Method(
                 *name,                   //name, 
                 Method::CT_ANY,                  Method::CT_ANY,
                 0, 0/*min,max numbered_params_count*/,                   0, 0/*min,max numbered_params_count*/, 
                 params_names, locals_names,                   params_names, locals_names, 
                 yyvsp[0], 0);                  0/*to be filled later in next {} */, 0);
         PC.cclass->add_method(*name, method);          PC.cclass->add_method(PC.alias_method(name), *method);
 ;          *reinterpret_cast<Method**>(&yyval)=method;
     break;}  
 case 19:          // todo: check [][;result;]
 #line 224 "compile.y"  ;}
 {yyval=yyvsp[-1];      break;
     break;}  
 case 23:    case 18:
 #line 226 "compile.y"  #line 254 "compile.y"
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;      {
     break;}          // fill in the code
 case 29:          reinterpret_cast<Method*>(yyvsp[-1])->parser_code=yyvsp[0];
 #line 234 "compile.y"  ;}
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;      break;
     break;}  
 case 35:    case 21:
 #line 240 "compile.y"  #line 260 "compile.y"
 {      {yyval=yyvsp[-1];}
         yyval=yyvsp[0]; /* stack: resulting value */      break;
         O(yyval, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */  
 ;    case 25:
     break;}  #line 262 "compile.y"
 case 36:      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 #line 244 "compile.y"      break;
 { yyval=yyvsp[0] ;  
     break;}    case 31:
 case 39:  #line 270 "compile.y"
 #line 246 "compile.y"      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 { yyval=yyvsp[-1] ;      break;
     break;}  
 case 42:    case 37:
 #line 250 "compile.y"  #line 276 "compile.y"
 {      {
         yyval=N(POOL);           yyval=yyvsp[0]; /* stack: resulting value */ 
         Array *diving_code=yyvsp[0];          changetail_or_append(*yyval, 
         const String *first_name=LA2S(diving_code);                  OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
                   /*or */OP_WRITE_VALUE
                   ); /* value=pop; wcontext.write(value) */
   ;}
       break;
   
     case 38:
   #line 283 "compile.y"
       { yyval=yyvsp[0] ;}
       break;
   
     case 41:
   #line 285 "compile.y"
       { yyval=yyvsp[-1] ;}
       break;
   
     case 44:
   #line 289 "compile.y"
       {
           yyval=N(); 
           ArrayOperation* diving_code=yyvsp[0];
           const String* first_name=LA2S(*diving_code);
           // self.xxx... -> xxx...
           // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
         if(first_name && *first_name==SELF_ELEMENT_NAME) {          if(first_name && *first_name==SELF_ELEMENT_NAME) {
                 O(yyval, OP_WITH_SELF); /* stack: starting context */                  O(*yyval, OP_WITH_SELF); /* stack: starting context */
                 P(yyval, diving_code,                   P(*yyval, *diving_code, 
                         /* skip over... */                          /* skip over... */
                         diving_code->size()>2?3/*OP_+string+get_element*/:2/*OP_+string*/);                          diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
         } else {          } else {
                 O(yyval, OP_WITH_READ); /* stack: starting context */                  O(*yyval, OP_WITH_READ); /* stack: starting context */
                 P(yyval, diving_code);  
                   // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
                   // OP_VALUE+origin+string+OP_GET_ELEMENT. -> OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR.
                   if(PC.in_call_value && diving_code->count()==4)
                           diving_code->put(4-1, OP_GET_ELEMENT_OR_OPERATOR);
                   P(*yyval, *diving_code);
         }          }
         /* diving code; stack: current context */          /* diving code; stack: current context */
 ;  ;}
     break;}      break;
 case 43:  
 #line 265 "compile.y"    case 45:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 311 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 case 45:      break;
 #line 266 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 47:
     break;}  #line 312 "compile.y"
 case 46:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 270 "compile.y"      break;
 {  
     case 48:
   #line 316 "compile.y"
       {
         yyval=yyvsp[-1]; /* stack: context,name */          yyval=yyvsp[-1]; /* stack: context,name */
         P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */          P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
 ;  ;}
     break;}      break;
 case 50:  
 #line 278 "compile.y"    case 52:
 {  #line 324 "compile.y"
         yyval=N(POOL);      {
         Array *diving_code=yyvsp[0];          yyval=N();
         const String *first_name=LA2S(diving_code);          ArrayOperation* diving_code=yyvsp[0];
           const String* first_name=LA2S(*diving_code);
           // $self.xxx... -> $xxx...
           // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
         if(first_name && *first_name==SELF_ELEMENT_NAME) {          if(first_name && *first_name==SELF_ELEMENT_NAME) {
                 O(yyval, OP_WITH_SELF); /* stack: starting context */                  O(*yyval, OP_WITH_SELF); /* stack: starting context */
                 P(yyval, diving_code,                   P(*yyval, *diving_code, 
                         /* skip over... */                          /* skip over... */
                         diving_code->size()>2?3/*OP_+string+get_element*/:2/*OP_+string*/);                          diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
         } else {          } else {
                 O(yyval, OP_WITH_ROOT); /* stack: starting context */                  O(*yyval, OP_WITH_ROOT); /* stack: starting context */
                 P(yyval, diving_code);                  P(*yyval, *diving_code);
         }          }
         /* diving code; stack: current context */          /* diving code; stack: current context */
 ;  ;}
     break;}      break;
 case 51:  
 #line 293 "compile.y"    case 53:
 {  #line 341 "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_WITH_WRITE); /* stack: starting context */
 ;          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
     break;}  ;}
 case 52:      break;
 #line 298 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 54:
     break;}  #line 346 "compile.y"
 case 56:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 305 "compile.y"      break;
 {  
     case 58:
   #line 353 "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 356 "compile.y"
       {
           PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
   ;}
       break;
   
     case 60:
   #line 358 "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_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
 ;  ;}
     break;}      break;
 case 57:  
 #line 311 "compile.y"    case 61:
 {   #line 364 "compile.y"
       { 
           yyval=N(); 
           O(*yyval, OP_PREPARE_TO_EXPRESSION);
         // stack: context, name          // stack: context, name
         yyval=yyvsp[-1]; // stack: context, name, value          P(*yyval, *yyvsp[-1]); // stack: context, name, value
         O(yyval, OP_CONSTRUCT_EXPR); /* value=pop; name=pop; context=pop; construct(context,name,value) */          O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
 ;  ;}
     break;}      break;
 case 58:  
 #line 317 "compile.y"    case 62:
 {  #line 372 "compile.y"
       {
         // stack: context, name          // stack: context, name
         yyval=N(POOL);           yyval=N(); 
         CCA(yyval, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */          OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
 ;  ;}
     break;}      break;
 case 62:  
 #line 328 "compile.y"    case 66:
 {  #line 383 "compile.y"
         yyval=N(POOL);       {
         O(yyval, OP_CREATE_EWPOOL); /* stack: empty write context */          yyval=N(); 
         P(yyval, yyvsp[0]); /* some code that writes to that context */          OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
         O(yyval, OP_REDUCE_EWPOOL); /* context=pop; stack: context.value() */          /* some code that writes to that context */
 ;          /* context=pop; stack: context.value() */
     break;}  ;}
 case 65:      break;
 #line 335 "compile.y"  
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;    case 69:
     break;}  #line 390 "compile.y"
 case 66:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 339 "compile.y"      break;
 {  
     case 70:
   #line 394 "compile.y"
       {
         yyval=yyvsp[0]; /* stack: value */          yyval=yyvsp[0]; /* stack: value */
         O(yyval, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */          changetail_or_append(*yyval, 
 ;                  OP_CALL, true,  /*->*/ OP_CALL__WRITE,
     break;}                  /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
 case 67:  ;}
 #line 343 "compile.y"      break;
 { PC.object_constructor_allowed=true ;  
     break;}    case 71:
 case 68:  #line 400 "compile.y"
 #line 344 "compile.y"      { 
 { PC.object_constructor_allowed=false ;                                          PC.in_call_value=true; 
     break;}                          ;}
 case 69:      break;
 #line 345 "compile.y"  
 { /* ^field.$method{vasya} */    case 72:
   #line 403 "compile.y"
       {
                                   PC.in_call_value=false;
                           ;}
       break;
   
     case 73:
   #line 406 "compile.y"
       { /* ^field.$method{vasya} */
         yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */          yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
         O(yyval, OP_GET_METHOD_FRAME); /* stack: context,method_frame */  
   
         YYSTYPE params_code=yyvsp[-1];          YYSTYPE params_code=yyvsp[-1];
         if(params_code->size()==3) // probably [] case. [OP_VALUE + Void + STORE_PARAM]          if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM]
                 if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?                  if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
                         if(!value->is_defined()) // value is VVoid?                          if(value->is_void()) // value is VVoid?
                                 params_code=0; // ^zzz[] case. don't append lone empty param.                                  params_code=0; // ^zzz[] case. don't append lone empty param.
         if(params_code)          }
                 P(yyval, params_code); // filling method_frame.store_params          /* stack: context, method_junction */
         O(yyval, OP_CALL); // method_frame=pop; ncontext=pop; call(ncontext,method_frame) stack: value          OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
 ;  ;}
     break;}      break;
 case 72:  
 #line 361 "compile.y"    case 76:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 421 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 case 76:      break;
 #line 367 "compile.y"  
 {yyval=yyvsp[-1];    case 80:
     break;}  #line 427 "compile.y"
 case 77:      {
 #line 368 "compile.y"          // allow ^call[ letters here any time ]
 {yyval=yyvsp[-1];          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
     break;}  ;}
 case 78:      break;
 #line 369 "compile.y"  
 {yyval=yyvsp[-1];    case 81:
     break;}  #line 430 "compile.y"
 case 80:      {
 #line 372 "compile.y"          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;  ;}
     break;}      break;
 case 82:  
 #line 376 "compile.y"    case 82:
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;  #line 432 "compile.y"
     break;}      {yyval=yyvsp[-2];}
 case 84:      break;
 #line 380 "compile.y"  
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;    case 83:
     break;}  #line 433 "compile.y"
 case 85:      {yyval=yyvsp[-1];}
 #line 382 "compile.y"      break;
 {  
         yyval=yyvsp[0];    case 84:
         O(yyval, OP_STORE_PARAM);  #line 434 "compile.y"
 ;      {yyval=yyvsp[-1];}
     break;}      break;
 case 86:  
 #line 386 "compile.y"    case 86:
 {  #line 437 "compile.y"
         yyval=N(POOL);       { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
         PEA(yyval, yyvsp[0]);      break;
 ;  
     break;}    case 88:
 case 87:  #line 441 "compile.y"
 #line 390 "compile.y"      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 {      break;
         yyval=N(POOL);   
         PCA(yyval, yyvsp[0]);    case 90:
 ;  #line 445 "compile.y"
     break;}      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 case 91:      break;
 #line 399 "compile.y"  
 {    case 91:
   #line 447 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_WRITE_EXPR_RESULT);          O(*yyval, OP_STORE_PARAM);
 ;  ;}
     break;}      break;
 case 93:  
 #line 406 "compile.y"    case 92:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 451 "compile.y"
     break;}      {
 case 95:          YYSTYPE expr_code=yyvsp[0];
 #line 408 "compile.y"          if(expr_code->count()==3
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;                  && (*expr_code)[0].code==OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP_VALUE+origin+Double]
     break;}                  yyval=expr_code; 
 case 97:                  O(*yyval, OP_STORE_PARAM); // no evaluating
 #line 410 "compile.y"          } else {
 {                  ArrayOperation* code=N();
                   O(*code, OP_PREPARE_TO_EXPRESSION);
                   P(*code, *expr_code);
                   O(*code, OP_WRITE_EXPR_RESULT);
                   yyval=N(); 
                   OA(*yyval, OP_EXPR_CODE__STORE_PARAM, code);
           }
   ;}
       break;
   
     case 93:
   #line 466 "compile.y"
       {
           yyval=N(); 
           OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
   ;}
       break;
   
     case 98:
   #line 478 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 100:
   #line 480 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 102:
   #line 482 "compile.y"
       {
           // we know that name_advance1 not called from ^xxx context
           // so we'll not check for operator call possibility as we do in name_advance2
   
         /* stack: context */          /* 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_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 ;  ;}
     break;}      break;
 case 98:  
 #line 415 "compile.y"    case 103:
 {  #line 490 "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_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
 ;  ;}
     break;}      break;
 case 104:  
 #line 428 "compile.y"    case 109:
 {  #line 503 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT);          O(*yyval, OP_GET_ELEMENT);
 ;  ;}
     break;}      break;
 case 105:  
 #line 432 "compile.y"    case 110:
 {  #line 507 "compile.y"
         yyval=N(POOL);       {
         O(yyval, OP_CREATE_EWPOOL);          ArrayOperation* code;
         P(yyval, yyvsp[-1]);          {
         O(yyval, OP_WRITE_VALUE);                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
         P(yyval, yyvsp[0]);                  P(*code, *yyvsp[0]);
         O(yyval, OP_REDUCE_EWPOOL);          }
 ;          yyval=N(); 
     break;}          OA(*yyval, OP_STRING_POOL, code);
 case 106:  ;}
 #line 440 "compile.y"      break;
 {  
         yyval=N(POOL);     case 111:
         O(yyval, OP_CREATE_EWPOOL);  #line 516 "compile.y"
         P(yyval, yyvsp[-1]);      {
         O(yyval, OP_REDUCE_EWPOOL);          // allow $result_or_other_variable[ letters here any time ]
 ;          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
     break;}  ;}
 case 107:      break;
 #line 446 "compile.y"  
 {    case 112:
         yyval=N(POOL);   #line 519 "compile.y"
         O(yyval, OP_WITH_READ);      {
         P(yyval, yyvsp[0]);          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
 ;  ;}
     break;}      break;
 case 109:  
 #line 451 "compile.y"    case 113:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 521 "compile.y"
     break;}      {
 case 110:          yyval=N(); 
 #line 452 "compile.y"          OA(*yyval, OP_OBJECT_POOL, yyvsp[-2]); /* stack: empty write context */
 {          /* some code that writes to that context */
           /* context=pop; stack: context.value() */
   ;}
       break;
   
     case 114:
   #line 527 "compile.y"
       {
           yyval=N(); 
           O(*yyval, OP_WITH_READ);
           P(*yyval, *yyvsp[0]);
   ;}
       break;
   
     case 116:
   #line 532 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 117:
   #line 533 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT__WRITE);          O(*yyval, OP_GET_ELEMENT__WRITE);
 ;  ;}
     break;}      break;
 case 113:  
 #line 461 "compile.y"    case 120:
 {  #line 542 "compile.y"
       {
         yyval=yyvsp[-1]; // stack: class name string          yyval=yyvsp[-1]; // stack: class name string
         O(yyval, OP_GET_CLASS);          if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
 ;                  if(VStateless_class* base=PC.cclass->base_class()) {
     break;}                          change_string_literal_value(*yyval, base->name());
 case 114:                  } else {
 #line 465 "compile.y"                          strcpy(PC.error, "no base class declared");
 {                          YYERROR;
                   }
           }
           O(*yyval, OP_GET_CLASS);
   ;}
       break;
   
     case 121:
   #line 554 "compile.y"
       {
         yyval=yyvsp[-1];          yyval=yyvsp[-1];
         if(!PC.object_constructor_allowed) {          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_PREPARE_TO_CONSTRUCT_OBJECT);
 ;  ;}
     break;}      break;
 case 115:  
 #line 477 "compile.y"    case 128:
 {  #line 573 "compile.y"
         if((yyval=yyvsp[0])->size()==2) // only one string literal in there?      { yyval = yyvsp[-1] ;}
                 change_string_literal_to_double_literal(yyval); // make that string literal Double      break;
 ;  
     break;}    case 129:
 case 119:  #line 574 "compile.y"
 #line 485 "compile.y"      { yyval = yyvsp[-1] ;}
 { yyval = yyvsp[-1]; ;      break;
     break;}  
 case 120:    case 130:
 #line 486 "compile.y"  #line 575 "compile.y"
 { yyval = yyvsp[-1]; ;      { yyval = yyvsp[-1]; ;}
     break;}      break;
 case 121:  
 #line 487 "compile.y"    case 131:
 { yyval = yyvsp[-1]; ;  #line 577 "compile.y"
     break;}      { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;}
 case 122:      break;
 #line 489 "compile.y"  
 { yyval=yyvsp[0];  O(yyval, OP_NEG) ;    case 132:
     break;}  #line 578 "compile.y"
 case 123:      { yyval=yyvsp[0] ;}
 #line 490 "compile.y"      break;
 { yyval=yyvsp[0];        O(yyval, OP_INV) ;  
     break;}    case 133:
 case 124:  #line 579 "compile.y"
 #line 491 "compile.y"      { yyval=yyvsp[0];    O(*yyval, OP_INV) ;}
 { yyval=yyvsp[0];  O(yyval, OP_NOT) ;      break;
     break;}  
 case 125:    case 134:
 #line 492 "compile.y"  #line 580 "compile.y"
 { yyval=yyvsp[0];  O(yyval, OP_DEF) ;      { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;}
     break;}      break;
 case 126:  
 #line 493 "compile.y"    case 135:
 { yyval=yyvsp[0];  O(yyval, OP_IN) ;  #line 581 "compile.y"
     break;}      { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;}
 case 127:      break;
 #line 494 "compile.y"  
 { yyval=yyvsp[0];  O(yyval, OP_FEXISTS) ;    case 136:
     break;}  #line 582 "compile.y"
 case 128:      { yyval=yyvsp[0];  O(*yyval, OP_IN) ;}
 #line 495 "compile.y"      break;
 { yyval=yyvsp[0];  O(yyval, OP_DEXISTS) ;  
     break;}    case 137:
 case 129:  #line 583 "compile.y"
 #line 497 "compile.y"      { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;}
 {       yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_SUB) ;      break;
     break;}  
 case 130:    case 138:
 #line 498 "compile.y"  #line 584 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_ADD) ;      { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;}
     break;}      break;
 case 131:  
 #line 499 "compile.y"    case 139:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MUL) ;  #line 586 "compile.y"
     break;}      {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;}
 case 132:      break;
 #line 500 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_DIV) ;    case 140:
     break;}  #line 587 "compile.y"
 case 133:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;}
 #line 501 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MOD) ;  
     break;}    case 141:
 case 134:  #line 588 "compile.y"
 #line 502 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;}
 { yyval=yyvsp[-2];      P(yyval, yyvsp[0]);  O(yyval, OP_BIN_AND) ;      break;
     break;}  
 case 135:    case 142:
 #line 503 "compile.y"  #line 589 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_OR) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;}
     break;}      break;
 case 136:  
 #line 504 "compile.y"    case 143:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_XOR) ;  #line 590 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;}
 case 137:      break;
 #line 505 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_AND) ;    case 144:
     break;}  #line 591 "compile.y"
 case 138:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;}
 #line 506 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_OR) ;  
     break;}    case 145:
 case 139:  #line 592 "compile.y"
 #line 507 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_XOR) ;      break;
     break;}  
 case 140:    case 146:
 #line 508 "compile.y"  #line 593 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LT) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;}
     break;}      break;
 case 141:  
 #line 509 "compile.y"    case 147:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GT) ;  #line 594 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;}
 case 142:      break;
 #line 510 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LE) ;    case 148:
     break;}  #line 595 "compile.y"
 case 143:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;}
 #line 511 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GE) ;  
     break;}    case 149:
 case 144:  #line 596 "compile.y"
 #line 512 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_EQ) ;      break;
     break;}  
 case 145:    case 150:
 #line 513 "compile.y"  #line 597 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_NE) ;      { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;}
     break;}      break;
 case 146:  
 #line 514 "compile.y"    case 151:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LT) ;  #line 598 "compile.y"
     break;}      { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;}
 case 147:      break;
 #line 515 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GT) ;    case 152:
     break;}  #line 599 "compile.y"
 case 148:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;}
 #line 516 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LE) ;  
     break;}    case 153:
 case 149:  #line 600 "compile.y"
 #line 517 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;}
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GE) ;      break;
     break;}  
 case 150:    case 154:
 #line 518 "compile.y"  #line 601 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_EQ) ;      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;}
     break;}      break;
 case 151:  
 #line 519 "compile.y"    case 155:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_NE) ;  #line 602 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;}
 case 152:      break;
 #line 520 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_IS) ;    case 156:
     break;}  #line 603 "compile.y"
 case 153:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;}
 #line 523 "compile.y"      break;
 {  
         yyval=N(POOL);    case 157:
         O(yyval, OP_CREATE_SWPOOL); /* stack: empty write context */  #line 604 "compile.y"
         P(yyval, yyvsp[0]); /* some code that writes to that context */      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;}
         O(yyval, OP_REDUCE_SWPOOL); /* context=pop; stack: context.get_string() */      break;
 ;  
     break;}    case 158:
 case 154:  #line 605 "compile.y"
 #line 532 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;}
 {      break;
   
     case 159:
   #line 606 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;}
       break;
   
     case 160:
   #line 607 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;}
       break;
   
     case 161:
   #line 608 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;}
       break;
   
     case 162:
   #line 609 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;}
       break;
   
     case 163:
   #line 610 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;}
       break;
   
     case 164:
   #line 611 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;}
       break;
   
     case 165:
   #line 612 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;}
       break;
   
     case 166:
   #line 615 "compile.y"
       {
           // optimized from OP_STRING->OP_VALUE for doubles
           maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
   ;}
       break;
   
     case 167:
   #line 620 "compile.y"
       {
           yyval=N();
           OA(*yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */
           /* some code that writes to that context */
           /* context=pop; stack: context.get_string() */
   ;}
       break;
   
     case 168:
   #line 629 "compile.y"
       {
         // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE          // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
         change_string_literal_to_write_string_literal(yyval=yyvsp[0])          change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
 ;  ;}
     break;}      break;
 case 155:  
 #line 537 "compile.y"    case 169:
 { yyval=VL(NEW VVoid(POOL)) ;  #line 634 "compile.y"
     break;}      { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0) ;}
 case 156:      break;
 #line 538 "compile.y"  
 { yyval=N(POOL) ;    case 170:
     break;}  #line 635 "compile.y"
 }      { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vtrue), 0, 0, 0) ;}
    /* the action file gets copied in in place of this dollarsign */      break;
 #line 543 "D:/cygwin/usr/share/bison.simple"  
     case 171:
   #line 636 "compile.y"
       { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0) ;}
       break;
   
     case 172:
   #line 638 "compile.y"
       { yyval=N() ;}
       break;
   
   
       }
   
   /* Line 993 of yacc.c.  */
   #line 2224 "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 540 "compile.y"  
   
   #line 640 "compile.y"
   
 #endif  #endif
   
Line 1824  yyerrhandle: Line 2465  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.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);
   
                 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.ls!=LS_COMMENT && PC.ls!=LS_DEF_COMMENT)                   if(pc.pos.col==0+1 && c=='@') {
                         switch(*PC.source) {                          if(pc.ls==LS_DEF_SPECIAL_BODY) {
                         // escaping: ^^ & co                                  // @SPECIAL
                                   // ...
                                   // @<here = 
                                   pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state
                           } // continuing checks
                           if(pc.ls==LS_USER) {
                                   push_LS(pc, LS_DEF_NAME);
                                   RC;
                           } else // @ in first column inside some code [when could that be?]
                                   result=BAD_METHOD_DECL_START;
                           goto break2;
                   }
                   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_WITHOUT_COLON:
   case LS_VAR_NAME_SIMPLE_WITH_COLON:
   case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
   case LS_VAR_NAME_CURLY:
   case LS_METHOD_NAME:
   case LS_USER_COMMENT:
   case LS_DEF_COMMENT:
           // no literals in names, please
           break;
   default:
                           switch(*pc.source) {
                           // ^escaping some punctuators
                         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
                                 begin=PC.source; // ^                                  begin=pc.source; // ->punctuation
                                 begin_line=PC.line;                                  begin_pos=pc.pos;
                                 // skip over ^ and _                                  // skip over _ after ^
                                 PC.source++;  PC.col++;                                  pc.source++;  pc.pos.col++;
                                 // skip analysis = forced literal                                  // skip analysis = forced literal
                                 continue;                                  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[0]=='#' && pc.source[1] && 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;                                  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_COMMENT);                          push_LS(pc, LS_USER_COMMENT);
                           continue;
                 }                  }
                 switch(PC.ls) {                  switch(pc.ls) {
   
                 // USER'S = NOT OURS                  // USER'S = NOT OURS
                 case LS_USER:                  case LS_USER:
                         if(PC.trim_bof)                  case LS_NAME_SQUARE_PART: // name.[here].xxx
                           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);                                  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.col==0+1) {                                  if(pc.ls==LS_NAME_SQUARE_PART)
                                         push_LS(PC, LS_DEF_NAME);                                          if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
                                         RC;                                                  pop_LS(pc); // $name.[co<]>de<]!>
                                 }                                                  RC;
                                 break;                                          }
                         case ')': // $name.(code<)>  
                                 if(--lexical_brackets_nestage==0) {  
                                         pop_LS(PC);  
                                         RC;  
                                 }  
                                 break;                                  break;
                         case '(':                          case '[': // $name.[co<[>de]
                                 lexical_brackets_nestage++;                                  if(pc.ls==LS_NAME_SQUARE_PART)
                                           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_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 1964  static int yylex(YYSTYPE *lvalp, void *p Line 2666  static int yylex(YYSTYPE *lvalp, void *p
                         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);                                  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 1983  static int yylex(YYSTYPE *lvalp, void *p Line 2685  static int yylex(YYSTYPE *lvalp, void *p
                 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;
   
                 case LS_DEF_PARAMS:                  case LS_DEF_PARAMS:
                         switch(c) {                          switch(c) {
                           case '$': // common error
                                   result=BAD_METHOD_PARAMETER_NAME_CHARACTER;
                                   goto break2;
                         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 2010  static int yylex(YYSTYPE *lvalp, void *p Line 2715  static int yylex(YYSTYPE *lvalp, void *p
                         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;
   
                 case LS_DEF_SPECIAL_BODY:                  case LS_DEF_SPECIAL_BODY:
                         //                          @todo in case                          if(c=='\n')
                         // ################  
                         // @next-method  
                         // we are here with c=='@'  
                         // which is wrong, and need action  
                         if(c=='\n') {  
                                 switch(*PC.source) {  
                                 case '@': case 0: // end of special_code  
                                         pop_LS(PC);  
                                         break;  
                                 }  
                                 RC;                                  RC;
                         }  
                         break;                          break;
   
                 // (EXPRESSION)                  // (EXPRESSION)
Line 2047  static int yylex(YYSTYPE *lvalp, void *p Line 2741  static int yylex(YYSTYPE *lvalp, void *p
                         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
                                   if(end!=begin) {
                                           if(!pc.string_start)
                                                   pc.string_start=begin_pos;
                                           // append piece till #
                                           pc.string.append_strdup_know_length(begin, end-begin);
                                   }
                                   // fall into COMMENT lexical state [wait for \n]
                                   push_LS(pc, LS_EXPRESSION_COMMENT);
                                   lexical_brackets_nestage=1;
                                   continue;
                         case '$':                          case '$':
                                 push_LS(PC, LS_EXPRESSION_VAR_NAME);                                                              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 2071  static int yylex(YYSTYPE *lvalp, void *p Line 2776  static int yylex(YYSTYPE *lvalp, void *p
                                         skip_analized=1;                                          skip_analized=1;
                                         result=DEXISTS;                                          result=DEXISTS;
                                         goto break2;                                          goto break2;
                                 default:                                  default: // minus
                                         result=c;                                          result=c;
                                         goto break2;                                          goto break2;
                                 }                                  }
                                 goto break2;                                  goto break2;
                         case '+': case '*': case '/': case '%':                           case '+': case '*': case '/': case '%': case '\\':
                         case '~':                          case '~':
                         case ';':                          case ';':
                                 RC;                                  RC;
                         case '&': case '|':  case '#':                          case '&': case '|':
                                 if(*PC.source==c) { // && ||                                  if(*pc.source==c) { // && ||
                                         result=c=='#'?LXOR: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 '>': case '=': case '!':                           case '!':
                                 if(*PC.source=='=') { // <= >= == !=                                  switch(pc.source[0]) { 
                                   case '|': // !| !||
                                         skip_analized=1;                                          skip_analized=1;
                                         switch(c) {                                          if(pc.source[1]=='|') {
                                         case '<': result=NLE; break;                                                  skip_analized++;
                                         case '>': result=NGE; break;                                                  result=LXOR;
                                         case '=': result=NEQ; break;                                          } else
                                         case '!': result=NNE; break;                                                  result=NXOR;
                                         }                                          goto break2;
                                 } else                                  case '=': // !=
                                         result=c;                                          skip_analized=1;
                                           result=NNE; 
                                           goto break2;
                                   }
                                   RC;
   
                           case '<': // <<, <=, <
                                   switch(*pc.source) {
                                   case '<': // <[<]
                                           skip_analized=1; result=NSL; break;
                                   case '=': // <[=]
                                           skip_analized=1; result=NLE; break;
                                   default: // <[]
                                           result=c; break;
                                   }
                                 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 2127  static int yylex(YYSTYPE *lvalp, void *p Line 2866  static int yylex(YYSTYPE *lvalp, void *p
                                 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 2142  static int yylex(YYSTYPE *lvalp, void *p Line 2881  static int yylex(YYSTYPE *lvalp, void *p
                                 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;                                                  skip_analized=2;
                                                 result=DEF;                                                  result=DEF;
                                                 goto break2;                                                  goto break2;
                                         }                                          }
                                 break;                                  break;
                           case 't':
                                   if(end==begin) // right after whitespace
                                           if(pc.source[0]=='r' && pc.source[1]=='u' && pc.source[2]=='e') { // def
                                                   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') { // def
                                                   skip_analized=4;
                                                   result=LITERAL_FALSE;
                                                   goto break2;
                                           }
                                   break;
                         case ' ': case '\t': case '\n':                          case ' ': case '\t': case '\n':
                                 if(end!=begin) { // there were a string after previous operator?                                  if(end!=begin) { // there were a string after previous operator?
                                         result=0; // return that string                                          result=0; // return that string
Line 2156  static int yylex(YYSTYPE *lvalp, void *p Line 2911  static int yylex(YYSTYPE *lvalp, void *p
                                 // 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;
                           }
                           break;
                   case LS_EXPRESSION_COMMENT:
                           if(c=='(')
                                   lexical_brackets_nestage++;
                           
                           switch(*pc.source) {
                           case '\n': case ')':
                                   if(*pc.source==')')
                                           if(--lexical_brackets_nestage!=0)
                                                   continue;
   
                                   // skip comment
                                   begin=pc.source;
                                   begin_pos=pc.pos;
   
                                   pop_LS(pc);
                                 continue;                                  continue;
                         }                          }
                         break;                          break;
   
                 // VARIABLE GET/PUT/WITH                  // VARIABLE GET/PUT/WITH
                 case LS_VAR_NAME_SIMPLE:                  case LS_VAR_NAME_SIMPLE_WITH_COLON: 
                 case LS_EXPRESSION_VAR_NAME:                  case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
                 case LS_VAR_NAME_NO_COLON:                  case LS_EXPRESSION_VAR_NAME_WITH_COLON: 
                         if(PC.ls==LS_EXPRESSION_VAR_NAME) {                  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
                                 // name in expr ends also before binary operators                           if(
                                   pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
                                   pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                   // name in expr ends also before 
                                 switch(c) {                                  switch(c) {
                                   // expression minus
                                 case '-':                                   case '-': 
                                         pop_LS(PC);                                  // expression integer division
                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }                                  case '\\':
                                           pop_LS(pc);
                                           pc.ungetc();
                                         result=EON;                                          result=EON;
                                         goto break2;                                          goto break2;
                                 }                                  }
                         }                          }
                         if(PC.ls==LS_VAR_NAME_NO_COLON) {                          if(
                                   pc.ls==LS_VAR_NAME_SIMPLE_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 2197  static int yylex(YYSTYPE *lvalp, void *p Line 2978  static int yylex(YYSTYPE *lvalp, void *p
                         case '&': case '|':                           case '&': case '|': 
                         case '=': case '!':                          case '=': case '!':
                         // common delimiters                          // common delimiters
                         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 '[':
                                 PC.ls=LS_VAR_SQUARE;                                  // $name.<[>code]
                                   if(pc.pos.col>1/*not first column*/ && (
                                           end[-1]=='$'/*was start of get*/ ||
                                           end[-1]==':'/*was class name delim */ ||
                                           end[-1]=='.'/*was name delim */
                                           )) {
                                           push_LS(pc, LS_NAME_SQUARE_PART);
                                           lexical_brackets_nestage=1;
                                           RC;
                                   }
                                   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 '(':
                                 // $name.<(>code)                                  pc.ls=LS_VAR_ROUND;
                                 if(PC.col>1/*not first column*/ && (  
                                         end[-1]=='.'/*was dot */ ||  
                                         end[-1]=='$'/*was start of get*/  
                                         )) {  
                                         push_LS(PC, LS_USER);  
                                         lexical_brackets_nestage=1;  
                                         RC;  
                                 }  
                                 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
                                 PC.ls=LS_VAR_NAME_NO_COLON; // stop before next ':'                                  // go to _WITHOUT_COLON state variant...
                                   if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
                                           pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
                                   else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
                                           pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
                                   // ...stop before next ':'
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
   
                 case LS_VAR_NAME_CURLY:                  case LS_VAR_NAME_CURLY:
                         switch(c) {                          switch(c) {
                         case '(':                          case '[':
                                 // ${name.<(>code)}                                  // ${name.<[>code]}
                                 push_LS(PC, LS_USER);                                  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 2258  static int yylex(YYSTYPE *lvalp, void *p Line 3047  static int yylex(YYSTYPE *lvalp, void *p
                 case LS_VAR_SQUARE:                  case LS_VAR_SQUARE:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE);                                  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 2280  static int yylex(YYSTYPE *lvalp, void *p Line 3069  static int yylex(YYSTYPE *lvalp, void *p
                 case LS_VAR_CURLY:                  case LS_VAR_CURLY:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE);                                  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 2301  static int yylex(YYSTYPE *lvalp, void *p Line 3090  static int yylex(YYSTYPE *lvalp, void *p
                 case LS_METHOD_NAME:                  case LS_METHOD_NAME:
                         switch(c) {                          switch(c) {
                         case '[':                          case '[':
                                 PC.ls=LS_METHOD_SQUARE;                                  // ^name.<[>code].xxx
                                   if(pc.pos.col>1/*not first column*/ && (
                                           end[-1]=='^'/*was start of call*/ || // never, ^[ is literal...
                                           end[-1]==':'/*was class name delim */ ||
                                           end[-1]=='.'/*was name delim */
                                           )) {
                                           push_LS(pc, LS_NAME_SQUARE_PART);
                                           lexical_brackets_nestage=1;
                                           RC;
                                   }
                                   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 '(':
                                 // $name.<(>code)                                  pc.ls=LS_METHOD_ROUND;
                                 if(PC.col>1/*not first column*/ && (  
                                         end[-1]=='.'/*was dot */ ||  
                                         end[-1]=='^'/*was start of call*/  
                                         )) {  
                                         push_LS(PC, LS_USER);  
                                         lexical_brackets_nestage=1;  
                                         RC;  
                                 }  
                                 PC.ls=LS_METHOD_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 ':': // ':name' or 'class:name'                          case ':': // ':name' or 'class:name'
                           case '^': // ^abc^xxx wrong. bailing out
                           case ']': case '}': case ')': // ^abc]}) wrong. bailing out
                           case ' ': // ^if ( wrong. bailing out
                                 RC;                                  RC;
                         }                          }
                         break;                          break;
Line 2331  static int yylex(YYSTYPE *lvalp, void *p Line 3124  static int yylex(YYSTYPE *lvalp, void *p
                 case LS_METHOD_SQUARE:                  case LS_METHOD_SQUARE:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE);                                  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 2353  static int yylex(YYSTYPE *lvalp, void *p Line 3146  static int yylex(YYSTYPE *lvalp, void *p
                 case LS_METHOD_CURLY:                  case LS_METHOD_CURLY:
                         switch(c) {                          switch(c) {
                         case '$':                          case '$':
                                 push_LS(PC, LS_VAR_NAME_SIMPLE);                                  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 2370  static int yylex(YYSTYPE *lvalp, void *p Line 3163  static int yylex(YYSTYPE *lvalp, void *p
                                 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 2407  break2: Line 3210  break2:
                         if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME                          if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
                                 end--;                                  end--;
                 }                  }
                 if(end!=begin && PC.ls!=LS_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.4  
changed lines
  Added in v.1.113

E-mail: