[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.2 and 1.117

version 1.2, 2001/08/06 16:18:26 version 1.117, 2008/06/10 14:07:05
Line 1 Line 1
   /* A Bison parser, made by GNU Bison 1.875d.  */
   
 /*  A Bison parser, made from compile.y  /* Skeleton parser for Yacc-like parsing with Bison,
     by GNU Bison version 1.28  */     Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   
 #define YYBISON 1  /* Identify Bison output.  */     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.
   
 #define EON     257     This program is distributed in the hope that it will be useful,
 #define STRING  258     but WITHOUT ANY WARRANTY; without even the implied warranty of
 #define BOGUS   259     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #define BAD_STRING_COMPARISON_OPERATOR  260     GNU General Public License for more details.
 #define BAD_HEX_LITERAL 261  
 #define LAND    262  
 #define LOR     263  
 #define LXOR    264  
 #define NLE     265  
 #define NGE     266  
 #define NEQ     267  
 #define NNE     268  
 #define SLT     269  
 #define SGT     270  
 #define SLE     271  
 #define SGE     272  
 #define SEQ     273  
 #define SNE     274  
 #define DEF     275  
 #define IN      276  
 #define FEXISTS 277  
 #define DEXISTS 278  
 #define IS      279  
 #define NEG     280  
   
 #line 8 "compile.y"     You should have received a copy of the GNU General Public License
      along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.  */
   
   /* As a special exception, when this file is copied by Bison into a
      Bison output file, you may use that output file without restriction.
      This special exception was added by the Free Software Foundation
      in version 1.24 of Bison.  */
   
 static char *RCSId="$Id$";   /* Written by Richard Stallman by simplifying the original so called
      ``semantic'' parser.  */
   
   /* All symbols defined below should begin with yy or YY, to avoid
      infringing on user name space.  This should be done even for local
      variables, as they might otherwise be expanded by user macros.
      There are some unavoidable exceptions within include files to
      define necessary library symbols; they are noted "INFRINGES ON
      USER NAME SPACE" below.  */
   
   /* Identify Bison output.  */
   #define YYBISON 1
   
   /* Skeleton name.  */
   #define YYSKELETON_NAME "yacc.c"
   
   /* Pure parsers.  */
   #define YYPURE 1
   
   /* Using locations.  */
   #define YYLSP_NEEDED 0
   
   
   
   /* Tokens.  */
   #ifndef YYTOKENTYPE
   # define YYTOKENTYPE
      /* Put the tokens into the symbol table, so that GDB and other debuggers
         know about them.  */
      enum yytokentype {
        EON = 258,
        STRING = 259,
        BOGUS = 260,
        BAD_STRING_COMPARISON_OPERATOR = 261,
        BAD_HEX_LITERAL = 262,
        BAD_METHOD_DECL_START = 263,
        BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
        BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,
        LAND = 266,
        LOR = 267,
        LXOR = 268,
        NXOR = 269,
        NLE = 270,
        NGE = 271,
        NEQ = 272,
        NNE = 273,
        NSL = 274,
        NSR = 275,
        SLT = 276,
        SGT = 277,
        SLE = 278,
        SGE = 279,
        SEQ = 280,
        SNE = 281,
        DEF = 282,
        IN = 283,
        FEXISTS = 284,
        DEXISTS = 285,
        IS = 286,
        LITERAL_TRUE = 287,
        LITERAL_FALSE = 288,
        NUNARY = 289
      };
   #endif
   #define EON 258
   #define STRING 259
   #define BOGUS 260
   #define BAD_STRING_COMPARISON_OPERATOR 261
   #define BAD_HEX_LITERAL 262
   #define BAD_METHOD_DECL_START 263
   #define BAD_METHOD_PARAMETER_NAME_CHARACTER 264
   #define BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE 265
   #define LAND 266
   #define LOR 267
   #define LXOR 268
   #define NXOR 269
   #define NLE 270
   #define NGE 271
   #define NEQ 272
   #define NNE 273
   #define NSL 274
   #define NSR 275
   #define SLT 276
   #define SGT 277
   #define SLE 278
   #define SGE 279
   #define SEQ 280
   #define SNE 281
   #define DEF 282
   #define IN 283
   #define FEXISTS 284
   #define DEXISTS 285
   #define IS 286
   #define LITERAL_TRUE 287
   #define LITERAL_FALSE 288
   #define NUNARY 289
   
   
   
   
   /* Copy the first part of user declarations.  */
   #line 1 "compile.y"
   
   /** @file
           Parser: compiler(lexical parser and grammar).
   
           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"
   #define OPTIONS_CONTROL_METHOD_NAME "OPTION"
   
   // forwards
   
 static int real_yyerror(parse_control *pc, char *s);  static int real_yyerror(Parse_control* pc, char* s);
 static void yyprint(FILE *file, int type, YYSTYPE value);  static void yyprint(FILE* file, int type, YYSTYPE value);
 static int yylex(YYSTYPE *lvalp, void *pc);  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 218 "compile.tab.C"
   
   #if ! defined (yyoverflow) || YYERROR_VERBOSE
   
   # ifndef YYFREE
   #  define YYFREE free
   # endif
   # ifndef YYMALLOC
   #  define YYMALLOC malloc
   # endif
   
   /* The parser invokes alloca or malloc; define the necessary symbols.  */
   
   # ifdef YYSTACK_USE_ALLOCA
   #  if YYSTACK_USE_ALLOCA
   #   define YYSTACK_ALLOC alloca
   #  endif
   # else
   #  if defined (alloca) || defined (_ALLOCA_H)
   #   define YYSTACK_ALLOC alloca
   #  else
   #   ifdef __GNUC__
   #    define YYSTACK_ALLOC __builtin_alloca
   #   endif
   #  endif
   # endif
   
   # ifdef YYSTACK_ALLOC
      /* Pacify GCC's `empty if-body' warning. */
   #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
   # else
   #  if defined (__STDC__) || defined (__cplusplus)
   #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
   #   define YYSIZE_T size_t
   #  endif
   #  define YYSTACK_ALLOC YYMALLOC
   #  define YYSTACK_FREE YYFREE
   # endif
   #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
   
   
   #if (! defined (yyoverflow) \
        && (! defined (__cplusplus) \
            || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
   
   /* A type that is properly aligned for any stack member.  */
   union yyalloc
   {
     short int yyss;
     YYSTYPE yyvs;
     };
   
   /* The size of the maximum gap between one aligned stack and the next.  */
   # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
   
   /* The size of an array large to enough to hold all stacks, each with
      N elements.  */
   # define YYSTACK_BYTES(N) \
        ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
         + YYSTACK_GAP_MAXIMUM)
   
   /* Copy COUNT objects from FROM to TO.  The source and destination do
      not overlap.  */
   # ifndef YYCOPY
   #  if defined (__GNUC__) && 1 < __GNUC__
   #   define YYCOPY(To, From, Count) \
         __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
   #  else
   #   define YYCOPY(To, From, Count)              \
         do                                        \
           {                                       \
             register YYSIZE_T yyi;                \
             for (yyi = 0; yyi < (Count); yyi++)   \
               (To)[yyi] = (From)[yyi];            \
           }                                       \
         while (0)
   #  endif
   # endif
   
   /* Relocate STACK from its old location to the new one.  The
      local variables YYSIZE and YYSTACKSIZE give the old and new number of
      elements in the stack, and YYPTR gives the new location of the
      stack.  Advance YYPTR to a properly aligned location for the next
      stack.  */
   # define YYSTACK_RELOCATE(Stack)                                        \
       do                                                                  \
         {                                                                 \
           YYSIZE_T yynewbytes;                                            \
           YYCOPY (&yyptr->Stack, Stack, yysize);                          \
           Stack = &yyptr->Stack;                                          \
           yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
           yyptr += yynewbytes / sizeof (*yyptr);                          \
         }                                                                 \
       while (0)
   
   #endif
   
 #define YYFINAL         240  #if defined (__STDC__) || defined (__cplusplus)
 #define YYFLAG          -32768     typedef signed char yysigned_char;
 #define YYNTBASE        54  #else
      typedef short int yysigned_char;
 #define YYTRANSLATE(x) ((unsigned)(x) <= 280 ? yytranslate[x] : 132)  #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,   261,   264,   266,   268,   271,   274,   276,  #define YYNSTATES  263
    278,   281,   284,   286,   288,   290,   292,   296,   300,   304,  
    307,   310,   313,   316,   319,   322,   325,   329,   333,   337,  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    341,   345,   349,   353,   357,   361,   365,   369,   373,   377,  #define YYUNDEFTOK  2
    381,   385,   389,   393,   397,   401,   405,   409,   413,   417,  #define YYMAXUTOK   289
    421,   423,   425,   426  
   #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,   131,     YYRHS.  */
      0,    60,     0,    61,     0,    60,    61,     0,    62,    40,  static const unsigned short int yyprhs[] =
      0,   131,     0,     4,     0,    39,     4,    65,    64,    68,  {
     40,    69,     0,   131,     0,    65,     0,    41,    66,    42,         0,     0,     3,     5,     7,     9,    12,    14,    16,    18,
      0,   131,     0,    67,     0,     4,     0,    67,    43,     4,        23,    25,    27,    29,    32,    35,    37,    39,    40,    49,
      0,   131,     0,     4,     0,   131,     0,    70,     0,    71,        51,    53,    57,    59,    61,    63,    67,    69,    71,    73,
      0,    70,    71,     0,   129,     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,   123,    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,   123,   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,   126,    49,     0,    45,    69,    46,     0,   130,     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,   130,     0,     4,     0,    91,     0,   126,  
      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,    44,   120,     0,  
      4,   121,     0,     4,     0,   122,     0,   121,   122,     0,  
     44,   120,     0,   124,     0,   125,     0,     4,    51,     0,  
    124,    51,     0,   127,     0,     4,     0,    74,     0,    95,  
      0,    52,   128,    52,     0,    53,   128,    53,     0,    48,  
    127,    49,     0,    33,   127,     0,    32,   127,     0,    28,  
    127,     0,    21,   127,     0,    22,   127,     0,    23,   127,  
      0,    24,   127,     0,   127,    33,   127,     0,   127,    34,  
    127,     0,   127,    35,   127,     0,   127,    36,   127,     0,  
    127,    37,   127,     0,   127,    31,   127,     0,   127,    30,  
    127,     0,   127,    29,   127,     0,   127,     8,   127,     0,  
    127,     9,   127,     0,   127,    10,   127,     0,   127,    26,  
    127,     0,   127,    27,   127,     0,   127,    11,   127,     0,  
    127,    12,   127,     0,   127,    13,   127,     0,   127,    14,  
    127,     0,   127,    15,   127,     0,   127,    16,   127,     0,  
    127,    17,   127,     0,   127,    18,   127,     0,   127,    19,  
    127,     0,   127,    20,   127,     0,   127,    25,   127,     0,  
     69,     0,     4,     0,     0,     0  
 };  };
   
 #endif  /* YYRHS -- A `-1'-separated list of the rules' RHS. */
   static const short int yyrhs[] =
   {
         63,     0,    -1,    65,    -1,    64,    -1,    66,    -1,    64,
         66,    -1,    79,    -1,    67,    -1,    72,    -1,    47,     4,
         48,    68,    -1,   150,    -1,    69,    -1,    70,    -1,    69,
         70,    -1,    71,    48,    -1,   150,    -1,     4,    -1,    -1,
         47,     4,    75,    74,    78,    48,    73,    79,    -1,   150,
         -1,    75,    -1,    49,    76,    50,    -1,   150,    -1,    77,
         -1,     4,    -1,    77,    51,     4,    -1,   150,    -1,     4,
         -1,   150,    -1,    80,    -1,    81,    -1,    80,    81,    -1,
        146,    -1,    82,    -1,    83,    -1,    91,    -1,   106,    -1,
         84,    -1,    52,    85,    -1,    87,     3,    -1,    86,    -1,
         53,    87,    54,    -1,    88,    -1,    89,    -1,    90,    -1,
        139,    90,    -1,   129,    -1,   126,   129,    -1,    52,    92,
         96,    -1,    93,    -1,    94,    -1,    95,    -1,   125,    -1,
         55,   125,    -1,   139,   125,    -1,    97,    -1,   100,    -1,
        101,    -1,    -1,    -1,    49,    98,   102,    99,    50,    -1,
         56,   142,    57,    -1,    53,    79,    54,    -1,   147,    -1,
          4,    -1,   103,    -1,   104,    -1,   105,    -1,    82,    -1,
         81,    80,    -1,   107,    -1,    -1,    -1,    58,   108,   110,
        109,   111,     3,    -1,    87,    -1,   112,    -1,   111,   112,
         -1,   113,    -1,   116,    -1,   117,    -1,    -1,    -1,    49,
        114,   118,   115,    50,    -1,    56,   119,    57,    -1,    53,
        120,    54,    -1,   121,    -1,   118,    51,   121,    -1,   122,
         -1,   119,    51,   122,    -1,   123,    -1,   120,    51,   123,
         -1,   124,    -1,   142,    -1,    79,    -1,   147,    -1,     4,
         -1,   103,    -1,   130,    -1,   126,   130,    -1,   127,    -1,
        126,   127,    -1,   128,    55,    -1,   130,    -1,   130,    -1,
          4,     5,    -1,     4,    -1,   131,    -1,   132,    -1,   133,
         -1,    52,   136,    -1,     4,   137,    -1,    -1,    -1,    49,
        134,    80,   135,    50,    -1,     4,    -1,   138,    -1,   137,
        138,    -1,    52,   136,    -1,   140,    -1,   141,    -1,     4,
         59,    -1,   140,    59,    -1,   143,    -1,   144,    -1,   148,
         -1,   149,    -1,    84,    -1,   107,    -1,    60,   145,    60,
         -1,    61,   145,    61,    -1,    56,   143,    57,    -1,    39,
        143,    -1,    38,   143,    -1,    45,   143,    -1,    46,   143,
         -1,    27,   143,    -1,    28,   143,    -1,    29,   143,    -1,
         30,   143,    -1,   143,    39,   143,    -1,   143,    38,   143,
         -1,   143,    40,   143,    -1,   143,    41,   143,    -1,   143,
         43,   143,    -1,   143,    42,   143,    -1,   143,    19,   143,
         -1,   143,    20,   143,    -1,   143,    37,   143,    -1,   143,
         36,   143,    -1,   143,    14,   143,    -1,   143,    11,   143,
         -1,   143,    12,   143,    -1,   143,    13,   143,    -1,   143,
         34,   143,    -1,   143,    35,   143,    -1,   143,    15,   143,
         -1,   143,    16,   143,    -1,   143,    17,   143,    -1,   143,
         18,   143,    -1,   143,    21,   143,    -1,   143,    22,   143,
         -1,   143,    23,   143,    -1,   143,    24,   143,    -1,   143,
         25,   143,    -1,   143,    26,   143,    -1,   143,    31,   143,
         -1,     4,    -1,    79,    -1,     4,    -1,    -1,    32,    -1,
         33,    -1,    -1
   };
   
 #if YYDEBUG != 0  /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const short yyrline[] = { 0,  static const unsigned short int yyrline[] =
    106,   116,   118,   118,   119,   121,   121,   123,   189,   189,  {
    190,   190,   191,   192,   192,   194,   223,   223,   224,   225,         0,   129,   129,   136,   138,   138,   139,   141,   141,   143,
    225,   226,   226,   228,   228,   232,   232,   234,   234,   235,       233,   233,   234,   234,   235,   236,   236,   238,   238,   287,
    235,   236,   236,   236,   240,   244,   245,   245,   246,   247,       287,   288,   289,   289,   290,   290,   292,   292,   296,   296,
    249,   250,   265,   266,   266,   270,   274,   276,   277,   278,       298,   298,   299,   299,   300,   300,   300,   304,   311,   312,
    293,   298,   300,   301,   302,   305,   311,   317,   323,   325,       312,   313,   315,   316,   317,   339,   340,   340,   344,   349,
    326,   328,   334,   335,   335,   339,   343,   344,   345,   359,       350,   351,   352,   369,   374,   377,   378,   379,   381,   384,
    361,   361,   362,   364,   365,   367,   368,   369,   370,   372,       381,   392,   400,   407,   408,   409,   411,   417,   418,   418,
    374,   376,   378,   380,   382,   386,   390,   394,   396,   397,       422,   428,   431,   428,   447,   449,   449,   451,   452,   453,
    399,   406,   406,   408,   408,   409,   410,   415,   420,   422,       455,   458,   455,   461,   462,   464,   465,   468,   469,   472,
    424,   425,   427,   431,   439,   444,   444,   445,   450,   452,       473,   475,   479,   494,   499,   500,   501,   506,   506,   508,
    454,   458,   470,   474,   476,   477,   478,   479,   480,   482,       508,   509,   510,   518,   523,   526,   527,   528,   529,   531,
    483,   484,   485,   486,   487,   488,   490,   491,   492,   493,       535,   544,   547,   544,   555,   560,   560,   561,   567,   568,
    494,   495,   496,   497,   498,   499,   500,   501,   502,   503,       570,   582,   594,   596,   597,   598,   599,   600,   601,   602,
    504,   505,   506,   507,   508,   509,   510,   511,   512,   513,       603,   605,   606,   607,   608,   609,   610,   611,   612,   614,
    516,   525,   530,   531       615,   616,   617,   618,   619,   620,   621,   622,   623,   624,
        625,   626,   627,   628,   629,   630,   631,   632,   633,   634,
        635,   636,   637,   638,   639,   640,   643,   648,   657,   662,
        663,   664,   666
 };  };
 #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",
 "subvar_ref_name_rdive","subvar_get_writes","subvar__get_write","class_prefix",    "name_expr_wdive", "name_expr_wdive_root", "name_expr_wdive_write",
 "class_static_prefix","class_constructor_prefix","expr_value","expr","string_inside_quotes_value",    "name_expr_wdive_class", "construct", "construct_square", "@2", "@3",
 "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 int 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,   118,   119,   120,   121,   121,   122,   123,   123,        34,    39
    124,   125,   126,   127,   127,   127,   127,   127,   127,   127,  
    127,   127,   127,   127,   127,   127,   127,   127,   127,   127,  
    127,   127,   127,   127,   127,   127,   127,   127,   127,   127,  
    127,   127,   127,   127,   127,   127,   127,   127,   127,   127,  
    128,   129,   130,   131  
 };  };
   # 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,     2,     2,     1,     1,     2,     2,     1,     1,       114,   115,   113,   116,   117,   118,   118,   119,   119,   120,
      2,     2,     1,     1,     1,     1,     3,     3,     3,     2,       120,   121,   122,   123,   124,   124,   124,   125,   125,   126,
      2,     2,     2,     2,     2,     2,     3,     3,     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,
      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[] = {   154,  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    152,     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,    36,    38,     0,    40,    41,         0,     2,     1,     1,     1,     2,     1,     1,     1,     4,
     42,     0,    47,    48,    49,    50,     0,    94,     0,    44,         1,     1,     1,     2,     2,     1,     1,     0,     8,     1,
     92,   101,   102,     0,   109,   110,     0,     4,    29,   154,         1,     3,     1,     1,     1,     3,     1,     1,     1,     1,
    154,   154,    99,     0,   111,   104,   106,   105,   103,     0,         1,     2,     1,     1,     1,     1,     1,     1,     2,     2,
      0,    98,     0,   100,    51,     0,    92,    37,   153,   154,         1,     3,     1,     1,     1,     2,     1,     2,     3,     1,
      0,    46,    53,    54,    55,   100,    95,    45,    93,    96,         1,     1,     1,     2,     2,     1,     1,     1,     0,     0,
     43,    52,   112,    70,    68,    15,     8,    10,    11,     0,         5,     3,     3,     1,     1,     1,     1,     1,     1,     2,
      9,    22,     0,    21,    20,   154,    18,    17,   108,   107,         1,     0,     0,     6,     1,     1,     2,     1,     1,     1,
     39,    93,   152,     0,    31,     0,    61,    62,    63,    59,         0,     0,     5,     3,     3,     1,     3,     1,     3,     1,
      0,   114,     0,     0,     0,     0,     0,     0,     0,     0,         3,     1,     1,     1,     1,     1,     1,     1,     2,     1,
      0,   154,   154,   115,   116,     0,   113,     0,    12,    14,         2,     2,     1,     1,     2,     1,     1,     1,     1,     2,
     13,    19,     0,    25,     0,    24,    65,    56,    58,   123,         2,     0,     0,     5,     1,     1,     2,     2,     1,     1,
    124,   125,   126,   122,   121,   120,     0,   151,     0,     0,         2,     2,     1,     1,     1,     1,     1,     1,     3,     3,
     57,     0,     0,     0,     0,     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,   153,   154,     0,     0,    71,         3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
     73,    74,    75,    23,   154,   119,   117,   118,   135,   136,         3,     3,     3,     3,     3,     3,     1,     1,     1,     0,
    137,   140,   141,   142,   143,   144,   145,   146,   147,   148,         1,     1,     0
    149,   150,   138,   139,   134,   133,   132,   127,   128,   129,  
    130,   131,   152,    90,     0,    79,    85,    88,    87,     0,  
     83,     0,    81,    86,    91,    69,    72,    16,    76,   153,  
    154,    78,     0,    77,    80,    84,    82,     0,     0,     0  
 };  };
   
 static const short yydefgoto[] = {   238,  /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
      5,     6,     7,     8,    87,    88,    89,    90,     9,    96,     STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
     52,    93,    94,   135,   148,    11,    12,    13,    14,   124,     means the default is an error.  */
     26,    27,    28,    29,    30,    31,    16,    32,    33,    34,  static const unsigned char yydefact[] =
     35,    72,    73,    74,    75,   106,   214,   108,   109,    17,  {
    125,    47,   128,    85,   179,   180,   181,   182,   183,   215,       172,   168,     0,     0,    71,     0,     3,     2,     4,     7,
    222,   220,   216,   223,   221,   217,   224,    36,    61,    38,         8,     6,    29,    30,    33,    34,    37,    35,    36,    70,
     39,    40,    62,    42,    43,    59,    56,    57,    63,    45,        32,    28,     0,   105,   111,     0,     0,     0,    38,    40,
     46,   225,   127,   149,    19,   218,    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[] = {    10,  /* YYDEFGOTO[NTERM-NUM]. */
 -32768,    15,    58,-32768,    -8,-32768,-32768,-32768,-32768,-32768,  static const short int yydefgoto[] =
      6,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  {
     80,     4,    32,    70,   105,-32768,-32768,    44,-32768,-32768,        -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
 -32768,   -21,-32768,-32768,-32768,-32768,   106,-32768,    54,-32768,        10,   244,   101,    56,    98,    99,   140,   161,    12,    13,
     19,-32768,-32768,   106,    66,-32768,    70,-32768,-32768,   122,        14,    15,   126,    28,    29,    30,    31,    32,    33,    17,
    124,    92,-32768,    32,-32768,    90,-32768,-32768,-32768,    97,        34,    35,    36,    37,    77,    78,   109,   204,    79,    80,
    106,   101,   106,    90,-32768,   105,   101,-32768,    13,     6,       146,   247,   148,   149,    18,   127,    50,   133,    90,   195,
    108,-32768,-32768,-32768,-32768,   111,-32768,-32768,    19,-32768,       196,   197,   235,   258,   198,   199,   248,   239,   237,   249,
 -32768,-32768,-32768,-32768,-32768,-32768,-32768,    11,-32768,   113,       240,   238,   250,    38,    66,    40,    41,    42,    67,    44,
    117,-32768,   120,   116,-32768,   147,-32768,-32768,-32768,-32768,        45,    46,    62,   142,    64,    60,    61,    68,    48,    49,
 -32768,   101,   128,     6,   139,   144,-32768,-32768,-32768,-32768,       241,   129,   130,   162,    20,   251,   131,   132,    21
    118,-32768,   108,   108,   108,   108,   108,   108,   108,    63,  
    108,     6,     6,-32768,-32768,   162,   230,   -20,-32768,-32768,  
 -32768,-32768,   186,-32768,   172,-32768,     6,-32768,-32768,   351,  
    351,   351,   351,   351,   364,-32768,   188,-32768,   164,   173,  
 -32768,   108,   108,   108,   108,   108,   108,   108,   108,   108,  
    108,   108,   108,   108,   108,   108,   108,   108,   108,   108,  
    108,   108,   108,   108,   108,    14,     6,   108,    20,-32768,  
 -32768,-32768,-32768,-32768,     6,-32768,-32768,-32768,   317,   290,  
    260,   342,   342,   138,   138,   342,   342,   342,   342,   138,  
    138,   351,   342,   342,   359,   158,   364,   109,   109,-32768,  
 -32768,-32768,   141,-32768,   167,-32768,-32768,-32768,-32768,   -13,  
 -32768,   -17,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    14,  
      6,-32768,   108,-32768,-32768,-32768,-32768,   227,   228,-32768  
 };  };
   
 static const short yypgoto[] = {-32768,  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 -32768,-32768,   224,-32768,-32768,-32768,   148,-32768,-32768,-32768,     STATE-NUM.  */
    183,-32768,-32768,-32768,     3,   149,   -10,   -65,-32768,     0,  #define YYPACT_NINF -107
 -32768,-32768,    91,-32768,-32768,   -28,-32768,-32768,-32768,-32768,  static const short int yypact[] =
 -32768,-32768,-32768,-32768,-32768,-32768,   182,-32768,-32768,-32768,  {
      2,-32768,-32768,-32768,-32768,    73,-32768,-32768,-32768,-32768,        14,  -107,    13,    45,  -107,    28,   -15,  -107,  -107,  -107,
 -32768,-32768,    24,    25,    31,-32768,-32768,    75,   110,    81,      -107,  -107,    21,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
 -32768,   -32,     9,-32768,-32768,   216,-32768,   225,   279,-32768,      -107,  -107,    73,    19,  -107,    50,     6,    44,  -107,  -107,
 -32768,   212,   -76,   161,-32768,   219,   -44        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          401  static const short int yypgoto[] =
   {
       -107,  -107,  -107,  -107,   206,  -107,  -107,  -107,   124,  -107,
 static const short yytable[] = {    15,      -107,  -107,  -107,   170,  -107,  -107,  -107,     1,   -58,    -7,
     49,    18,    10,   105,    78,    91,    95,    98,    53,     1,      -106,  -107,     0,  -107,  -107,    -6,  -107,  -107,   -21,  -107,
     15,    41,    18,     1,    86,    81,   103,   213,    21,    69,      -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
    176,   -98,   226,    70,   177,   233,    71,   178,    78,   231,      -107,   118,  -107,  -107,  -107,     2,  -107,  -107,  -107,  -107,
      2,   234,   232,    67,    81,    58,   140,   141,   142,   143,        43,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,   -17,
    144,   145,   146,   130,   147,    79,    68,    54,     2,     3,       -13,   -16,  -107,   -18,     4,    41,  -107,   -23,     3,  -107,
   -154,   136,    41,     3,    55,     4,     3,     3,   104,     4,      -107,  -107,  -107,  -107,   181,  -107,   183,   239,  -107,  -107,
    176,    22,     4,     4,   177,   -97,    22,   178,    15,    15,       171,    95,  -107,   123,  -107,   142,  -107,  -107,    64
     18,    18,   111,    22,   102,   189,   190,   191,   192,   193,  
    194,   195,   196,   197,   198,   199,   200,   201,   202,   203,  
    204,   205,   206,   207,   208,   209,   210,   211,   212,    65,  
     80,    23,    24,    15,    25,    18,    23,    24,    64,    76,  
    105,   112,    37,    23,    60,    53,    83,    77,    82,    50,  
     51,    15,    15,    18,    18,    86,    49,    92,   113,   114,  
    115,   116,    51,    54,    66,   117,    15,    84,    18,   118,  
    119,    77,   101,   173,   174,   175,    77,   -97,    23,    23,  
    134,   120,   131,    37,    54,   121,   -14,     4,   133,   122,  
    123,   132,   165,   139,   105,   104,   168,   169,   170,   -60,  
    171,   172,   173,   174,   175,    15,    15,    18,    18,   219,  
    -64,   -64,   -89,   -89,    15,   138,    18,   228,   170,   184,  
    171,   172,   173,   174,   175,   152,   153,   154,   155,   156,  
    157,   158,   159,   160,   161,   162,   163,   164,   229,   230,  
    151,   185,   165,   166,   167,   187,   168,   169,   170,   104,  
    171,   172,   173,   174,   175,   188,   239,   240,    48,    15,  
     15,    18,    18,   219,    97,   129,   186,   152,   153,   154,  
    155,   156,   157,   158,   159,   160,   161,   162,   163,   164,  
    107,   227,   137,   235,   165,   166,   167,   237,   168,   169,  
    170,   236,   171,   172,   173,   174,   175,   152,   153,    99,  
    155,   156,   157,   158,   159,   160,   161,   162,   163,   164,  
    100,    44,   126,   150,   165,   166,   167,   110,   168,   169,  
    170,     0,   171,   172,   173,   174,   175,   152,     0,     0,  
    155,   156,   157,   158,   159,   160,   161,   162,   163,   164,  
      0,     0,     0,     0,   165,   166,   167,     0,   168,   169,  
    170,     0,   171,   172,   173,   174,   175,   155,   156,   157,  
    158,   159,   160,   161,   162,   163,   164,     0,     0,     0,  
      0,   165,   166,   167,     0,   168,   169,   170,     0,   171,  
    172,   173,   174,   175,   157,   158,     0,     0,     0,     0,  
    163,   164,     0,     0,     0,     0,   165,     0,     0,     0,  
    168,   169,   170,     0,   171,   172,   173,   174,   175,   168,  
    169,   170,     0,   171,   172,   173,   174,   175,   169,   170,  
      0,   171,   172,   173,   174,   175,   171,   172,   173,   174,  
    175  
 };  };
   
 static const short yycheck[] = {     0,  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
     11,     0,     0,    69,    37,    50,    51,    52,     5,     4,     positive, shift that token.  If negative, reduce the rule which
     11,     3,    11,     4,     4,    44,     4,     4,     4,    41,     number is the opposite.  If zero, do what YYDEFACT says.
     41,     3,     3,    45,    45,    43,    48,    48,    61,    43,     If YYTABLE_NINF, syntax error.  */
     39,    49,    46,    25,    63,     4,   113,   114,   115,   116,  #define YYTABLE_NINF -173
    117,   118,   119,    88,   121,    37,     3,    44,    39,    44,  static const short int yytable[] =
     40,    96,    44,    44,    51,    50,    44,    44,    69,    50,  {
     41,     4,    50,    50,    45,    47,     4,    48,    69,    70,        16,    11,    19,   145,   106,    53,    43,    39,  -103,    70,
     69,    70,    70,     4,    66,   152,   153,   154,   155,   156,        23,   111,    16,    91,    19,    74,    83,    22,     1,    75,
    157,   158,   159,   160,   161,   162,   163,   164,   165,   166,        65,   254,    76,    57,    57,     1,    86,   255,    51,    87,
    167,   168,   169,   170,   171,   172,   173,   174,   175,    25,        72,    71,     2,   143,   112,   113,   114,   115,   242,   116,
     47,    44,    45,   104,    47,   104,    44,    45,     4,     4,       117,   246,    84,    83,    89,   118,   119,    86,    69,    23,
    176,     4,     3,    44,    24,     5,    51,    37,    44,    40,        43,    39,   120,   121,    63,    24,    23,  -172,    25,   122,
     41,   122,   123,   122,   123,     4,   137,     4,    21,    22,      -102,     2,    16,   123,    19,     4,     3,   124,   125,    81,
     23,    24,    41,    44,    25,    28,   137,    47,   137,    32,        58,    58,     4,     3,   108,    16,   110,    19,    59,     4,
     33,    61,    46,    35,    36,    37,    66,    47,    44,    44,        82,     3,   252,    88,   192,   253,   203,     4,   193,     3,
      4,    44,    40,    44,    44,    48,    40,    50,    43,    52,        73,   194,    91,    24,    24,     4,    25,    25,    26,    53,
     53,    42,    25,    46,   230,   176,    29,    30,    31,    42,        27,    24,   144,    85,    25,    26,    16,    82,    19,    16,
     33,    34,    35,    36,    37,   176,   177,   176,   177,   177,       168,    19,    82,    97,    24,   173,   174,    25,    96,   100,
     42,    43,    42,    43,   185,    42,   185,   185,    31,     4,       103,    54,    55,    55,    16,    16,    19,    19,    58,   145,
     33,    34,    35,    36,    37,     8,     9,    10,    11,    12,       -68,   -68,   184,   185,   186,   187,   188,   189,   190,   191,
     13,    14,    15,    16,    17,    18,    19,    20,    42,    43,       107,   192,   136,   137,    16,   193,    19,   -15,   194,   168,
     49,    40,    25,    26,    27,    52,    29,    30,    31,   230,       139,   145,   171,   172,   173,   174,  -102,   135,   -95,   -95,
     33,    34,    35,    36,    37,    53,     0,     0,     5,   230,       179,   180,   168,   138,   151,   141,   181,   173,   174,   200,
    231,   230,   231,   231,    52,    88,    49,     8,     9,    10,       164,   184,   185,   186,   187,   188,   189,   190,   191,   181,
     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,       188,   189,   190,   191,   184,   185,   186,   187,   188,   189,
     69,   179,   104,   230,    25,    26,    27,   233,    29,    30,       190,   191,   201,    16,   236,    19,    53,   202,   206,   -64,
     31,   231,    33,    34,    35,    36,    37,     8,     9,    54,       207,   173,   174,    16,   245,    19,   257,   152,   153,   154,
     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,       155,   262,    52,   156,   157,   158,   159,   134,   160,   185,
     56,     3,    71,   123,    25,    26,    27,    69,    29,    30,       186,   187,   188,   189,   190,   191,   102,   147,   144,   186,
     31,    -1,    33,    34,    35,    36,    37,     8,    -1,    -1,       187,   188,   189,   190,   191,    16,   259,    19,   243,   104,
     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,       261,   260,    47,   105,    16,   256,    19,   128,   163,     0,
     -1,    -1,    -1,    -1,    25,    26,    27,    -1,    29,    30,       144,   150,    16,   236,    19,     0,     0,    16,     0,    19,
     31,    -1,    33,    34,    35,    36,    37,    11,    12,    13,       208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
     14,    15,    16,    17,    18,    19,    20,    -1,    -1,    -1,       218,   219,   220,   221,   222,   223,   224,   225,   226,   227,
     -1,    25,    26,    27,    -1,    29,    30,    31,    -1,    33,       228,   229,   230,   231,   232,   233,   234,   165,   166,   167,
     34,    35,    36,    37,    13,    14,    -1,    -1,    -1,    -1,       168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
     19,    20,    -1,    -1,    -1,    -1,    25,    -1,    -1,    -1,       178,   179,   180,   173,   174,     0,     0,   181,     0,     0,
     29,    30,    31,    -1,    33,    34,    35,    36,    37,    29,       182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
     30,    31,    -1,    33,    34,    35,    36,    37,    30,    31,       184,   185,   186,   187,   188,   189,   190,   191,     0,     0,
     -1,    33,    34,    35,    36,    37,    33,    34,    35,    36,         0,     0,     0,   205,   165,   166,   167,   168,   169,   170,
     37       171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
          0,     0,     0,     0,   181,     0,     0,   182,   183,   184,
        185,   186,   187,   188,   189,   190,   191,   165,   166,     0,
        168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
        178,   179,   180,     0,     0,     0,     0,   181,     0,     0,
        182,   183,   184,   185,   186,   187,   188,   189,   190,   191,
        165,     0,     0,   168,   169,   170,   171,   172,   173,   174,
        175,   176,   177,   178,   179,   180,     0,     0,     0,     0,
        181,     0,     0,   182,   183,   184,   185,   186,   187,   188,
        189,   190,   191,   168,   169,   170,   171,   172,   173,   174,
        175,   176,   177,   178,   179,   180,   173,   174,     0,     0,
        181,     0,     0,   182,   183,   184,   185,   186,   187,   188,
        189,   190,   191,     0,     0,   186,   187,   188,   189,   190,
        191
 };  };
 #define YYPURE 1  
   
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */  
 #line 3 "D:/cygwin/usr/share/bison.simple"  
 /* This file comes from bison-1.28.  */  
   
 /* Skeleton output parser for bison,  static const short int 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 int *bottom, short int *top)
   #else
   static void
   yy_stack_print (bottom, top)
       short int *bottom;
       short int *top;
 #endif  #endif
   {
     YYFPRINTF (stderr, "Stack now");
     for (/* Nothing. */; bottom <= top; ++bottom)
       YYFPRINTF (stderr, " %d", *bottom);
     YYFPRINTF (stderr, "\n");
   }
   
 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;
   
     return yys - yystr - 1;
   }
   #  endif
   # endif
   
   while (i-- > 0)  # ifndef yystpcpy
     *t++ = *f++;  #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
   #   define yystpcpy stpcpy
   #  else
   /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
      YYDEST.  */
   static char *
   #   if defined (__STDC__) || defined (__cplusplus)
   yystpcpy (char *yydest, const char *yysrc)
   #   else
   yystpcpy (yydest, yysrc)
        char *yydest;
        const char *yysrc;
   #   endif
   {
     register char *yyd = yydest;
     register const char *yys = yysrc;
   
     while ((*yyd++ = *yys++) != '\0')
       continue;
   
     return yyd - 1;
 }  }
   #  endif
   # endif
   
   #endif /* !YYERROR_VERBOSE */
   
 #else /* __cplusplus */  
   
   #if YYDEBUG
   /*--------------------------------.
   | Print this symbol on YYOUTPUT.  |
   `--------------------------------*/
   
 /* This is the most reliable way to avoid incompatibilities  #if defined (__STDC__) || defined (__cplusplus)
    in available built-in functions on various systems.  */  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;
   register short *yyssp;    int yyresult;
     /* Number of tokens to shift before error messages enabled.  */
     int yyerrstatus;
     /* Lookahead token as an internal (translated) token number.  */
     int yytoken = 0;
   
     /* Three stacks and their tools:
        `yyss': related to states,
        `yyvs': related to semantic values,
        `yyls': related to locations.
   
        Refer to the stacks thru separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
   
     /* The state stack.  */
     short int yyssa[YYINITDEPTH];
     short int *yyss = yyssa;
     register short int *yyssp;
   
     /* The semantic value stack.  */
     YYSTYPE yyvsa[YYINITDEPTH];
     YYSTYPE *yyvs = yyvsa;
   register YYSTYPE *yyvsp;    register YYSTYPE *yyvsp;
   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */  
   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */  
   
   short yyssa[YYINITDEPTH];     /*  the state stack                     */  
   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */  
   
   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */  
   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */  
   
 #ifdef YYLSP_NEEDED  
   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */  
   YYLTYPE *yyls = yylsa;  
   YYLTYPE *yylsp;  
   
 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)  
 #else  
 #define YYPOPSTACK   (yyvsp--, yyssp--)  #define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif  
   
   int yystacksize = YYINITDEPTH;    YYSIZE_T yystacksize = YYINITDEPTH;
   int yyfree_stacks = 0;  
   
 #ifdef YYPURE    /* The variables used to return semantic value and location from the
   int yychar;       action routines.  */
   YYSTYPE yylval;    YYSTYPE yyval;
   int yynerrs;  
 #ifdef YYLSP_NEEDED  
   YYLTYPE yylloc;  
 #endif  
 #endif  
   
   YYSTYPE yyval;                /*  the variable used to return         */  
                                 /*  semantic values from the action     */  
                                 /*  routines                            */  
   
     /* When reducing, the number of symbols on the RHS of the reduced
        rule.  */
   int yylen;    int yylen;
   
 #if YYDEBUG != 0    YYDPRINTF ((stderr, "Starting parse\n"));
   if (yydebug)  
     fprintf(stderr, "Starting parse\n");  
 #endif  
   
   yystate = 0;    yystate = 0;
   yyerrstatus = 0;    yyerrstatus = 0;
Line 754  yyparse(YYPARSE_PARAM_ARG) Line 1235  yyparse(YYPARSE_PARAM_ARG)
      so that they stay on the same level as the state stack.       so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */       The wasted elements are never initialized.  */
   
   yyssp = yyss - 1;    yyssp = yyss;
   yyvsp = yyvs;    yyvsp = yyvs;
 #ifdef YYLSP_NEEDED  
   yylsp = yyls;  
 #endif  
   
 /* Push a new state, which is found in  yystate  .  */  
 /* In all cases, when you get here, the value and location stacks  
    have just been pushed. so pushing a state here evens the stacks.  */  
 yynewstate:  
   
   *++yyssp = yystate;    goto yysetstate;
   
   if (yyssp >= yyss + yystacksize - 1)  /*------------------------------------------------------------.
     {  | yynewstate -- Push a new state, which is found in yystate.  |
       /* Give user a chance to reallocate the stack */  `------------------------------------------------------------*/
       /* Use copies of these so that the &'s don't force the real ones into memory. */   yynewstate:
       YYSTYPE *yyvs1 = yyvs;    /* In all cases, when you get here, the value and location stacks
       short *yyss1 = yyss;       have just been pushed. so pushing a state here evens the stacks.
 #ifdef YYLSP_NEEDED       */
       YYLTYPE *yyls1 = yyls;    yyssp++;
 #endif  
   
    yysetstate:
     *yyssp = yystate;
   
     if (yyss + yystacksize - 1 <= yyssp)
       {
       /* Get the current used size of the three stacks, in elements.  */        /* Get the current used size of the three stacks, in elements.  */
       int size = yyssp - yyss + 1;        YYSIZE_T yysize = yyssp - yyss + 1;
   
 #ifdef yyoverflow  #ifdef yyoverflow
       /* Each stack pointer address is followed by the size of        {
          the data in use in that stack, in bytes.  */          /* Give user a chance to reallocate the stack. Use copies of
 #ifdef YYLSP_NEEDED             these so that the &'s don't force the real ones into
       /* This used to be a conditional around just the two extra args,             memory.  */
          but that might be undefined if yyoverflow is a macro.  */          YYSTYPE *yyvs1 = yyvs;
       yyoverflow("parser stack overflow",          short int *yyss1 = yyss;
                  &yyss1, size * sizeof (*yyssp),  
                  &yyvs1, size * sizeof (*yyvsp),  
                  &yyls1, size * sizeof (*yylsp),          /* Each stack pointer address is followed by the size of the
                  &yystacksize);             data in use in that stack, in bytes.  This used to be a
 #else             conditional around just the two extra args, but that might
       yyoverflow("parser stack overflow",             be undefined if yyoverflow is a macro.  */
                  &yyss1, size * sizeof (*yyssp),          yyoverflow ("parser stack overflow",
                  &yyvs1, size * sizeof (*yyvsp),                      &yyss1, yysize * sizeof (*yyssp),
                  &yystacksize);                      &yyvs1, yysize * sizeof (*yyvsp),
 #endif  
                       &yystacksize);
       yyss = yyss1; yyvs = yyvs1;  
 #ifdef YYLSP_NEEDED          yyss = yyss1;
       yyls = yyls1;          yyvs = yyvs1;
 #endif        }
 #else /* no yyoverflow */  #else /* no yyoverflow */
   # ifndef YYSTACK_RELOCATE
         goto yyoverflowlab;
   # else
       /* Extend the stack our own way.  */        /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)        if (YYMAXDEPTH <= yystacksize)
         {          goto yyoverflowlab;
           yyerror("parser stack overflow");  
           if (yyfree_stacks)  
             {  
               free (yyss);  
               free (yyvs);  
 #ifdef YYLSP_NEEDED  
               free (yyls);  
 #endif  
             }  
           return 2;  
         }  
       yystacksize *= 2;        yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)        if (YYMAXDEPTH < yystacksize)
         yystacksize = YYMAXDEPTH;          yystacksize = YYMAXDEPTH;
 #ifndef YYSTACK_USE_ALLOCA  
       yyfree_stacks = 1;        {
 #endif          short int *yyss1 = yyss;
       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));          union yyalloc *yyptr =
       __yy_memcpy ((char *)yyss, (char *)yyss1,            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
                    size * (unsigned int) sizeof (*yyssp));          if (! yyptr)
       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));            goto yyoverflowlab;
       __yy_memcpy ((char *)yyvs, (char *)yyvs1,          YYSTACK_RELOCATE (yyss);
                    size * (unsigned int) sizeof (*yyvsp));          YYSTACK_RELOCATE (yyvs);
 #ifdef YYLSP_NEEDED  
       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));  #  undef YYSTACK_RELOCATE
       __yy_memcpy ((char *)yyls, (char *)yyls1,          if (yyss1 != yyssa)
                    size * (unsigned int) sizeof (*yylsp));            YYSTACK_FREE (yyss1);
 #endif        }
   # endif
 #endif /* no yyoverflow */  #endif /* no yyoverflow */
   
       yyssp = yyss + size - 1;        yyssp = yyss + yysize - 1;
       yyvsp = yyvs + size - 1;        yyvsp = yyvs + yysize - 1;
 #ifdef YYLSP_NEEDED  
       yylsp = yyls + size - 1;  
 #endif  
   
 #if YYDEBUG != 0  
       if (yydebug)  
         fprintf(stderr, "Stack size increased to %d\n", yystacksize);  
 #endif  
   
       if (yyssp >= yyss + yystacksize - 1)        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                     (unsigned long int) yystacksize));
   
         if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;          YYABORT;
     }      }
   
 #if YYDEBUG != 0    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
   if (yydebug)  
     fprintf(stderr, "Entering state %d\n", yystate);  
 #endif  
   
   goto yybackup;    goto yybackup;
  yybackup:  
   /*-----------.
   | yybackup.  |
   `-----------*/
   yybackup:
   
 /* Do appropriate processing given the current state.  */  /* Do appropriate processing given the current state.  */
 /* Read a lookahead token if we need one and don't already have one.  */  /* Read a lookahead token if we need one and don't already have one.  */
Line 866  yynewstate: Line 1334  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), ",    /* If YYLEN is nonzero, implement the default value of the action:
                yyn, yyrline[yyn]);       `$$ = $1'.
   
       /* Print the symbols being reduced, and their result.  */       Otherwise, the following line sets YYVAL to garbage.
       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)       This behavior is undocumented and Bison
         fprintf (stderr, "%s ", yytname[yyrhs[i]]);       users should not rely upon it.  Assigning to YYVAL
       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);       unconditionally makes the parser a bit smaller, and it avoids a
     }       GCC warning that YYVAL may be used uninitialized.  */
 #endif    yyval = yyvsp[1-yylen];
   
   
   switch (yyn) {    YY_REDUCE_PRINT (yyn);
     switch (yyn)
 case 1:      {
 #line 107 "compile.y"          case 2:
 {  #line 129 "compile.y"
         Method& method=*NEW Method(POOL,       {
                 *main_method_name,           Method& method=*new Method(Method::CT_ANY,
                 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 144 "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);
                           *PC.cclasses+=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;
                 }                  }
           } else if(command==OPTIONS_CONTROL_METHOD_NAME) {
                   if(1){
                           for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) {
                                   const String& option=*LA2S(*strings_code, i);
                                   if(option==ALL_VARS_LOCAL_NAME){
                                           PC.cclass->all_vars_local();
                                   } else {
                                           strcpy(PC.error, option.cstr());
                                           strcat(PC.error, ": unknown option in @"OPTIONS_CONTROL_METHOD_NAME" was specified.");
                                           YYERROR;
                                   }
                           }
                   } else {
                           strcpy(PC.error, "@"OPTIONS_CONTROL_METHOD_NAME" must be specified for class.");
                   }
         } else {          } else {
                 strcpy(PC.error, "'");                  strcpy(PC.error, "'");
                 strncat(PC.error, command.cstr(), MAX_STRING/2);                  strncat(PC.error, command.cstr(), MAX_STRING/2);
                 strcat(PC.error, "' invalid special name. valid names are "                  strcat(PC.error, "' invalid special name. valid names are "
                         "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"', '"BASE_NAME"' and '"OPTIONS_CONTROL_METHOD_NAME"'.");
                 YYERROR;                  YYERROR;
         }          }
 ;  ;}
     break;}      break;
 case 12:  
 #line 190 "compile.y"    case 13:
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  #line 234 "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 238 "compile.y"
       { 
         YYSTYPE params_names_code=yyvsp[-4];          PC.explicit_result=false;
         Array *params_names=0;  
         if(int size=params_names_code->size()) {          YYSTYPE params_names_code=yyvsp[-3];
                 params_names=NEW Array(POOL);          ArrayString* params_names=0;
                 for(int i=0; i<size; i+=2)          if(int size=params_names_code->count()) {
                         *params_names+=LA2S(params_names_code, i);                  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()) {          bool all_vars_local=false;
                 locals_names=NEW Array(POOL);          if(int size=locals_names_code->count()) {
                 for(int i=0; i<size; i+=2)                  locals_names=new ArrayString;
                         *locals_names+=LA2S(locals_names_code, i);                  for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
                           const String* local_name=LA2S(*locals_names_code, i);
                           if(*local_name==RESULT_VAR_NAME)
                                   PC.explicit_result=true;
                           else if(*local_name==ALL_VARS_LOCAL_NAME)
                                   all_vars_local=true;
                           else
                                   *locals_names+=local_name;
                   }
           }
           if(!all_vars_local && PC.cclass && PC.cclass->is_vars_local()){
                   all_vars_local=true;
         }          }
   
         Method& method=*NEW Method(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, all_vars_local);
         PC.cclass->add_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 278 "compile.y"
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;      {
     break;}          Method& method=*reinterpret_cast<Method*>(yyvsp[-1]);
 case 29:          // fill in the code
 #line 234 "compile.y"          method.parser_code=yyvsp[0];
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;          // register in class
     break;}          const String& name=*LA2S(*yyvsp[-6]);
 case 35:          PC.cclass->add_method(PC.alias_method(name), method);
 #line 240 "compile.y"  ;}
 {      break;
         yyval=yyvsp[0]; /* stack: resulting value */  
         O(yyval, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */    case 21:
 ;  #line 288 "compile.y"
     break;}      {yyval=yyvsp[-1];}
 case 36:      break;
 #line 244 "compile.y"  
 { yyval=yyvsp[0] ;    case 25:
     break;}  #line 290 "compile.y"
 case 39:      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 #line 246 "compile.y"      break;
 { yyval=yyvsp[-1] ;  
     break;}    case 31:
 case 42:  #line 298 "compile.y"
 #line 250 "compile.y"      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 {      break;
         yyval=N(POOL);   
         Array *diving_code=yyvsp[0];    case 37:
         const String *first_name=LA2S(diving_code);  #line 304 "compile.y"
       {
           yyval=yyvsp[0]; /* stack: resulting value */ 
           changetail_or_append(*yyval, 
                   OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
                   /*or */OP_WRITE_VALUE
                   ); /* value=pop; wcontext.write(value) */
   ;}
       break;
   
     case 38:
   #line 311 "compile.y"
       { yyval=yyvsp[0] ;}
       break;
   
     case 41:
   #line 313 "compile.y"
       { yyval=yyvsp[-1] ;}
       break;
   
     case 44:
   #line 317 "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 339 "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 340 "compile.y"
 case 46:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 270 "compile.y"      break;
 {  
     case 48:
   #line 344 "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 352 "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 369 "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 374 "compile.y"
 case 56:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 305 "compile.y"      break;
 {  
     case 58:
   #line 381 "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 384 "compile.y"
       {
           PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
   ;}
       break;
   
     case 60:
   #line 386 "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 392 "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 400 "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 411 "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 418 "compile.y"
 case 66:      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 #line 339 "compile.y"      break;
 {  
     case 70:
   #line 422 "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 428 "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 431 "compile.y"
       {
                                   PC.in_call_value=false;
                           ;}
       break;
   
     case 73:
   #line 434 "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 449 "compile.y"
     break;}      { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
 case 76:      break;
 #line 367 "compile.y"  
 {yyval=yyvsp[-1];    case 80:
     break;}  #line 455 "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 458 "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 460 "compile.y"
     break;}      {yyval=yyvsp[-2];}
 case 84:      break;
 #line 380 "compile.y"  
 { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;    case 83:
     break;}  #line 461 "compile.y"
 case 85:      {yyval=yyvsp[-1];}
 #line 382 "compile.y"      break;
 {  
         yyval=yyvsp[0];    case 84:
         O(yyval, OP_STORE_PARAM);  #line 462 "compile.y"
 ;      {yyval=yyvsp[-1];}
     break;}      break;
 case 86:  
 #line 386 "compile.y"    case 86:
 {  #line 465 "compile.y"
         yyval=N(POOL);       { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
         PEA(yyval, yyvsp[0]);      break;
 ;  
     break;}    case 88:
 case 87:  #line 469 "compile.y"
 #line 390 "compile.y"      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 {      break;
         yyval=N(POOL);   
         PCA(yyval, yyvsp[0]);    case 90:
 ;  #line 473 "compile.y"
     break;}      { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
 case 91:      break;
 #line 399 "compile.y"  
 {    case 91:
   #line 475 "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 479 "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 494 "compile.y"
       {
           yyval=N(); 
           OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
   ;}
       break;
   
     case 98:
   #line 506 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 100:
   #line 508 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 102:
   #line 510 "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 518 "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 103:  
 #line 427 "compile.y"    case 109:
 {  #line 531 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT);          O(*yyval, OP_GET_ELEMENT);
 ;  ;}
     break;}      break;
 case 104:  
 #line 431 "compile.y"    case 110:
 {  #line 535 "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 105:  ;}
 #line 439 "compile.y"      break;
 {  
         yyval=N(POOL);     case 111:
         O(yyval, OP_WITH_READ);  #line 544 "compile.y"
         P(yyval, yyvsp[0]);      {
 ;          // allow $result_or_other_variable[ letters here any time ]
     break;}          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
 case 107:  ;}
 #line 444 "compile.y"      break;
 { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;  
     break;}    case 112:
 case 108:  #line 547 "compile.y"
 #line 445 "compile.y"      {
 {          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
   ;}
       break;
   
     case 113:
   #line 549 "compile.y"
       {
           yyval=N(); 
           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 555 "compile.y"
       {
           yyval=N(); 
           O(*yyval, OP_WITH_READ);
           P(*yyval, *yyvsp[0]);
   ;}
       break;
   
     case 116:
   #line 560 "compile.y"
       { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
       break;
   
     case 117:
   #line 561 "compile.y"
       {
         yyval=yyvsp[0];          yyval=yyvsp[0];
         O(yyval, OP_GET_ELEMENT__WRITE);          O(*yyval, OP_GET_ELEMENT__WRITE);
 ;  ;}
     break;}      break;
 case 111:  
 #line 454 "compile.y"    case 120:
 {  #line 570 "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 112:                  } else {
 #line 458 "compile.y"                          strcpy(PC.error, "no base class declared");
 {                          YYERROR;
                   }
           }
           O(*yyval, OP_GET_CLASS);
   ;}
       break;
   
     case 121:
   #line 582 "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 113:  
 #line 470 "compile.y"    case 128:
 {  #line 601 "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 117:  #line 602 "compile.y"
 #line 478 "compile.y"      { yyval = yyvsp[-1] ;}
 { yyval = yyvsp[-1]; ;      break;
     break;}  
 case 118:    case 130:
 #line 479 "compile.y"  #line 603 "compile.y"
 { yyval = yyvsp[-1]; ;      { yyval = yyvsp[-1]; ;}
     break;}      break;
 case 119:  
 #line 480 "compile.y"    case 131:
 { yyval = yyvsp[-1]; ;  #line 605 "compile.y"
     break;}      { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;}
 case 120:      break;
 #line 482 "compile.y"  
 { yyval=yyvsp[0];  O(yyval, OP_NEG) ;    case 132:
     break;}  #line 606 "compile.y"
 case 121:      { yyval=yyvsp[0] ;}
 #line 483 "compile.y"      break;
 { yyval=yyvsp[0];        O(yyval, OP_INV) ;  
     break;}    case 133:
 case 122:  #line 607 "compile.y"
 #line 484 "compile.y"      { yyval=yyvsp[0];    O(*yyval, OP_INV) ;}
 { yyval=yyvsp[0];  O(yyval, OP_NOT) ;      break;
     break;}  
 case 123:    case 134:
 #line 485 "compile.y"  #line 608 "compile.y"
 { yyval=yyvsp[0];  O(yyval, OP_DEF) ;      { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;}
     break;}      break;
 case 124:  
 #line 486 "compile.y"    case 135:
 { yyval=yyvsp[0];  O(yyval, OP_IN) ;  #line 609 "compile.y"
     break;}      { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;}
 case 125:      break;
 #line 487 "compile.y"  
 { yyval=yyvsp[0];  O(yyval, OP_FEXISTS) ;    case 136:
     break;}  #line 610 "compile.y"
 case 126:      { yyval=yyvsp[0];  O(*yyval, OP_IN) ;}
 #line 488 "compile.y"      break;
 { yyval=yyvsp[0];  O(yyval, OP_DEXISTS) ;  
     break;}    case 137:
 case 127:  #line 611 "compile.y"
 #line 490 "compile.y"      { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;}
 {       yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_SUB) ;      break;
     break;}  
 case 128:    case 138:
 #line 491 "compile.y"  #line 612 "compile.y"
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_ADD) ;      { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;}
     break;}      break;
 case 129:  
 #line 492 "compile.y"    case 139:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MUL) ;  #line 614 "compile.y"
     break;}      {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;}
 case 130:      break;
 #line 493 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_DIV) ;    case 140:
     break;}  #line 615 "compile.y"
 case 131:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;}
 #line 494 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MOD) ;  
     break;}    case 141:
 case 132:  #line 616 "compile.y"
 #line 495 "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 133:    case 142:
 #line 496 "compile.y"  #line 617 "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 134:  
 #line 497 "compile.y"    case 143:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_XOR) ;  #line 618 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;}
 case 135:      break;
 #line 498 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_AND) ;    case 144:
     break;}  #line 619 "compile.y"
 case 136:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;}
 #line 499 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_OR) ;  
     break;}    case 145:
 case 137:  #line 620 "compile.y"
 #line 500 "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 138:    case 146:
 #line 501 "compile.y"  #line 621 "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 139:  
 #line 502 "compile.y"    case 147:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GT) ;  #line 622 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;}
 case 140:      break;
 #line 503 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LE) ;    case 148:
     break;}  #line 623 "compile.y"
 case 141:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;}
 #line 504 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GE) ;  
     break;}    case 149:
 case 142:  #line 624 "compile.y"
 #line 505 "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 143:    case 150:
 #line 506 "compile.y"  #line 625 "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 144:  
 #line 507 "compile.y"    case 151:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LT) ;  #line 626 "compile.y"
     break;}      { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;}
 case 145:      break;
 #line 508 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GT) ;    case 152:
     break;}  #line 627 "compile.y"
 case 146:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;}
 #line 509 "compile.y"      break;
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LE) ;  
     break;}    case 153:
 case 147:  #line 628 "compile.y"
 #line 510 "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 148:    case 154:
 #line 511 "compile.y"  #line 629 "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 149:  
 #line 512 "compile.y"    case 155:
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_NE) ;  #line 630 "compile.y"
     break;}      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;}
 case 150:      break;
 #line 513 "compile.y"  
 { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_IS) ;    case 156:
     break;}  #line 631 "compile.y"
 case 151:      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;}
 #line 516 "compile.y"      break;
 {  
         yyval=N(POOL);    case 157:
         O(yyval, OP_CREATE_SWPOOL); /* stack: empty write context */  #line 632 "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 152:  #line 633 "compile.y"
 #line 525 "compile.y"      { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;}
 {      break;
   
     case 159:
   #line 634 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;}
       break;
   
     case 160:
   #line 635 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;}
       break;
   
     case 161:
   #line 636 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;}
       break;
   
     case 162:
   #line 637 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;}
       break;
   
     case 163:
   #line 638 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;}
       break;
   
     case 164:
   #line 639 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;}
       break;
   
     case 165:
   #line 640 "compile.y"
       { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;}
       break;
   
     case 166:
   #line 643 "compile.y"
       {
           // optimized from OP_STRING->OP_VALUE for doubles
           maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
   ;}
       break;
   
     case 167:
   #line 648 "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 657 "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 153:  
 #line 530 "compile.y"    case 169:
 { yyval=VL(NEW VVoid(POOL)) ;  #line 662 "compile.y"
     break;}      { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0) ;}
 case 154:      break;
 #line 531 "compile.y"  
 { yyval=N(POOL) ;    case 170:
     break;}  #line 663 "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 664 "compile.y"
       { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0) ;}
       break;
   
     case 172:
   #line 666 "compile.y"
       { yyval=N() ;}
       break;
   
   
       }
   
   /* Line 1010 of yacc.c.  */
   #line 2260 "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 533 "compile.y"  
   
   #line 668 "compile.y"
   
 #endif  #endif
   
Line 1808  yyerrhandle: Line 2501  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.[co<[>de]
                                   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 1939  static int yylex(YYSTYPE *lvalp, void *p Line 2702  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 1958  static int yylex(YYSTYPE *lvalp, void *p Line 2721  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 1985  static int yylex(YYSTYPE *lvalp, void *p Line 2751  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 2022  static int yylex(YYSTYPE *lvalp, void *p Line 2777  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 2046  static int yylex(YYSTYPE *lvalp, void *p Line 2812  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;
                           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;                                  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 2102  static int yylex(YYSTYPE *lvalp, void *p Line 2902  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 2117  static int yylex(YYSTYPE *lvalp, void *p Line 2917  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 2131  static int yylex(YYSTYPE *lvalp, void *p Line 2947  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 2172  static int yylex(YYSTYPE *lvalp, void *p Line 3014  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 '(':
                                 PC.ls=LS_VAR_ROUND;                                  pc.ls=LS_VAR_ROUND;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '.': // name part delim                          case '.': // name part delim
                         case '$': // name part subvar                          case '$': // name part subvar
                         case ':': // ':name' or '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 '[':
                                   // ${name.<[>code]}
                                   push_LS(pc, LS_NAME_SQUARE_PART);
                                   lexical_brackets_nestage=1;
                                   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 2219  static int yylex(YYSTYPE *lvalp, void *p Line 3083  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 2241  static int yylex(YYSTYPE *lvalp, void *p Line 3105  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 2262  static int yylex(YYSTYPE *lvalp, void *p Line 3126  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 '(':
                                 PC.ls=LS_METHOD_ROUND;                                  pc.ls=LS_METHOD_ROUND;
                                 lexical_brackets_nestage=1;                                  lexical_brackets_nestage=1;
                                 RC;                                  RC;
                         case '.': // name part delim                           case '.': // name part delim 
                         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 2283  static int yylex(YYSTYPE *lvalp, void *p Line 3160  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 2305  static int yylex(YYSTYPE *lvalp, void *p Line 3182  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 2322  static int yylex(YYSTYPE *lvalp, void *p Line 3199  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 2359  break2: Line 3246  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.2  
changed lines
  Added in v.1.117

E-mail: