parser3/src/main/compile.tab.C - diff

Return to compile.tab.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.tab.C between versions 1.81.2.13.2.2 and 1.81.2.13.2.25

-version 1.81.2.13.2.2, 2003/03/19 12:22:36
+version 1.81.2.13.2.25, 2003/04/03 12:25:33
  Line 1
+ /* A Bison parser, made from compile.y, by GNU bison 1.75.  */
- /*  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 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.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
- #define EON     257
+    You should have received a copy of the GNU General Public License
- #define STRING  258
+    along with this program; if not, write to the Free Software
- #define BOGUS   259
+    Foundation, Inc., 59 Temple Place - Suite 330,
- #define BAD_STRING_COMPARISON_OPERATOR  260
+    Boston, MA 02111-1307, USA.  */
- #define BAD_HEX_LITERAL 261
- #define BAD_METHOD_DECL_START   262
- #define BAD_METHOD_PARAMETER_NAME_CHARACTER     263
- #define BAD_MATH_OPERATOR_CHARACTER     264
- #define LAND    265
- #define LOR     266
- #define LXOR    267
- #define NXOR    268
- #define NLE     269
- #define NGE     270
- #define NEQ     271
- #define NNE     272
- #define NSL     273
- #define NSR     274
- #define SLT     275
- #define SGT     276
- #define SLE     277
- #define SGE     278
- #define SEQ     279
- #define SNE     280
- #define DEF     281
- #define IN      282
- #define FEXISTS 283
- #define DEXISTS 284
- #define IS      285
- #define NUNARY  286
+ /* As a special exception, when this file is copied by Bison into a
+    Bison output file, you may use that output file without restriction.
+    This special exception was added by the Free Software Foundation
+    in version 1.24 of Bison.  */
+ /* Written by Richard Stallman by simplifying the original so called
+    ``semantic'' parser.  */
+ /* All symbols defined below should begin with yy or YY, to avoid
+    infringing on user name space.  This should be done even for local
+    variables, as they might otherwise be expanded by user macros.
+    There are some unavoidable exceptions within include files to
+    define necessary library symbols; they are noted "INFRINGES ON
+    USER NAME SPACE" below.  */
+ /* Identify Bison output.  */
+ #define YYBISON 1
+ /* Pure parsers.  */
+ #define YYPURE  1
+ /* Using locations.  */
+ #define YYLSP_NEEDED 0
+ /* Tokens.  */
+ #ifndef YYTOKENTYPE
+ # define YYTOKENTYPE
+    /* Put the tokens into the symbol table, so that GDB and other debuggers
+       know about them.  */
+    enum yytokentype {
+      EON = 258,
+      STRING = 259,
+      BOGUS = 260,
+      BAD_STRING_COMPARISON_OPERATOR = 261,
+      BAD_HEX_LITERAL = 262,
+      BAD_METHOD_DECL_START = 263,
+      BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
+      BAD_MATH_OPERATOR_CHARACTER = 265,
+      LAND = 266,
+      LOR = 267,
+      LXOR = 268,
+      NXOR = 269,
+      NLE = 270,
+      NGE = 271,
+      NEQ = 272,
+      NNE = 273,
+      NSL = 274,
+      NSR = 275,
+      SLT = 276,
+      SGT = 277,
+      SLE = 278,
+      SGE = 279,
+      SEQ = 280,
+      SNE = 281,
+      DEF = 282,
+      IN = 283,
+      FEXISTS = 284,
+      DEXISTS = 285,
+      IS = 286,
+      NUNARY = 287
+    };
+ #endif
+ #define EON 258
+ #define STRING 259
+ #define BOGUS 260
+ #define BAD_STRING_COMPARISON_OPERATOR 261
+ #define BAD_HEX_LITERAL 262
+ #define BAD_METHOD_DECL_START 263
+ #define BAD_METHOD_PARAMETER_NAME_CHARACTER 264
+ #define BAD_MATH_OPERATOR_CHARACTER 265
+ #define LAND 266
+ #define LOR 267
+ #define LXOR 268
+ #define NXOR 269
+ #define NLE 270
+ #define NGE 271
+ #define NEQ 272
+ #define NNE 273
+ #define NSL 274
+ #define NSR 275
+ #define SLT 276
+ #define SGT 277
+ #define SLE 278
+ #define SGE 279
+ #define SEQ 280
+ #define SNE 281
+ #define DEF 282
+ #define IN 283
+ #define FEXISTS 284
+ #define DEXISTS 285
+ #define IS 286
+ #define NUNARY 287
+ /* Copy the first part of user declarations.  */
  #line 1 "compile.y"
  /** @file
- Line 57
+ Line 139
                  -#:     in iis make up specialized Pool object for that
  */
- #define YYSTYPE  ArrayOperationPtr
+ #define YYSTYPE  ArrayOperation*
  #define YYPARSE_PARAM  pc
  #define YYLEX_PARAM  pc
  #define YYDEBUG  1
  #define YYERROR_VERBOSE 1
- #define yyerror(msg)  real_yyerror((parse_control *)pc, msg)
+ #define yyerror(msg)  real_yyerror((Parse_control *)pc, msg)
  #define YYPRINT(file, type, value)  yyprint(file, type, value)
+ // includes
  #include "compile_tools.h"
  #include "pa_value.h"
  #include "pa_request.h"
- Line 74
+ Line 158
  #include "pa_vvoid.h"
  #include "pa_vmethod_frame.h"
+ // defines
  #define USE_CONTROL_METHOD_NAME "USE"
+ #define TAB_SIZE 8
+ // 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);
  // local convinient inplace typecast & var
  #undef PC
- #define PC  (*(parse_control *)pc)
+ #define PC  (*(Parse_control *)pc)
  #undef POOL
  #define POOL  (*PC.pool)
  #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
+ /* Enabling verbose error messages.  */
+ #ifdef YYERROR_VERBOSE
+ # undef YYERROR_VERBOSE
+ # define YYERROR_VERBOSE 1
+ #else
+ # define YYERROR_VERBOSE 0
  #endif
+ #ifndef YYSTYPE
+ typedef int yystype;
+ # define YYSTYPE yystype
+ # define YYSTYPE_IS_TRIVIAL 1
+ #endif
+ #ifndef YYLTYPE
+ typedef struct yyltype
+ {
+   int first_line;
+   int first_column;
+   int last_line;
+   int last_column;
+ } yyltype;
+ # define YYLTYPE yyltype
+ # define YYLTYPE_IS_TRIVIAL 1
+ #endif
+ /* Copy the second part of user declarations.  */
+ /* Line 213 of /usr/local/share/bison/yacc.c.  */
+ #line 217 "compile.tab.C"
+ #if ! defined (yyoverflow) || YYERROR_VERBOSE
+ /* The parser invokes alloca or malloc; define the necessary symbols.  */
+ # if YYSTACK_USE_ALLOCA
+ #  define YYSTACK_ALLOC alloca
+ # else
+ #  ifndef YYSTACK_USE_ALLOCA
+ #   if defined (alloca) || defined (_ALLOCA_H)
+ #    define YYSTACK_ALLOC alloca
+ #   else
+ #    ifdef __GNUC__
+ #     define YYSTACK_ALLOC __builtin_alloca
+ #    endif
+ #   endif
+ #  endif
+ # endif
+ # ifdef YYSTACK_ALLOC
+    /* Pacify GCC's `empty if-body' warning. */
+ #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ # else
+ #  if defined (__STDC__) || defined (__cplusplus)
+ #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ #   define YYSIZE_T size_t
+ #  endif
+ #  define YYSTACK_ALLOC malloc
+ #  define YYSTACK_FREE free
+ # endif
+ #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+ #if (! defined (yyoverflow) \
+      && (! defined (__cplusplus) \
+          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+ /* A type that is properly aligned for any stack member.  */
+ union yyalloc
+ {
+   short yyss;
+   YYSTYPE yyvs;
+   };
+ /* The size of the maximum gap between one aligned stack and the next.  */
+ # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+ /* The size of an array large to enough to hold all stacks, each with
+    N elements.  */
+ # define YYSTACK_BYTES(N) \
+      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
+       + YYSTACK_GAP_MAX)
+ /* Copy COUNT objects from FROM to TO.  The source and destination do
+    not overlap.  */
+ # ifndef YYCOPY
+ #  if 1 < __GNUC__
+ #   define YYCOPY(To, From, Count) \
+       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+ #  else
+ #   define YYCOPY(To, From, Count)              \
+       do                                        \
+         {                                       \
+           register YYSIZE_T yyi;                \
+           for (yyi = 0; yyi < (Count); yyi++)   \
+             (To)[yyi] = (From)[yyi];    \
+         }                                       \
+       while (0)
+ #  endif
+ # endif
+ /* Relocate STACK from its old location to the new one.  The
+    local variables YYSIZE and YYSTACKSIZE give the old and new number of
+    elements in the stack, and YYPTR gives the new location of the
+    stack.  Advance YYPTR to a properly aligned location for the next
+    stack.  */
+ # define YYSTACK_RELOCATE(Stack)                                        \
+     do                                                                  \
+       {                                                                 \
+         YYSIZE_T yynewbytes;                                            \
+         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
+         Stack = &yyptr->Stack;                                          \
+         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
+         yyptr += yynewbytes / sizeof (*yyptr);                          \
+       }                                                                 \
+     while (0)
+ #endif
+ #if defined (__STDC__) || defined (__cplusplus)
+    typedef signed char yysigned_char;
+ #else
+    typedef short yysigned_char;
+ #endif
- #define YYFINAL         252
+ /* YYFINAL -- State number of the termination state. */
- #define YYFLAG          -32768
+ #define YYFINAL  51
- #define YYNTBASE        60
+ #define YYLAST   483
- #define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 139)
+ /* YYNTOKENS -- Number of terminals. */
+ #define YYNTOKENS  60
- static const char yytranslate[] = {     0,
+ /* YYNNTS -- Number of nonterminals. */
-,     2,     2,     2,     2,     2,     2,     2,     2,    46,
+ #define YYNNTS  80
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ /* YYNRULES -- Number of rules. */
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ #define YYNRULES  161
-,     2,    44,    58,     2,    50,    41,    35,    59,    54,
+ /* YYNRULES -- Number of states. */
-,    38,    36,     2,    37,    53,    39,     2,     2,     2,
+ #define YYNSTATES  252
-,     2,     2,     2,     2,     2,     2,    57,    49,    32,
-,    33,     2,    45,     2,     2,     2,     2,     2,     2,
+ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ #define YYUNDEFTOK  2
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ #define YYMAXUTOK   287
-,    40,    48,    56,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ #define YYTRANSLATE(X) \
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
-,     2,    51,    34,    52,    43,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ static const unsigned char yytranslate[] =
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+ {
 ,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 ,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 ,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,    44,    58,     2,    50,    41,    35,    59,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,    55,    38,    36,     2,    37,    53,    39,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,    57,    49,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,    33,     2,    45,     2,     2,     2,     2,     2,
 ,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 ,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     1,     3,     4,     5,     6,
+,    47,    40,    48,    56,     2,     2,     2,     2,     2,
-,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,    28,    29,    30,    31,    42
+,     2,     2,    51,    34,    52,    43,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    28,    29,    30,    31,    42
  };
- #if YYDEBUG != 0
+ #if YYDEBUG
- static const short yyprhs[] = {     0,
+ /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-,     2,     4,     6,     9,    11,    13,    15,    20,    22,
+    YYRHS.  */
-,    26,    29,    32,    34,    36,    44,    46,    48,    52,
+ static const unsigned short yyprhs[] =
-,    56,    58,    62,    64,    66,    68,    70,    72,    75,
+ {
-,    79,    81,    83,    85,    87,    90,    93,    95,    99,
+,     0,     3,     5,     7,     9,    12,    14,    16,    18,
-,   103,   105,   108,   110,   113,   117,   119,   121,   123,
+,    25,    27,    29,    32,    35,    37,    39,    47,    49,
-,   128,   131,   133,   135,   137,   141,   145,   149,   151,
+,    55,    57,    59,    61,    65,    67,    69,    71,    73,
-,   155,   157,   159,   161,   164,   166,   167,   168,   175,
+,    78,    80,    82,    84,    86,    88,    90,    93,    96,
-,   179,   182,   184,   186,   188,   192,   196,   200,   202,
+,   102,   104,   106,   108,   111,   113,   116,   120,   122,
-,   208,   212,   214,   218,   220,   222,   224,   226,   228,
+,   126,   128,   131,   134,   136,   138,   140,   144,   148,
-,   232,   234,   237,   239,   242,   245,   247,   249,   252,
+,   154,   156,   158,   160,   162,   164,   167,   169,   170,
-,   256,   258,   260,   263,   266,   270,   272,   274,   277,
+,   178,   180,   182,   185,   187,   189,   191,   195,   199,
-,   282,   284,   287,   290,   292,   294,   296,   298,   302,
+,   205,   209,   211,   215,   217,   221,   223,   225,   227,
-,   310,   313,   316,   319,   322,   325,   328,   331,   334,
+,   231,   233,   235,   237,   240,   242,   245,   248,   250,
-,   342,   346,   350,   354,   358,   362,   366,   370,   374,
+,   255,   257,   259,   261,   263,   266,   269,   273,   275,
-,   382,   386,   390,   394,   398,   402,   406,   410,   414,
+,   280,   283,   285,   287,   290,   293,   295,   297,   299,
-,   422,   426,   430,   434,   438,   442,   444,   446,   447
+,   305,   309,   313,   316,   319,   322,   325,   328,   331,
+,   337,   341,   345,   349,   353,   357,   361,   365,   369,
+,   377,   381,   385,   389,   393,   397,   401,   405,   409,
+,   417,   421,   425,   429,   433,   437,   441,   445,   447,
+,   450
  };
- static const short yyrhs[] = {    62,
+ /* YYRHS -- A `-1'-separated list of the rules' RHS. */
-,    61,     0,    63,     0,    61,    63,     0,    75,     0,
+ static const short yyrhs[] =
-,     0,    69,     0,    45,     4,    46,    65,     0,   138,
+ {
-,    66,     0,    67,     0,    66,    67,     0,    68,    46,
+,     0,    -1,    63,    -1,    62,    -1,    64,    -1,    62,
-,   138,     0,     4,     0,    45,     4,    71,    70,    74,
+,    -1,    76,    -1,    65,    -1,    70,    -1,    45,     4,
-,    75,     0,   138,     0,    71,     0,    47,    72,    48,
+,    66,    -1,   139,    -1,    67,    -1,    68,    -1,    67,
-,   138,     0,    73,     0,     4,     0,    73,    49,     4,
+,    -1,    69,    46,    -1,   139,    -1,     4,    -1,    45,
-,   138,     0,     4,     0,   138,     0,    76,     0,    77,
+,    72,    71,    75,    46,    76,    -1,   139,    -1,    72,
-,    76,    77,     0,   136,     0,    78,     0,    79,     0,
+       -1,    47,    73,    48,    -1,   139,    -1,    74,    -1,     4,
-,     0,   100,     0,    80,     0,    50,    81,     0,    83,
+       -1,    74,    49,     4,    -1,   139,    -1,     4,    -1,   139,
-,     0,    82,     0,    51,    83,    52,     0,    84,     0,
+       -1,    77,    -1,    78,    -1,    77,    78,    -1,   137,    -1,
-,     0,    86,     0,   130,    86,     0,   122,     0,   119,
+,    -1,    80,    -1,    88,    -1,   101,    -1,    81,    -1,
-,     0,    50,    88,    92,     0,    89,     0,    90,     0,
+,    82,    -1,    84,     3,    -1,    83,    -1,    51,    84,
-,     0,   118,     0,    53,   118,     0,   130,   118,     0,
+,    -1,    85,    -1,    86,    -1,    87,    -1,   131,    87,
-,     0,    94,     0,    95,     0,    47,    96,    48,     0,
+       -1,   123,    -1,   120,   123,    -1,    50,    89,    93,    -1,
-,   133,    55,     0,    51,    75,    52,     0,   137,     0,
+,    -1,    91,    -1,    92,    -1,   119,    -1,    53,   119,
-,     0,    97,     0,    98,     0,    99,     0,    78,     0,
+       -1,   131,   119,    -1,    94,    -1,    95,    -1,    96,    -1,
-,    76,     0,   101,     0,     0,     0,    56,   102,   104,
+,    97,    48,    -1,    54,   134,    55,    -1,    51,    76,
-,   105,     3,     0,    83,     0,   106,     0,   105,   106,
+,    -1,   138,    -1,     4,    -1,    98,    -1,    99,    -1,
-,   107,     0,   108,     0,   109,     0,    47,   110,    48,
+,    -1,    79,    -1,    78,    77,    -1,   102,    -1,    -1,
-,    54,   111,    55,     0,    51,   112,    52,     0,   113,
+       -1,    56,   103,   105,   104,   106,     3,    -1,    84,    -1,
-,   110,    49,   113,     0,   114,     0,   111,    49,   114,
+,    -1,   106,   107,    -1,   108,    -1,   109,    -1,   110,
-,   115,     0,   112,    49,   115,     0,   116,     0,   117,
+       -1,    47,   111,    48,    -1,    54,   112,    55,    -1,    51,
-,    75,     0,   137,     0,     4,     0,    97,     0,   133,
+,    52,    -1,   114,    -1,   111,    49,   114,    -1,   115,
-,   123,     0,   119,   123,     0,   120,     0,   119,   120,
+       -1,   112,    49,   115,    -1,   116,    -1,   113,    49,   116,
-,   121,    53,     0,   123,     0,   123,     0,     4,     5,
+       -1,   117,    -1,   118,    -1,    76,    -1,   138,    -1,     4,
-,     4,     0,   124,     0,   125,     0,   126,     0,    50,
+       -1,    98,    -1,   134,    -1,   124,    -1,   120,   124,    -1,
-,     0,     4,   128,     0,    47,    76,    48,     0,     4,
+,    -1,   120,   121,    -1,   122,    53,    -1,   124,    -1,
-,   129,     0,   128,   129,     0,    50,   127,     0,   131,
+,    -1,     4,     5,    -1,     4,    -1,   125,    -1,   126,
-,   132,     0,     4,    57,     0,   131,    57,     0,   134,
+       -1,   127,    -1,    50,   128,    -1,     4,   129,    -1,    47,
-,     4,     0,    80,     0,   101,     0,    58,   135,    58,
+,    48,    -1,     4,    -1,   130,    -1,   129,   130,    -1,
-,    59,   135,    59,     0,    54,   134,    55,     0,    37,
+,   128,    -1,   132,    -1,   133,    -1,     4,    57,    -1,
-,     0,    36,   134,     0,    43,   134,     0,    44,   134,
+,    57,    -1,   135,    -1,     4,    -1,    81,    -1,   102,
-,    27,   134,     0,    28,   134,     0,    29,   134,     0,
+       -1,    58,   136,    58,    -1,    59,   136,    59,    -1,    54,
-,   134,     0,   134,    37,   134,     0,   134,    36,   134,
+,    55,    -1,    37,   135,    -1,    36,   135,    -1,    43,
-,   134,    38,   134,     0,   134,    39,   134,     0,   134,
+,    -1,    44,   135,    -1,    27,   135,    -1,    28,   135,
-,   134,     0,   134,    40,   134,     0,   134,    19,   134,
+       -1,    29,   135,    -1,    30,   135,    -1,   135,    37,   135,
-,   134,    20,   134,     0,   134,    35,   134,     0,   134,
+       -1,   135,    36,   135,    -1,   135,    38,   135,    -1,   135,
-,   134,     0,   134,    14,   134,     0,   134,    11,   134,
+,   135,    -1,   135,    41,   135,    -1,   135,    40,   135,
-,   134,    12,   134,     0,   134,    13,   134,     0,   134,
+       -1,   135,    19,   135,    -1,   135,    20,   135,    -1,   135,
-,   134,     0,   134,    33,   134,     0,   134,    15,   134,
+,   135,    -1,   135,    34,   135,    -1,   135,    14,   135,
-,   134,    16,   134,     0,   134,    17,   134,     0,   134,
+       -1,   135,    11,   135,    -1,   135,    12,   135,    -1,   135,
-,   134,     0,   134,    21,   134,     0,   134,    22,   134,
+,   135,    -1,   135,    32,   135,    -1,   135,    33,   135,
-,   134,    23,   134,     0,   134,    24,   134,     0,   134,
+       -1,   135,    15,   135,    -1,   135,    16,   135,    -1,   135,
-,   134,     0,   134,    26,   134,     0,   134,    31,   134,
+,   135,    -1,   135,    18,   135,    -1,   135,    21,   135,
-,    75,     0,     4,     0,     0,     0
+       -1,   135,    22,   135,    -1,   135,    23,   135,    -1,   135,
+,   135,    -1,   135,    25,   135,    -1,   135,    26,   135,
+       -1,   135,    31,   135,    -1,    76,    -1,     4,    -1,    -1,
+       -1
  };
- #endif
+ /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+ static const unsigned short yyrline[] =
- #if YYDEBUG != 0
+ {
- static const short yyrline[] = { 0,
+,   122,   122,   130,   132,   132,   133,   135,   135,   137,
-,   123,   125,   125,   126,   128,   128,   130,   202,   202,
+,   209,   210,   210,   211,   212,   212,   214,   243,   243,
-,   203,   204,   205,   205,   207,   236,   236,   237,   238,
+,   245,   245,   246,   246,   248,   248,   252,   252,   254,
-,   239,   239,   241,   241,   245,   245,   247,   247,   248,
+,   255,   255,   256,   256,   256,   260,   267,   268,   268,
-,   249,   249,   249,   253,   260,   261,   261,   262,   263,
+,   270,   272,   273,   295,   296,   296,   300,   304,   306,
-,   266,   288,   289,   289,   293,   297,   299,   300,   301,
+,   308,   325,   330,   332,   334,   335,   337,   343,   351,
-,   323,   325,   327,   328,   330,   336,   344,   350,   352,
+,   359,   360,   362,   368,   369,   369,   373,   379,   382,
-,   355,   361,   362,   362,   366,   372,   375,   378,   391,
+,   398,   400,   400,   401,   403,   404,   406,   407,   408,
-,   393,   394,   396,   397,   399,   400,   401,   402,   404,
+,   411,   413,   415,   417,   419,   421,   425,   429,   433,
-,   408,   410,   412,   414,   418,   422,   426,   428,   429,
+,   436,   438,   447,   447,   449,   449,   450,   451,   459,
-,   440,   440,   442,   442,   443,   444,   452,   457,   459,
+,   466,   468,   469,   470,   472,   476,   485,   491,   496,
-,   462,   463,   465,   469,   478,   484,   489,   489,   490,
+,   497,   502,   504,   506,   518,   530,   535,   537,   538,
-,   497,   499,   511,   523,   528,   530,   531,   532,   533,
+,   540,   541,   543,   544,   545,   546,   547,   548,   549,
-,   536,   537,   538,   539,   540,   541,   542,   543,   545,
+,   552,   553,   554,   555,   556,   557,   558,   559,   560,
-,   547,   548,   549,   550,   551,   552,   553,   554,   555,
+,   562,   563,   564,   565,   566,   567,   568,   569,   570,
-,   557,   558,   559,   560,   561,   562,   563,   564,   565,
+,   572,   573,   574,   575,   576,   577,   578,   581,   590,
-,   567,   568,   569,   570,   571,   574,   583,   588,   589
+,   596
  };
  #endif
+ #if YYDEBUG || YYERROR_VERBOSE
- #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+ /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
- static const char * const yytname[] = {   "$","error","$undefined.","EON","STRING",
+ static const char *const yytname[] =
- "BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START",
+ {
- "BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_MATH_OPERATOR_CHARACTER","\"&&\"",
+   "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
- "\"||\"","\"!||\"","\"!|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"<<\"","\">>\"",
+   "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
- "\"lt\"","\"gt\"","\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"",
+   "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
- "\"-d\"","\"is\"","'<'","'>'","'|'","'&'","'+'","'-'","'*'","'/'","'\\\\'","'%'",
+   "BAD_MATH_OPERATOR_CHARACTER", "\"&&\"", "\"||\"", "\"!||\"", "\"!|\"",
- "NUNARY","'~'","'!'","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'",
+   "\"<=\"", "\">=\"", "\"==\"", "\"!=\"", "\"<<\"", "\">>\"", "\"lt\"",
- "'('","')'","'^'","':'","'\\\"'","'\\''","all","methods","one_big_piece","method",
+   "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"", "\"ne\"", "\"def\"", "\"in\"",
- "control_method","maybe_control_strings","control_strings","control_string",
+   "\"-f\"", "\"-d\"", "\"is\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'",
- "maybe_string","code_method","maybe_bracketed_strings","bracketed_maybe_strings",
+   "'*'", "'/'", "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'",
- "maybe_strings","strings","maybe_comment","maybe_codes","codes","code","action",
+   "'['", "']'", "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'",
- "get","get_value","get_name_value","name_in_curly_rdive","name_without_curly_rdive",
+   "':'", "'\"'", "'''", "$accept", "all", "methods", "one_big_piece",
- "name_without_curly_rdive_read","name_without_curly_rdive_class","name_without_curly_rdive_code",
+   "method", "control_method", "maybe_control_strings", "control_strings",
- "put","name_expr_wdive","name_expr_wdive_root","name_expr_wdive_write","name_expr_wdive_class",
+   "control_string", "maybe_string", "code_method",
- "construct","construct_square","construct_round","construct_curly","any_constructor_code_value",
+   "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
- "constructor_code_value","constructor_code","codes__excluding_sole_str_literal",
+   "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
- "call","call_value","@1","@2","call_name","store_params","store_param","store_square_param",
+   "get", "get_value", "get_name_value", "name_in_curly_rdive",
- "store_round_param","store_curly_param","store_code_param_parts","store_expr_param_parts",
+   "name_without_curly_rdive", "name_without_curly_rdive_read",
- "store_curly_param_parts","store_code_param_part","store_expr_param_part","store_curly_param_part",
+   "name_without_curly_rdive_class", "name_without_curly_rdive_code",
- "code_param_value","write_expr_value","name_expr_dive_code","name_path","name_step",
+   "put", "name_expr_wdive", "name_expr_wdive_root",
- "name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",
+   "name_expr_wdive_write", "name_expr_wdive_class", "construct",
- "name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",
+   "construct_square", "construct_round", "construct_curly",
- "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",
+   "any_constructor_code_value", "constructor_code_value",
- "expr","string_inside_quotes_value","write_string","void_value","empty", NULL
+   "constructor_code", "codes__excluding_sole_str_literal", "call",
+   "call_value", "@1", "@2", "call_name", "store_params", "store_param",
+   "store_square_param", "store_round_param", "store_curly_param",
+   "store_code_param_parts", "store_expr_param_parts",
+   "store_curly_param_parts", "store_code_param_part",
+   "store_expr_param_part", "store_curly_param_part", "code_param_value",
+   "write_expr_value", "name_expr_dive_code", "name_path", "name_step",
+   "name_advance1", "name_advance2", "name_expr_value",
+   "name_expr_subvar_value", "name_expr_with_subvar_value",
+   "name_square_code_value", "subvar_ref_name_rdive", "subvar_get_writes",
+   "subvar__get_write", "class_prefix", "class_static_prefix",
+   "class_constructor_prefix", "expr_value", "expr",
+   "string_inside_quotes_value", "write_string", "void_value", "empty", 0
  };
  #endif
- static const short yyr1[] = {     0,
+ # ifdef YYPRINT
-,    60,    61,    61,    62,    63,    63,    64,    65,    65,
+ /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-,    66,    67,    68,    68,    69,    70,    70,    71,    72,
+    token YYLEX-NUM.  */
-,    73,    73,    74,    74,    75,    75,    76,    76,    77,
+ static const unsigned short yytoknum[] =
-,    78,    78,    78,    79,    80,    81,    81,    82,    83,
+ {
-,    84,    85,    86,    86,    87,    88,    88,    88,    89,
+,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-,    91,    92,    92,    92,    93,    94,    95,    96,    96,
+,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-,    97,    98,    99,    99,   100,   102,   103,   101,   104,
+,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-,   105,   106,   106,   106,   107,   108,   109,   110,   110,
+,   286,    60,    62,   124,    38,    43,    45,    42,    47,
-,   111,   112,   112,   113,   114,   115,   116,   116,   116,
+,    37,   287,   126,    33,    64,    10,    91,    93,    59,
-,   118,   118,   119,   119,   120,   121,   122,   122,   123,
+,   123,   125,    46,    40,    41,    94,    58,    34,    39
-,   123,   123,   124,   125,   126,   127,   128,   128,   129,
-,   130,   131,   132,   133,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   135,   136,   137,   138
  };
+ # endif
- static const short yyr2[] = {     0,
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-,     1,     1,     2,     1,     1,     1,     4,     1,     1,
+ static const unsigned char yyr1[] =
-,     2,     2,     1,     1,     7,     1,     1,     3,     1,
+ {
-,     1,     3,     1,     1,     1,     1,     1,     2,     1,
+,    60,    61,    61,    62,    62,    63,    64,    64,    65,
-,     1,     1,     1,     1,     2,     2,     1,     3,     1,
+,    66,    67,    67,    68,    69,    69,    70,    71,    71,
-,     1,     2,     1,     2,     3,     1,     1,     1,     1,
+,    73,    73,    74,    74,    75,    75,    76,    76,    77,
-,     2,     1,     1,     1,     3,     3,     3,     1,     1,
+,    78,    78,    79,    79,    79,    80,    81,    82,    82,
-,     1,     1,     1,     2,     1,     0,     0,     6,     1,
+,    84,    84,    85,    86,    87,    87,    88,    89,    89,
-,     2,     1,     1,     1,     3,     3,     3,     1,     3,
+,    90,    91,    92,    93,    93,    93,    94,    95,    96,
-,     3,     1,     3,     1,     1,     1,     1,     1,     1,
+,    97,    97,    98,    99,   100,   100,   101,   103,   104,
-,     1,     2,     1,     2,     2,     1,     1,     2,     1,
+,   105,   106,   106,   107,   107,   107,   108,   109,   110,
-,     1,     1,     2,     2,     3,     1,     1,     2,     2,
+,   111,   112,   112,   113,   113,   114,   115,   116,   117,
-,     1,     2,     2,     1,     1,     1,     1,     3,     3,
+,   117,   118,   119,   119,   120,   120,   121,   122,   123,
-,     2,     2,     2,     2,     2,     2,     2,     2,     3,
+,   124,   124,   124,   124,   125,   126,   127,   128,   129,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   130,   131,   131,   132,   133,   134,   135,   135,   135,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   135,   135,   135,   135,   135,   135,   135,   135,   135,
-,     3,     3,     3,     3,     3,     1,     1,     0,     0
+,   135,   135,   135,   135,   135,   135,   135,   135,   135,
+,   135,   135,   135,   135,   135,   135,   135,   135,   135,
+,   135,   135,   135,   135,   135,   135,   135,   136,   137,
+,   139
  };
- static const short yydefact[] = {   160,
+ /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-,     0,     0,    67,     2,     1,     3,     6,     7,     5,
+ static const unsigned char yyr2[] =
-,    28,    31,    32,    35,    33,    34,    66,    30,    26,
+ {
-,   100,     0,     0,     0,     0,    36,    38,     0,    40,
+,     2,     1,     1,     1,     2,     1,     1,     1,     4,
-,    42,     0,    47,    48,    49,    50,     0,    94,     0,
+,     1,     1,     2,     2,     1,     1,     7,     1,     1,
-,    92,   101,   102,   103,     0,   111,   112,     0,     4,
+,     1,     1,     1,     3,     1,     1,     1,     1,     1,
-,   160,   160,   160,    99,     0,   113,   105,   108,     0,
+,     1,     1,     1,     1,     1,     1,     2,     2,     1,
-,   104,     0,     0,    98,     0,   100,    51,     0,    92,
+,     1,     1,     1,     2,     1,     2,     3,     1,     1,
-,   159,   160,     0,    46,    53,    54,    55,   100,    95,
+,     1,     2,     2,     1,     1,     1,     3,     3,     3,
-,    93,    96,    43,    52,   114,    70,    68,    15,     8,
+,     1,     1,     1,     1,     1,     2,     1,     0,     0,
-,    11,     0,     9,    22,     0,    21,    20,   160,    18,
+,     1,     1,     2,     1,     1,     1,     3,     3,     3,
-,   110,   109,   106,    39,    93,   158,     0,    31,     0,
+,     3,     1,     3,     1,     3,     1,     1,     1,     1,
-,    62,    63,    59,     0,   116,     0,     0,     0,     0,
+,     1,     1,     1,     2,     1,     2,     2,     1,     1,
-,     0,     0,     0,     0,     0,   160,   160,   117,   118,
+,     1,     1,     1,     1,     2,     2,     3,     1,     1,
-,   115,     0,    12,    14,    13,    19,     0,    25,     0,
+,     2,     1,     1,     2,     2,     1,     1,     1,     1,
-,    65,    56,    58,   126,   127,   128,   129,   123,   122,
+,     3,     3,     2,     2,     2,     2,     2,     2,     2,
-,   125,     0,   157,     0,     0,    57,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     1,     1,
-,     0,     0,     0,   159,   160,     0,     0,    71,    73,
+,     0
-,    75,    23,   160,   121,   119,   120,   141,   142,   143,
-,   146,   147,   148,   149,   136,   137,   150,   151,   152,
-,   154,   155,   156,   144,   145,   139,   138,   131,   130,
-,   133,   135,   134,   158,    90,     0,    79,    85,    88,
-,     0,    83,     0,    81,    86,    91,    69,    72,    16,
-,   159,   160,    78,     0,    77,    80,    84,    82,     0,
-,     0
  };
- static const short yydefgoto[] = {   250,
+ /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-,     6,     7,     8,    90,    91,    92,    93,     9,    99,
+    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-,    96,    97,   140,   154,    11,    12,    13,    14,   129,
+    means the default is an error.  */
-,    28,    29,    30,    31,    32,    16,    33,    34,    35,
+ static const unsigned char yydefact[] =
-,    75,    76,    77,    78,   110,   226,   112,   113,    17,
+ {
-,    49,   133,    88,   188,   189,   190,   191,   192,   227,
+,   159,     0,     0,    68,     0,     3,     2,     4,     7,
-,   232,   228,   235,   233,   229,   236,    37,    64,    39,
+,     6,    28,    29,    32,    33,    36,    34,    35,    67,
-,    41,    65,    43,    44,    45,    62,    58,    59,    66,
+,    27,     0,   101,     0,     0,     0,     0,    37,    39,
-,    48,   237,   132,   155,    19,   230,    20
+,    41,    42,    43,     0,    48,    49,    50,    51,     0,
+,     0,    45,    93,   102,   103,   104,     0,   112,   113,
+,     1,     5,    30,   161,   161,   161,   100,     0,   114,
+,   109,     0,   108,   105,     0,     0,    99,     0,   101,
+,     0,    93,    38,   160,   161,     0,    47,    54,    55,
+,   101,    96,    46,    94,    97,    44,    53,   115,    71,
+,    16,     9,    11,    12,     0,    10,    23,     0,    22,
+,   161,    19,    18,   111,   110,   107,    40,    94,   159,
+,    32,     0,    62,    63,    64,    60,     0,   117,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,   161,
+,   118,   119,     0,   116,     0,    13,    15,    14,    20,
+,    26,     0,    25,    66,    57,    59,   127,   128,   129,
+,   124,   123,   125,   126,     0,   158,     0,     0,    58,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,   160,   161,     0,
+,    72,    74,    75,    76,    24,   161,   122,   120,   121,
+,   143,   144,   141,   147,   148,   149,   150,   137,   138,
+,   152,   153,   154,   155,   156,   157,   145,   146,   140,
+,   132,   131,   133,   134,   136,   135,   159,    91,     0,
+,    86,    89,    88,     0,    84,     0,    82,    87,    92,
+,    73,    17,    77,   160,   161,    79,     0,    78,    81,
+,    83
  };
- static const short yypact[] = {    13,
+ /* YYDEFGOTO[NTERM-NUM]. */
- -32768,    24,    98,-32768,    36,-32768,-32768,-32768,-32768,-32768,
+ static const short yydefgoto[] =
-,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ {
-    -26,    39,    14,    44,    45,   100,-32768,-32768,    47,-32768,
+       -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
- -32768,-32768,    52,-32768,-32768,-32768,-32768,   118,-32768,    59,
+,   101,    56,    98,    99,   142,   156,    12,    13,    14,
- -32768,     4,-32768,-32768,-32768,   118,    -3,-32768,    45,-32768,
+,   131,    28,    29,    30,    31,    32,    33,    17,    34,
- -32768,   101,   113,    71,-32768,    44,-32768,    70,-32768,    32,
+,    36,    37,    77,    78,    79,    80,   112,   228,   114,
- -32768,-32768,    73,   118,    83,   118,    70,-32768,   100,    83,
+,    18,   132,    50,   135,    90,   190,   191,   192,   193,
- -32768,    27,    14,    57,-32768,-32768,-32768,-32768,     1,-32768,
+,   229,   236,   234,   230,   237,   235,   231,   238,    38,
- -32768,     4,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+,    40,    41,    42,    67,    44,    45,    46,    64,    60,
-,-32768,    78,    91,-32768,    90,    94,-32768,   135,-32768,
+,    68,    48,    49,   239,   134,   157,    20,   232,    21
- -32768,-32768,-32768,-32768,-32768,    83,    92,    14,   -22,   106,
- -32768,-32768,-32768,-32768,   115,-32768,    57,    57,    57,    57,
-,    57,    57,    57,   105,    57,    14,    14,-32768,-32768,
-,   281,    72,-32768,-32768,-32768,-32768,   142,-32768,   107,
- -32768,    14,-32768,-32768,   440,   440,   440,   440,-32768,-32768,
- -32768,-32768,   236,-32768,   112,   120,-32768,    57,    57,    57,
-,    57,    57,    57,    57,    57,    57,    57,    57,    57,
-,    57,    57,    57,    57,    57,    57,    57,    57,    57,
-,    57,    57,    57,    41,    14,    57,     5,-32768,-32768,
- -32768,-32768,-32768,    14,-32768,-32768,-32768,   371,   343,   312,
-,   399,   399,   412,   412,   136,   136,   399,   399,   399,
-,   412,   412,   440,   399,   399,   447,   453,    93,    93,
- -32768,-32768,-32768,-32768,   -11,-32768,    19,-32768,-32768,-32768,
- -32768,   -10,-32768,   -33,-32768,-32768,-32768,-32768,-32768,-32768,
- -32768,    41,    14,-32768,    57,-32768,-32768,-32768,-32768,   180,
-,-32768
  };
- static const short yypgoto[] = {-32768,
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- -32768,-32768,   177,-32768,-32768,-32768,    99,-32768,-32768,-32768,
+    STATE-NUM.  */
-,-32768,-32768,-32768,     3,   -18,    -7,   -71,-32768,     0,
+ #define YYPACT_NINF -71
- -32768,-32768,    -6,-32768,-32768,   -37,-32768,-32768,-32768,-32768,
+ static const short yypact[] =
- -32768,-32768,-32768,-32768,-32768,-32768,   119,-32768,-32768,-32768,
+ {
-,-32768,-32768,-32768,-32768,    -4,-32768,-32768,-32768,-32768,
+,   -71,    11,    98,   -71,    27,     5,   -71,   -71,   -71,
- -32768,-32768,   -50,   -52,   -48,-32768,-32768,   -16,    95,   -23,
+      -71,   -71,    16,   -71,   -71,   -71,   -71,   -71,   -71,   -71,
- -32768,   -24,     9,-32768,-32768,-32768,   169,-32768,   168,   224,
+      -71,   -71,   -15,    23,    16,    41,     6,    21,   -71,   -71,
- -32768,-32768,   154,    40,   102,-32768,   157,   -20
+,   -71,   -71,   -71,    71,   -71,   -71,   -71,   -71,    48,
+      -71,    53,   -71,    14,   -71,   -71,   -71,    48,    66,   -71,
+,   -71,   -71,   -71,   117,   122,    96,   -71,    41,   -71,
+,   -71,     9,   -71,   -71,   106,    48,   114,    48,    97,
+      -71,    21,   114,   -71,    32,    16,    57,   -71,   -71,   -71,
+      -71,    64,   -71,   -71,    14,   -71,   -71,   -71,   -71,   -71,
+      -71,   -71,   -71,    12,   -71,   123,   126,   -71,   125,   121,
+      -71,   173,   -71,   -71,   -71,   -71,   -71,   -71,   114,   135,
+,    -9,   136,   -71,   -71,   -71,   -71,   133,   -71,    57,
+,    57,    57,    57,    57,    57,    57,    77,    57,    16,
+,   -71,   -71,   131,   283,   124,   -71,   -71,   -71,   -71,
+,   -71,   147,   -71,    16,   -71,   -71,   442,   442,   442,
+,   -71,   -71,   -71,   -71,   238,   -71,   137,   138,   -71,
+,    57,    57,    57,    57,    57,    57,    57,    57,    57,
+,    57,    57,    57,    57,    57,    57,    57,    57,    57,
+,    57,    57,    57,    57,    57,    57,    33,    16,    57,
+,   -71,   -71,   -71,   -71,   -71,    16,   -71,   -71,   -71,
+,   345,   314,   100,   401,   401,   414,   414,   116,   116,
+,   401,   401,   401,   414,   414,   442,   401,   401,   246,
+,   141,   141,   -71,   -71,   -71,   -71,    -5,   -71,    60,
+      -71,   -71,   -71,   -71,   -30,   -71,   -26,   -71,   -71,   -71,
+      -71,   -71,   -71,   -71,    33,    16,   -71,    57,   -71,   -71,
+      -71,   -71
  };
+ /* YYPGOTO[NTERM-NUM].  */
- #define YYLAST          494
+ static const short yypgoto[] =
+ {
+      -71,   -71,   -71,   -71,   221,   -71,   -71,   -71,   101,   -71,
- static const short yytable[] = {    15,
+      -71,   -71,   172,   -71,   -71,   -71,     3,   -19,   -11,   -70,
-,    18,    10,    51,    60,    55,   -98,   238,    84,    68,
+      -71,     0,   -71,   -71,    -8,   -71,   -71,   -38,   -71,   -71,
-,    42,    18,    81,    80,   245,     1,     1,    63,    52,
+      -71,   -71,   -71,   -71,   -71,   -71,   -71,   -71,   155,   -71,
-,   246,    15,    89,    18,   -64,   -64,    21,    84,    85,
+      -71,   -71,     2,   -71,   -71,   -71,   -71,    42,   -71,   -71,
-,    94,    98,   101,    70,     1,   -89,   -89,   243,    81,
+      -71,   -71,   -71,   -71,   -14,   -16,   -10,   -71,   -71,    -6,
-,   244,    87,    55,   225,    80,    82,    61,    22,    71,
+,   -33,   -71,   -32,     8,   -71,   -71,   -71,   176,   -71,
-,   185,    51,    86,    42,   186,   -97,     2,   187,    15,
+,   233,   -71,   -71,   162,    40,   109,   -71,   166,    49
-,    18,     3,     3,   108,  -160,   241,   242,     4,     4,
-,    15,    15,    18,    18,   115,     3,   106,   141,   104,
-,     3,     4,   117,   118,   119,   120,     4,    56,   142,
-,    23,   121,   122,    24,    57,     4,    38,    72,   123,
-,    22,    73,    67,    89,    74,   125,    15,    22,    18,
-,    83,     4,   109,   127,   128,    95,    53,   185,    56,
-,    79,   186,   136,   105,   187,    15,    15,    18,    18,
-,   182,   183,   184,    51,   -97,   -14,   137,   139,   -60,
-,    15,   138,    18,    23,   193,    23,    24,    25,    24,
-,    23,   194,   143,    24,    25,   145,   146,   147,   148,
-,   150,   151,   152,    23,   153,   144,    24,   157,   196,
-,   179,   180,   181,   182,   183,   184,   108,   197,   251,
-,    50,   100,   239,    15,    15,    18,    18,   231,   134,
-,   247,   249,    15,   248,    18,   240,   198,   199,   200,
-,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-,   222,   223,   224,   102,   103,    46,   131,   114,   156,
-,     0,     0,     0,   108,     0,     0,     0,     0,     0,
-,    15,    15,    18,    18,   231,   158,   159,   160,   161,
-,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-,   173,   166,   167,     0,     0,   174,   175,   176,   177,
-,   179,   180,   181,   182,   183,   184,   177,   178,   179,
-,   181,   182,   183,   184,     0,     0,     0,     0,     0,
-,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-,   168,   169,   170,   171,   172,   173,     0,     0,     0,
-,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-,   184,   158,   159,     0,   161,   162,   163,   164,   165,
-,   167,   168,   169,   170,   171,   172,   173,     0,     0,
-,     0,   174,   175,   176,   177,   178,   179,   180,   181,
-,   183,   184,   158,     0,     0,   161,   162,   163,   164,
-,   166,   167,   168,   169,   170,   171,   172,   173,     0,
-,     0,     0,   174,   175,   176,   177,   178,   179,   180,
-,   182,   183,   184,   161,   162,   163,   164,   165,   166,
-,   168,   169,   170,   171,   172,   173,     0,     0,     0,
-,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-,   184,   161,     0,     0,   164,   165,   166,   167,     0,
-,     0,     0,   172,   173,   161,     0,     0,     0,   174,
-,   167,   177,   178,   179,   180,   181,   182,   183,   184,
-,     0,   174,     0,     0,   177,   178,   179,   180,   181,
-,   183,   184,   161,     0,     0,     0,     0,   166,   167,
-,     0,     0,     0,     0,   166,   167,     0,     0,     0,
-,   166,   167,   177,   178,   179,   180,   181,   182,   183,
-,   178,   179,   180,   181,   182,   183,   184,   179,   180,
-,   182,   183,   184
  };
- static const short yycheck[] = {     0,
+ /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-,     0,     0,    11,    23,     5,     3,     3,    46,    26,
+    positive, shift that token.  If negative, reduce the rule which
-,     3,    11,    38,    38,    49,     4,     4,    25,    46,
+    number is the opposite.  If zero, do what YYDEFACT says.
-,    55,    23,     4,    23,    48,    49,     4,    66,    46,
+    If YYTABLE_NINF, parse error.  */
-,    52,    53,    54,    26,     4,    48,    49,    49,    64,
+ #define YYTABLE_NINF -162
-,    52,    49,     5,     4,    69,    38,     4,     4,     3,
+ static const short yytable[] =
-,    47,    60,    57,    46,    51,    53,    45,    54,    60,
+ {
-,    60,    50,    50,    72,    46,    48,    49,    56,    56,
+,    53,    19,    11,   111,    62,    82,    83,     1,    86,
-,    72,    73,    72,    73,    73,    50,    69,    99,    48,
+,    43,    16,     1,    19,    22,    91,   -99,    65,   245,
-,    50,    56,    27,    28,    29,    30,    56,    50,   108,
+,    70,   246,   247,    16,    69,    19,    51,    57,   248,
-,    47,    36,    37,    50,    57,    56,     3,    47,    43,
+,    54,    55,    82,    83,    72,   109,   227,    82,   -65,
-,     4,    51,     4,     4,    54,    50,   108,     4,   108,
+      -65,    87,    89,   -90,   -90,    63,    39,    84,   240,     2,
-,    53,    56,   185,    58,    59,     4,    47,    47,    50,
+,    53,    81,    24,     3,    43,    25,   106,  -161,     3,
-,     4,    51,    46,    52,    54,   127,   128,   127,   128,
+,   118,    16,   110,    19,     4,     3,   -98,    24,    57,
-,    39,    40,    41,   142,    53,    46,    48,     4,    48,
+,    25,     4,    58,    16,    16,    19,    19,   117,   108,
-,   142,    49,   142,    47,     4,    47,    50,    51,    50,
+,    23,     3,     3,   119,   120,   121,   122,     4,     4,
-,    47,    46,    48,    50,    51,   117,   118,   119,   120,
+,   144,   187,   123,   124,    24,   188,    73,    25,   189,
-,   122,   123,   124,    47,   126,    52,    50,    55,    58,
+,   126,    23,    96,   100,   103,    85,   127,   243,   244,
-,    36,    37,    38,    39,    40,    41,   185,    59,     0,
+,   128,    19,     4,    58,   129,   130,   111,    74,   168,
-,     5,    54,   188,   185,   186,   185,   186,   186,    91,
+,    91,    75,    88,    24,    76,    97,    25,    26,    16,
-,   242,   245,   194,   243,   194,   194,   158,   159,   160,
+,    19,    19,    53,   179,   180,   181,   182,   183,   184,
-,   162,   163,   164,   165,   166,   167,   168,   169,   170,
+,   186,   137,    55,    16,    24,    19,    58,    25,    26,
-,   172,   173,   174,   175,   176,   177,   178,   179,   180,
+,    27,   181,   182,   183,   184,   185,   186,   107,   147,
-,   182,   183,   184,    56,    58,     3,    74,    72,   128,
+,   149,   150,   151,   152,   153,   154,   -98,   155,   138,
-     -1,    -1,    -1,    -1,   242,    -1,    -1,    -1,    -1,    -1,
+,   187,   -15,   139,   111,   188,   110,   141,   189,   183,
-     -1,   242,   243,   242,   243,   243,    11,    12,    13,    14,
+,   185,   186,   -61,   145,   146,   159,    16,    16,    19,
-,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,   233,   195,   196,   136,   198,    16,   199,    19,   242,
-,    26,    19,    20,    -1,    -1,    31,    32,    33,    34,
+,   201,   202,   203,   204,   205,   206,   207,   208,   209,
-,    36,    37,    38,    39,    40,    41,    34,    35,    36,
+,   211,   212,   213,   214,   215,   216,   217,   218,   219,
-,    38,    39,    40,    41,    -1,    -1,    -1,    -1,    -1,
+,   221,   222,   223,   224,   225,   226,    52,   102,   113,
-,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,   251,   241,   110,   104,   250,    47,   105,   133,   158,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,     0,     0,     0,    16,    16,    19,    19,   233,   160,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-,    41,    11,    12,    -1,    14,    15,    16,    17,    18,
+,   172,   173,   174,   175,   168,   169,     0,     0,   176,
-,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,   178,   179,   180,   181,   182,   183,   184,   185,   186,
-     -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
+,   180,   181,   182,   183,   184,   185,   186,     0,     0,
-,    40,    41,    11,    -1,    -1,    14,    15,    16,    17,
+,     0,     0,   197,   160,   161,   162,   163,   164,   165,
-,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     -1,    -1,    -1,    31,    32,    33,    34,    35,    36,    37,
+,     0,     0,     0,   176,   177,   178,   179,   180,   181,
-,    39,    40,    41,    14,    15,    16,    17,    18,    19,
+,   183,   184,   185,   186,   160,   161,     0,   163,   164,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,   166,   167,   168,   169,   170,   171,   172,   173,   174,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,     0,     0,     0,     0,   176,   177,   178,   179,   180,
-,    41,    14,    -1,    -1,    17,    18,    19,    20,    -1,
+,   182,   183,   184,   185,   186,   160,     0,     0,   163,
-     -1,    -1,    -1,    25,    26,    14,    -1,    -1,    -1,    31,
+,   165,   166,   167,   168,   169,   170,   171,   172,   173,
-,    20,    34,    35,    36,    37,    38,    39,    40,    41,
+,   175,     0,     0,     0,     0,   176,   177,   178,   179,
-     -1,    -1,    31,    -1,    -1,    34,    35,    36,    37,    38,
+,   181,   182,   183,   184,   185,   186,   163,   164,   165,
-,    40,    41,    14,    -1,    -1,    -1,    -1,    19,    20,
+,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    -1,    -1,
+,     0,     0,     0,   176,   177,   178,   179,   180,   181,
-     -1,    19,    20,    34,    35,    36,    37,    38,    39,    40,
+,   183,   184,   185,   186,   163,     0,     0,   166,   167,
-,    35,    36,    37,    38,    39,    40,    41,    36,    37,
+,   169,     0,     0,     0,     0,   174,   175,   163,     0,
-,    39,    40,    41
+,     0,   176,   168,   169,   179,   180,   181,   182,   183,
+,   185,   186,     0,     0,   176,   168,   169,   179,   180,
+,   182,   183,   184,   185,   186,   163,     0,     0,     0,
+,   168,   169,   181,   182,   183,   184,   185,   186,     0,
+,     0,     0,     0,     0,     0,   179,   180,   181,   182,
+,   184,   185,   186
  };
- #define YYPURE 1
- /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
- #line 3 "/usr/share/bison.simple"
- /* This file comes from bison-1.28.  */
- /* Skeleton output parser for bison,
+ static const short yycheck[] =
-    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+ {
+,    12,     0,     0,    74,    24,    39,    39,     4,    47,
-    This program is free software; you can redistribute it and/or modify
+,     3,    12,     4,    12,     4,     4,     3,    26,    49,
-    it under the terms of the GNU General Public License as published by
+,    27,    52,    49,    24,     4,    24,     0,     5,    55,
-    the Free Software Foundation; either version 2, or (at your option)
+,    46,    47,    66,    66,    27,     4,     4,    71,    48,
-    any later version.
+,    47,    50,    48,    49,     4,     3,    39,     3,    45,
+,    62,     4,    47,    50,    47,    50,    48,    46,    50,
-    This program is distributed in the hope that it will be useful,
+,     4,    62,    74,    62,    56,    50,    53,    47,     5,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+,    50,    56,    50,    74,    75,    74,    75,    75,    71,
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+,     4,    50,    50,    27,    28,    29,    30,    56,    56,
-    GNU General Public License for more details.
+,   110,    47,    36,    37,    47,    51,     3,    50,    54,
+,    44,     4,    54,    55,    56,    53,    50,    48,    49,
-    You should have received a copy of the GNU General Public License
+,    54,   110,    56,    50,    58,    59,   187,    47,    19,
-    along with this program; if not, write to the Free Software
+,     4,    51,    57,    47,    54,     4,    50,    51,   129,
-    Foundation, Inc., 59 Temple Place - Suite 330,
+,   129,   130,   144,    34,    35,    36,    37,    38,    39,
-    Boston, MA 02111-1307, USA.  */
+,    41,    93,    47,   144,    47,   144,    50,    50,    51,
+,    53,    36,    37,    38,    39,    40,    41,    52,   119,
- /* As a special exception, when this file is copied by Bison into a
+,   121,   122,   123,   124,   125,   126,    53,   128,    46,
-    Bison output file, you may use that output file without restriction.
+,    47,    46,    48,   244,    51,   187,     4,    54,    38,
-    This special exception was added by the Free Software Foundation
+,    40,    41,    48,    48,    52,    55,   187,   188,   187,
-    in version 1.24 of Bison.  */
+,   188,     4,    46,    93,    58,   196,    59,   196,   196,
+,   161,   162,   163,   164,   165,   166,   167,   168,   169,
+,   171,   172,   173,   174,   175,   176,   177,   178,   179,
+,   181,   182,   183,   184,   185,   186,     6,    56,    74,
+,   247,   190,   244,    58,   245,     3,    60,    76,   130,
+,    -1,    -1,    -1,   244,   245,   244,   245,   245,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    19,    20,    -1,    -1,    31,
+,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+       -1,    35,    36,    37,    38,    39,    40,    41,    -1,    -1,
+       -1,    -1,    -1,    55,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+       -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
+,    38,    39,    40,    41,    11,    12,    -1,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,
+,    37,    38,    39,    40,    41,    11,    -1,    -1,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,    -1,    -1,    -1,    31,    32,    33,    34,
+,    36,    37,    38,    39,    40,    41,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+       -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
+,    38,    39,    40,    41,    14,    -1,    -1,    17,    18,
+,    20,    -1,    -1,    -1,    -1,    25,    26,    14,    -1,
+       -1,    -1,    31,    19,    20,    34,    35,    36,    37,    38,
+,    40,    41,    -1,    -1,    31,    19,    20,    34,    35,
+,    37,    38,    39,    40,    41,    14,    -1,    -1,    -1,
+       -1,    19,    20,    36,    37,    38,    39,    40,    41,    -1,
+       -1,    -1,    -1,    -1,    -1,    -1,    34,    35,    36,    37,
+,    39,    40,    41
+ };
- /* 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.  */
+ {
+,     4,    45,    50,    56,    61,    62,    63,    64,    65,
- #ifndef YYSTACK_USE_ALLOCA
+,    76,    77,    78,    79,    80,    81,    88,   101,   102,
- #ifdef alloca
+,   139,     4,     4,    47,    50,    51,    53,    82,    83,
- #define YYSTACK_USE_ALLOCA
+,    85,    86,    87,    89,    90,    91,    92,   119,   120,
- #else /* alloca not defined */
+,   122,   123,   124,   125,   126,   127,   131,   132,   133,
- #ifdef __GNUC__
+,     0,    64,    78,    46,    47,    72,     5,    50,    57,
- #define YYSTACK_USE_ALLOCA
+,   130,    77,     4,   128,    84,   120,   124,   131,     4,
- #define alloca __builtin_alloca
+,   120,   124,     3,    47,    51,    54,    93,    94,    95,
- #else /* not GNU C.  */
+,     4,   121,   123,   124,    53,    87,   119,    57,    84,
- #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+,     4,    66,    67,    68,    69,   139,     4,    73,    74,
- #define YYSTACK_USE_ALLOCA
+,    71,    72,   139,   128,   130,    48,    52,   124,     4,
- #include <alloca.h>
+,    79,    97,    98,    99,   100,   138,    76,     4,    27,
- #else /* not sparc */
+,    29,    30,    36,    37,    43,    44,    50,    54,    58,
- /* We think this test detects Watcom and Microsoft C.  */
+,    81,   102,   134,   135,   104,    68,   139,    46,    48,
- /* This used to test MSDOS, but that is a bad idea
+,     4,    75,   139,    77,    48,    52,   135,   135,   135,
-    since that symbol is in the user namespace.  */
+,   135,   135,   135,   135,   135,    76,   136,   136,    55,
- #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+,    12,    13,    14,    15,    16,    17,    18,    19,    20,
- #if 0 /* No need for malloc.h, which pollutes the namespace;
+,    22,    23,    24,    25,    26,    31,    32,    33,    34,
-          instead, just don't use alloca.  */
+,    36,    37,    38,    39,    40,    41,    47,    51,    54,
- #include <malloc.h>
+,   107,   108,   109,   110,     4,    46,    55,    58,    59,
- #endif
+,   135,   135,   135,   135,   135,   135,   135,   135,   135,
- #else /* not MSDOS, or __TURBOC__ */
+,   135,   135,   135,   135,   135,   135,   135,   135,   135,
- #if defined(_AIX)
+,   135,   135,   135,   135,   135,   135,     4,    98,   111,
- /* I don't know what this was needed for, but it pollutes the namespace.
+,   117,   138,    76,   113,   116,   112,   115,   118,   134,
-    So I turned it off.   rms, 2 May 1997.  */
+,   107,    76,    48,    49,    49,    52,    49,    55,   114,
- /* #include <malloc.h>  */
+,   115
-  #pragma alloca
+ };
- #define YYSTACK_USE_ALLOCA
- #else /* not MSDOS, or __TURBOC__, or _AIX */
- #if 0
- #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
-                  and on HPUX 10.  Eventually we can turn this on.  */
- #define YYSTACK_USE_ALLOCA
- #define alloca __builtin_alloca
- #endif /* __hpux */
- #endif
- #endif /* not _AIX */
- #endif /* not MSDOS, or __TURBOC__ */
- #endif /* not sparc */
- #endif /* not GNU C */
- #endif /* alloca not defined */
- #endif /* YYSTACK_USE_ALLOCA not defined */
- #ifdef YYSTACK_USE_ALLOCA
+ #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
- /* Note: there must be only one dollar sign in this file.
-    It is replaced by the list of actions, each action
-    as one case of the switch.  */
  #define yyerrok         (yyerrstatus = 0)
  #define yyclearin       (yychar = YYEMPTY)
  #define YYEMPTY         -2
  #define YYEOF           0
  #define YYACCEPT        goto yyacceptlab
  #define YYABORT         goto yyabortlab
  #define YYERROR         goto yyerrlab1
- /* Like YYERROR except do call yyerror.
-    This remains here temporarily to ease the
+ /* Like YYERROR except do call yyerror.  This remains here temporarily
-    transition to the new meaning of YYERROR, for GCC.
+    to ease the transition to the new meaning of YYERROR, for GCC.
     Once GCC version 2 has supplanted version 1, this can go.  */
  #define YYFAIL          goto yyerrlab
  #define YYRECOVERING()  (!!yyerrstatus)
- #define YYBACKUP(token, value) \
+ #define YYBACKUP(Token, Value)                                  \
  do                                                              \
    if (yychar == YYEMPTY && yylen == 1)                          \
-     { yychar = (token), yylval = (value);                       \
+     {                                                           \
+       yychar = (Token);                                         \
+       yylval = (Value);                                         \
        yychar1 = YYTRANSLATE (yychar);                           \
        YYPOPSTACK;                                               \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
-     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
+     {                                                           \
+       yyerror ("syntax error: cannot back up");                 \
+       YYERROR;                                                  \
+     }                                                           \
  while (0)
  #define YYTERROR        1
  #define YYERRCODE       256
- #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
- #else /* not YYLSP_NEEDED */
+ /* YYLEX -- calling `yylex' with the right arguments.  */
  #ifdef YYLEX_PARAM
- #define YYLEX           yylex(&yylval, YYLEX_PARAM)
+ # define YYLEX  yylex (&yylval, YYLEX_PARAM)
  #else
- #define YYLEX           yylex(&yylval)
+ # define YYLEX  yylex (&yylval)
  #endif
- #endif /* not YYLSP_NEEDED */
+ /* Enable debugging if requested.  */
+ #if YYDEBUG
+ # 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)
+ /* Nonzero means print parse trace.  It is left uninitialized so that
+    multiple parsers can coexist.  */
+ int yydebug;
+ #else /* !YYDEBUG */
+ # define YYDPRINTF(Args)
+ # define YYDSYMPRINT(Args)
+ #endif /* !YYDEBUG */
+ /* YYINITDEPTH -- initial size of the parser's stacks.  */
+ #ifndef YYINITDEPTH
+ # define YYINITDEPTH 200
  #endif
- /* If nonreentrant, generate the variables here */
+ /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+    if the built-in stack extension method is used).
- #ifndef YYPURE
+    Do not make this value too large; the results are undefined if
+    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+    evaluated with infinite-precision integer arithmetic.  */
- int     yychar;                 /*  the lookahead symbol                */
+ #if YYMAXDEPTH == 0
- YYSTYPE yylval;                 /*  the semantic value of the           */
+ # undef YYMAXDEPTH
-                                 /*  lookahead symbol                    */
+ #endif
- #ifdef YYLSP_NEEDED
+ #ifndef YYMAXDEPTH
- YYLTYPE yylloc;                 /*  location data for the lookahead     */
+ # define YYMAXDEPTH 10000
-                                 /*  symbol                              */
  #endif
- int yynerrs;                    /*  number of parse errors so far       */
- #endif  /* not YYPURE */
- #if YYDEBUG != 0
+ #if YYERROR_VERBOSE
- int yydebug;                    /*  nonzero means print parse trace     */
- /* Since this is uninitialized, it does not stop multiple parsers
-    from coexisting.  */
- #endif
- /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
+ # ifndef yystrlen
+ #  if defined (__GLIBC__) && defined (_STRING_H)
+ #   define yystrlen strlen
+ #  else
+ /* Return the length of YYSTR.  */
+ static YYSIZE_T
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystrlen (const char *yystr)
+ #   else
+ yystrlen (yystr)
+      const char *yystr;
+ #   endif
+ {
+   register const char *yys = yystr;
- #ifndef YYINITDEPTH
+   while (*yys++ != '\0')
- #define YYINITDEPTH 200
+     continue;
- #endif
- /*  YYMAXDEPTH is the maximum size the stacks can grow to
+   return yys - yystr - 1;
-     (effective only if the built-in stack extension method is used).  */
+ }
+ #  endif
+ # endif
- #if YYMAXDEPTH == 0
+ # ifndef yystpcpy
- #undef YYMAXDEPTH
+ #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
- #endif
+ #   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 */
- #ifndef YYMAXDEPTH
- #define YYMAXDEPTH 10000
- #endif
- /* Define __yy_memcpy.  Note that the size argument
-    should be passed with type unsigned int, because that is what the non-GCC
-    definitions require.  With GCC, __builtin_memcpy takes an arg
-    of type size_t, but it can handle unsigned int.  */
- #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
- #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
- #else                           /* not GNU C or C++ */
- #ifndef __cplusplus
- /* This is the most reliable way to avoid incompatibilities
+ #if YYDEBUG
-    in available built-in functions on various systems.  */
+ /*-----------------------------.
+ | Print this symbol on YYOUT.  |
+ `-----------------------------*/
  static void
- __yy_memcpy (to, from, count)
+ #if defined (__STDC__) || defined (__cplusplus)
-      char *to;
+ yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
-      char *from;
+ #else
-      unsigned int count;
+ yysymprint (yyout, yytype, yyvalue)
+     FILE* yyout;
+     int yytype;
+     YYSTYPE yyvalue;
+ #endif
  {
-   register char *f = from;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *t = to;
+   (void) yyvalue;
-   register int i = count;
-   while (i-- > 0)
+   if (yytype < YYNTOKENS)
-     *t++ = *f++;
+     {
+       YYFPRINTF (yyout, "token %s (", yytname[yytype]);
+ # ifdef YYPRINT
+       YYPRINT (yyout, yytoknum[yytype], yyvalue);
+ # endif
+     }
+   else
+     YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+   YYFPRINTF (yyout, ")");
  }
+ #endif /* YYDEBUG. */
- #else /* __cplusplus */
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
- /* This is the most reliable way to avoid incompatibilities
-    in available built-in functions on various systems.  */
  static void
- __yy_memcpy (char *to, char *from, unsigned int count)
+ #if defined (__STDC__) || defined (__cplusplus)
+ yydestruct (int yytype, YYSTYPE yyvalue)
+ #else
+ yydestruct (yytype, yyvalue)
+     int yytype;
+     YYSTYPE yyvalue;
+ #endif
  {
-   register char *t = to;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *f = from;
+   (void) yyvalue;
-   register int i = count;
-   while (i-- > 0)
+   switch (yytype)
-     *t++ = *f++;
+     {
+       default:
+         break;
+     }
  }
- #endif
- #endif
- #line 217 "/usr/share/bison.simple"
  /* The user can define YYPARSE_PARAM as the name of an argument to be passed
     into yyparse.  The argument should have type void *.
- Line 712  __yy_memcpy (char *to, char *from, unsig
+ Line 1041  __yy_memcpy (char *to, char *from, unsig
     to the proper pointer type.  */
  #ifdef YYPARSE_PARAM
- #ifdef __cplusplus
+ # if defined (__STDC__) || defined (__cplusplus)
- #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+ #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
- #define YYPARSE_PARAM_DECL
+ #  define YYPARSE_PARAM_DECL
- #else /* not __cplusplus */
+ # else
- #define YYPARSE_PARAM_ARG YYPARSE_PARAM
+ #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
- #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+ #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
- #endif /* not __cplusplus */
+ # endif
- #else /* not YYPARSE_PARAM */
+ #else /* !YYPARSE_PARAM */
- #define YYPARSE_PARAM_ARG
+ # define YYPARSE_PARAM_ARG
- #define YYPARSE_PARAM_DECL
+ # define YYPARSE_PARAM_DECL
- #endif /* not YYPARSE_PARAM */
+ #endif /* !YYPARSE_PARAM */
  /* Prevent warning if -Wstrict-prototypes.  */
  #ifdef __GNUC__
- #ifdef YYPARSE_PARAM
+ # ifdef YYPARSE_PARAM
  int yyparse (void *);
- #else
+ # else
  int yyparse (void);
+ # endif
  #endif
- #endif
  int
- yyparse(YYPARSE_PARAM_ARG)
+ yyparse (YYPARSE_PARAM_ARG)
       YYPARSE_PARAM_DECL
  {
+   /* The lookahead symbol.  */
+ int yychar;
+ /* The semantic value of the lookahead symbol.  */
+ YYSTYPE yylval;
+ /* Number of parse errors so far.  */
+ int yynerrs;
    register int yystate;
    register int yyn;
+   int yyresult;
+   /* Number of tokens to shift before error messages enabled.  */
+   int yyerrstatus;
+   /* Lookahead token as an internal (translated) token number.  */
+   int yychar1 = 0;
+   /* Three stacks and their tools:
+      `yyss': related to states,
+      `yyvs': related to semantic values,
+      `yyls': related to locations.
+      Refer to the stacks thru separate pointers, to allow yyoverflow
+      to reallocate them elsewhere.  */
+   /* The state stack.  */
+   short yyssa[YYINITDEPTH];
+   short *yyss = yyssa;
    register short *yyssp;
-   register YYSTYPE *yyvsp;
-   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
-   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
-   short yyssa[YYINITDEPTH];     /*  the state stack                     */
+   /* The semantic value stack.  */
-   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
+   YYSTYPE yyvsa[YYINITDEPTH];
+   YYSTYPE *yyvs = yyvsa;
+   register YYSTYPE *yyvsp;
-   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
-   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
-   YYLTYPE *yyls = yylsa;
-   YYLTYPE *yylsp;
- #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
- #else
  #define YYPOPSTACK   (yyvsp--, yyssp--)
- #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;
- #if YYDEBUG != 0
+   YYDPRINTF ((stderr, "Starting parse\n"));
-   if (yydebug)
-     fprintf(stderr, "Starting parse\n");
- #endif
    yystate = 0;
    yyerrstatus = 0;
- Line 793  yyparse(YYPARSE_PARAM_ARG)
+ Line 1131  yyparse(YYPARSE_PARAM_ARG)
       so that they stay on the same level as the state stack.
       The wasted elements are never initialized.  */
-   yyssp = yyss - 1;
+   yyssp = yyss;
    yyvsp = yyvs;
- #ifdef YYLSP_NEEDED
-   yylsp = yyls;
- #endif
- /* Push a new state, which is found in  yystate  .  */
+   goto yysetstate;
- /* In all cases, when you get here, the value and location stacks
-    have just been pushed. so pushing a state here evens the stacks.  */
+ /*------------------------------------------------------------.
- yynewstate:
+ | yynewstate -- Push a new state, which is found in yystate.  |
+ `------------------------------------------------------------*/
+  yynewstate:
+   /* In all cases, when you get here, the value and location stacks
+      have just been pushed. so pushing a state here evens the stacks.
+      */
+   yyssp++;
-   *++yyssp = yystate;
+  yysetstate:
+   *yyssp = yystate;
    if (yyssp >= yyss + yystacksize - 1)
      {
-       /* Give user a chance to reallocate the stack */
-       /* Use copies of these so that the &'s don't force the real ones into memory. */
-       YYSTYPE *yyvs1 = yyvs;
-       short *yyss1 = yyss;
- #ifdef YYLSP_NEEDED
-       YYLTYPE *yyls1 = yyls;
- #endif
        /* Get the current used size of the three stacks, in elements.  */
-       int size = yyssp - yyss + 1;
+       YYSIZE_T yysize = yyssp - yyss + 1;
  #ifdef yyoverflow
-       /* Each stack pointer address is followed by the size of
+       {
-          the data in use in that stack, in bytes.  */
+         /* Give user a chance to reallocate the stack. Use copies of
- #ifdef YYLSP_NEEDED
+            these so that the &'s don't force the real ones into
-       /* This used to be a conditional around just the two extra args,
+            memory.  */
-          but that might be undefined if yyoverflow is a macro.  */
+         YYSTYPE *yyvs1 = yyvs;
-       yyoverflow("parser stack overflow",
+         short *yyss1 = yyss;
-                  &yyss1, size * sizeof (*yyssp),
-                  &yyvs1, size * sizeof (*yyvsp),
-                  &yyls1, size * sizeof (*yylsp),
+         /* Each stack pointer address is followed by the size of the
-                  &yystacksize);
+            data in use in that stack, in bytes.  This used to be a
- #else
+            conditional around just the two extra args, but that might
-       yyoverflow("parser stack overflow",
+            be undefined if yyoverflow is a macro.  */
-                  &yyss1, size * sizeof (*yyssp),
+         yyoverflow ("parser stack overflow",
-                  &yyvs1, size * sizeof (*yyvsp),
+                     &yyss1, yysize * sizeof (*yyssp),
-                  &yystacksize);
+                     &yyvs1, yysize * sizeof (*yyvsp),
- #endif
+                     &yystacksize);
-       yyss = yyss1; yyvs = yyvs1;
- #ifdef YYLSP_NEEDED
+         yyss = yyss1;
-       yyls = yyls1;
+         yyvs = yyvs1;
- #endif
+       }
  #else /* no yyoverflow */
+ # ifndef YYSTACK_RELOCATE
+       goto yyoverflowlab;
+ # else
        /* Extend the stack our own way.  */
        if (yystacksize >= YYMAXDEPTH)
-         {
+         goto yyoverflowlab;
-           yyerror("parser stack overflow");
-           if (yyfree_stacks)
-             {
-               free (yyss);
-               free (yyvs);
- #ifdef YYLSP_NEEDED
-               free (yyls);
- #endif
-             }
-           return 2;
-         }
        yystacksize *= 2;
        if (yystacksize > YYMAXDEPTH)
          yystacksize = YYMAXDEPTH;
- #ifndef YYSTACK_USE_ALLOCA
-       yyfree_stacks = 1;
+       {
- #endif
+         short *yyss1 = yyss;
-       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
+         union yyalloc *yyptr =
-       __yy_memcpy ((char *)yyss, (char *)yyss1,
+           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-                    size * (unsigned int) sizeof (*yyssp));
+         if (! yyptr)
-       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
+           goto yyoverflowlab;
-       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
+         YYSTACK_RELOCATE (yyss);
-                    size * (unsigned int) sizeof (*yyvsp));
+         YYSTACK_RELOCATE (yyvs);
- #ifdef YYLSP_NEEDED
-       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
+ #  undef YYSTACK_RELOCATE
-       __yy_memcpy ((char *)yyls, (char *)yyls1,
+         if (yyss1 != yyssa)
-                    size * (unsigned int) sizeof (*yylsp));
+           YYSTACK_FREE (yyss1);
- #endif
+       }
+ # endif
  #endif /* no yyoverflow */
-       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)
+       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+                   (unsigned long int) yystacksize));
- #endif
        if (yyssp >= yyss + yystacksize - 1)
          YYABORT;
      }
- #if YYDEBUG != 0
+   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-   if (yydebug)
-     fprintf(stderr, "Entering state %d\n", yystate);
- #endif
    goto yybackup;
-  yybackup:
+ /*-----------.
+ | yybackup.  |
+ `-----------*/
+ yybackup:
  /* Do appropriate processing given the current state.  */
  /* Read a lookahead token if we need one and don't already have one.  */
- Line 905  yynewstate:
+ Line 1229  yynewstate:
    /* First try to decide what to do without reference to lookahead token.  */
    yyn = yypact[yystate];
-   if (yyn == YYFLAG)
+   if (yyn == YYPACT_NINF)
      goto yydefault;
    /* Not known => get a lookahead token if don't already have one.  */
- Line 915  yynewstate:
+ Line 1239  yynewstate:
    if (yychar == YYEMPTY)
      {
- #if YYDEBUG != 0
+       YYDPRINTF ((stderr, "Reading a token: "));
-       if (yydebug)
-         fprintf(stderr, "Reading a token: ");
- #endif
        yychar = YYLEX;
      }
-   /* Convert token to internal form (in yychar1) for indexing tables with */
+   /* Convert token to internal form (in yychar1) for indexing tables with.  */
-   if (yychar <= 0)              /* This means end of input. */
+   if (yychar <= 0)              /* This means end of input.  */
      {
        yychar1 = 0;
-       yychar = YYEOF;           /* Don't call YYLEX any more */
+       yychar = YYEOF;           /* Don't call YYLEX any more.  */
- #if YYDEBUG != 0
+       YYDPRINTF ((stderr, "Now at end of input.\n"));
-       if (yydebug)
-         fprintf(stderr, "Now at end of input.\n");
- #endif
      }
    else
      {
-       yychar1 = YYTRANSLATE(yychar);
+       yychar1 = YYTRANSLATE (yychar);
- #if YYDEBUG != 0
+       /* We have to keep this `#if YYDEBUG', since we use variables
-       if (yydebug)
+          which are defined only if `YYDEBUG' is set.  */
-         {
+       YYDPRINTF ((stderr, "Next token is "));
-           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+       YYDSYMPRINT ((stderr, yychar1, yylval));
-           /* Give the individual parser a way to print the precise meaning
+       YYDPRINTF ((stderr, "\n"));
-              of a token, for further debugging info.  */
- #ifdef YYPRINT
-           YYPRINT (stderr, yychar, yylval);
- #endif
-           fprintf (stderr, ")\n");
-         }
- #endif
      }
+   /* If the proper action on seeing token YYCHAR1 is to reduce or to
+      detect an error, take that action.  */
    yyn += yychar1;
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
      goto yydefault;
    yyn = yytable[yyn];
+   if (yyn <= 0)
-   /* yyn is what to do for this token type in this state.
-      Negative => reduce, -yyn is rule number.
-      Positive => shift, yyn is new state.
-        New state is final state => don't bother to shift,
-        just return success.
-, or most negative number => error.  */
-   if (yyn < 0)
      {
-       if (yyn == YYFLAG)
+       if (yyn == 0 || yyn == YYTABLE_NINF)
          goto yyerrlab;
        yyn = -yyn;
        goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrlab;
    if (yyn == YYFINAL)
      YYACCEPT;
    /* Shift the lookahead token.  */
+   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
- #if YYDEBUG != 0
+               yychar, yytname[yychar1]));
-   if (yydebug)
-     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
- #endif
    /* Discard the token being shifted unless it is eof.  */
    if (yychar != YYEOF)
      yychar = YYEMPTY;
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
-   /* count tokens shifted since error; after three, turn off error status.  */
-   if (yyerrstatus) yyerrstatus--;
+   /* Count tokens shifted since error; after three, turn off error
+      status.  */
+   if (yyerrstatus)
+     yyerrstatus--;
    yystate = yyn;
    goto yynewstate;
- /* Do the default action for the current state.  */
- yydefault:
+ /*-----------------------------------------------------------.
+ | yydefault -- do the default action for the current state.  |
+ `-----------------------------------------------------------*/
+ yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
      goto yyerrlab;
+   goto yyreduce;
- /* Do a reduction.  yyn is the number of a rule to reduce with.  */
+ /*-----------------------------.
+ | yyreduce -- Do a reduction.  |
+ `-----------------------------*/
  yyreduce:
+   /* yyn is the number of a rule to reduce with.  */
    yylen = yyr2[yyn];
-   if (yylen > 0)
-     yyval = yyvsp[1-yylen]; /* implement default value of the action */
- #if YYDEBUG != 0
+   /* If YYLEN is nonzero, implement the default value of the action:
+      `$$ = $1'.
+      Otherwise, the following line sets YYVAL to garbage.
+      This behavior is undocumented and Bison
+      users should not rely upon it.  Assigning to YYVAL
+      unconditionally makes the parser a bit smaller, and it avoids a
+      GCC warning that YYVAL may be used uninitialized.  */
+   yyval = yyvsp[1-yylen];
+ #if YYDEBUG
+   /* We have to keep this `#if YYDEBUG', since we use variables which
+      are defined only if `YYDEBUG' is set.  */
    if (yydebug)
      {
-       int i;
+       int yyi;
-       fprintf (stderr, "Reducing via rule %d (line %d), ",
+       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-                yyn, yyrline[yyn]);
+                  yyn - 1, yyrline[yyn]);
        /* Print the symbols being reduced, and their result.  */
-       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
-         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
      }
  #endif
+   switch (yyn)
+     {
-   switch (yyn) {
+         case 2:
+ #line 123 "compile.y"
- case 1:
+     {
- #line 116 "compile.y"
+         Method& method=*new Method(Method::CT_ANY,
- {
-         MethodPtr method(new Method(main_method_name, Method::CT_ANY,
 , 0, /*min, max numbered_params_count*/
-                 Array0/*param_names*/, Array0/*local_names*/,
+/*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 131 "compile.y"
+   case 9:
- {
+ #line 138 "compile.y"
-         const String& command=LA2S(*yyvsp[-2]);
+     {
+         const String& command=*LA2S(*yyvsp[-2]);
          YYSTYPE strings_code=yyvsp[0];
          if(strings_code->count()<1*2) {
                  strcpy(PC.error, "@");
-                 strcat(PC.error, command->cstr());
+                 strcat(PC.error, command.cstr());
                  strcat(PC.error, " is empty");
                  YYERROR;
          }
-         if(*command==CLASS_NAME) {
+         if(command==CLASS_NAME) {
                  if(PC.cclass->base_class()) { // already changed from default?
                          strcpy(PC.error, "class already have a name '");
-                         strncat(PC.error, PC.cclass->name()->cstr(), 100);
+                         strncat(PC.error, PC.cclass->name().cstr(), 100);
                          strcat(PC.error, "'");
                          YYERROR;
                  }
                  if(strings_code->count()==1*2) {
                          // new class' name
-                         const String& name=LA2S(*strings_code);
+                         const String& name=*LA2S(*strings_code);
                          // creating the class
-                         VStateless_classPtr cclass(new VClass);  cclass->set_name(name);
+                         VStateless_class* cclass=new VClass;
+                         PC.cclass=cclass;
+                         PC.cclass->set_name(name);
                          // append to request's classes
-                         PC.request->classes().put(name, cclass);
+                         PC.request.classes().put(name, cclass);
-                         // new methods go to that class
-                         PC.cclass=cclass.get();
                  } else {
                          strcpy(PC.error, "@"CLASS_NAME" must contain sole name");
                          YYERROR;
                  }
-         } else if(*command==USE_CONTROL_METHOD_NAME) {
+         } else if(command==USE_CONTROL_METHOD_NAME) {
-                 for(int i=0; i<strings_code->count(); i+=2)
+                 for(size_t i=0; i<strings_code->count(); i+=2)
-                         PC.request->use_file(*PC.request->main_class, 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_class()) { // already changed from default?
                          strcpy(PC.error, "class already have a base '");
-                         strncat(PC.error, PC.cclass->base_class()->name()->cstr(), 100);
+                         strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100);
                          strcat(PC.error, "'");
                          YYERROR;
                  }
                  if(strings_code->count()==1*2) {
-                         const String& base_name=LA2S(*strings_code);
+                         const String& base_name=*LA2S(*strings_code);
-                         if(ValuePtr base_class_value=PC.request->classes().get(base_name)) {
+                         if(Value* base_class_value=PC.request.classes().get(base_name)) {
                                  // @CLASS == @BASE sanity check
                                  if(VStateless_class *base_class=base_class_value->get_class()) {
                                          if(PC.cclass==base_class) {
- Line 1093  case 8:
+ Line 1410  case 8:
                                          }
                                          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());
+                                         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);
                                  YYERROR;
                          }
- Line 1108  case 8:
+ Line 1425  case 8:
                  }
          } else {
                  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 "
                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
                  YYERROR;
          }
- ;
+ }
-     break;}
+     break;
- case 12:
- #line 203 "compile.y"
+   case 13:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 210 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- case 16:
+     break;
- #line 208 "compile.y"
- {
+   case 17:
-         const String& name=LA2S(*yyvsp[-5]);
+ #line 215 "compile.y"
+     {
+         const String& name=*LA2S(*yyvsp[-5]);
          YYSTYPE params_names_code=yyvsp[-4];
-         ArrayString& params_names;
+         ArrayString* params_names=0;
          if(int size=params_names_code->count()) {
-                 params_names=ArrayString* (new ArrayString);
+                 params_names=new ArrayString;
                  for(int i=0; i<size; i+=2)
                          *params_names+=LA2S(*params_names_code, i);
          }
          YYSTYPE locals_names_code=yyvsp[-3];
-         ArrayString& locals_names;
+         ArrayString* locals_names=0;
          if(int size=locals_names_code->count()) {
-                 locals_names=ArrayString* (new ArrayString);
+                 locals_names=new ArrayString;
                  for(int i=0; i<size; i+=2)
                          *locals_names+=LA2S(*locals_names_code, i);
          }
-         MethodPtr method(new Method(
+         Method& method=*new Method(
-                 name,
+                 //name,
                  Method::CT_ANY,
 , 0/*min,max numbered_params_count*/,
                  params_names, locals_names,
-                 yyvsp[0], 0));
+                 yyvsp[0], 0);
-         PC.cclass->add_method(name, method);
+         PC.cclass->add_method(PC.alias_method(name), method);
- ;
+ }
-     break;}
+     break;
- case 19:
- #line 237 "compile.y"
+   case 20:
- {yyval=yyvsp[-1];
+ #line 244 "compile.y"
-     break;}
+     {yyval=yyvsp[-1]}
- case 23:
+     break;
- #line 239 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+   case 24:
-     break;}
+ #line 246 "compile.y"
- case 29:
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) }
- #line 247 "compile.y"
+     break;
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
+   case 30:
- case 35:
+ #line 254 "compile.y"
- #line 253 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- {
+     break;
+   case 36:
+ #line 260 "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;}
+     break;
- case 36:
- #line 260 "compile.y"
+   case 37:
- { yyval=yyvsp[0] ;
+ #line 267 "compile.y"
-     break;}
+     { yyval=yyvsp[0] }
- case 39:
+     break;
- #line 262 "compile.y"
- { yyval=yyvsp[-1] ;
+   case 40:
-     break;}
+ #line 269 "compile.y"
- case 42:
+     { yyval=yyvsp[-1] }
- #line 266 "compile.y"
+     break;
- {
+   case 43:
+ #line 273 "compile.y"
+     {
          yyval=N();
-         ArrayOperationPtr diving_code=yyvsp[0];
+         ArrayOperation* diving_code=yyvsp[0];
-         const String& first_name=LA2S(*diving_code);
+         const String* first_name=LA2S(*diving_code);
          // self.xxx... -> xxx...
          // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
- Line 1198  case 42:
+ Line 1524  case 42:
                  // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
                  // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
                  if(PC.in_call_value && diving_code->count()==3)
-                         (*diving_code)[2].code=OP_GET_ELEMENT_OR_OPERATOR;
+                         diving_code->put(2, OP_GET_ELEMENT_OR_OPERATOR);
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ }
-     break;}
+     break;
- case 43:
- #line 288 "compile.y"
+   case 44:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 295 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- case 45:
+     break;
- #line 289 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 46:
-     break;}
+ #line 296 "compile.y"
- case 46:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- #line 293 "compile.y"
+     break;
- {
+   case 47:
+ #line 300 "compile.y"
+     {
          yyval=yyvsp[-1]; /* stack: context,name */
          P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
- ;
+ }
-     break;}
+     break;
- case 50:
- #line 301 "compile.y"
+   case 51:
- {
+ #line 308 "compile.y"
+     {
          yyval=N();
-         ArrayOperationPtr diving_code=yyvsp[0];
+         ArrayOperation* diving_code=yyvsp[0];
-         const String& first_name=LA2S(*diving_code);
+         const String* first_name=LA2S(*diving_code);
          // $self.xxx... -> $xxx...
          // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
- Line 1237  case 50:
+ Line 1567  case 50:
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ }
-     break;}
+     break;
- case 51:
- #line 318 "compile.y"
+   case 52:
- {
+ #line 325 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_WRITE); /* stack: starting context */
          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
- ;
+ }
-     break;}
+     break;
- case 52:
- #line 323 "compile.y"
+   case 53:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 56:
  #line 330 "compile.y"
- {
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
+     break;
+   case 57:
+ #line 337 "compile.y"
+     {
          // stack: context, name
          yyval=yyvsp[-1]; // stack: context, name, value
          O(*yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
- ;
+ }
-     break;}
+     break;
- case 57:
- #line 336 "compile.y"
+   case 58:
- {
+ #line 343 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_PREPARE_TO_EXPRESSION);
          // stack: context, name
          P(*yyval, *yyvsp[-1]); // stack: context, name, value
          O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
- ;
+ }
-     break;}
+     break;
- case 58:
- #line 344 "compile.y"
+   case 59:
- {
+ #line 351 "compile.y"
+     {
          // stack: context, name
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
- ;
+ }
-     break;}
+     break;
- case 62:
- #line 355 "compile.y"
+   case 63:
- {
+ #line 362 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ }
-     break;}
+     break;
- case 65:
- #line 362 "compile.y"
+   case 66:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 369 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- case 66:
+     break;
- #line 366 "compile.y"
- {
+   case 67:
+ #line 373 "compile.y"
+     {
          yyval=yyvsp[0]; /* stack: value */
          changetail_or_append(*yyval,
                  OP_CALL, true,  /*->*/ OP_CALL__WRITE,
                  /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
- ;
+ }
-     break;}
+     break;
- case 67:
- #line 372 "compile.y"
+   case 68:
- {
+ #line 379 "compile.y"
+     {
                                          PC.in_call_value=true;
-                         ;
+                         }
-     break;}
+     break;
- case 68:
- #line 375 "compile.y"
+   case 69:
- {
+ #line 382 "compile.y"
+     {
                                  PC.in_call_value=false;
-                         ;
+                         }
-     break;}
+     break;
- case 69:
- #line 378 "compile.y"
+   case 70:
- { /* ^field.$method{vasya} */
+ #line 385 "compile.y"
+     { /* ^field.$method{vasya} */
          yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
          YYSTYPE params_code=yyvsp[-1];
          if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
-                 if(ValuePtr value=LA2V(*params_code)) // it is OP_VALUE + value?
+                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE + value?
                          if(!value->is_defined()) // value is VVoid?
-                                 params_code=YYSTYPE(0); // ^zzz[] case. don't append lone empty param.
+                                 params_code=0; // ^zzz[] case. don't append lone empty param.
          }
          /* stack: context, method_junction */
          OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
- ;
+ }
-     break;}
+     break;
- case 72:
- #line 393 "compile.y"
+   case 73:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 76:
- #line 399 "compile.y"
- {yyval=yyvsp[-1];
-     break;}
- case 77:
  #line 400 "compile.y"
- {yyval=yyvsp[-1];
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
-     break;}
+     break;
- case 78:
- #line 401 "compile.y"
+   case 77:
- {yyval=yyvsp[-1];
+ #line 406 "compile.y"
-     break;}
+     {yyval=yyvsp[-1]}
- case 80:
+     break;
- #line 404 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+   case 78:
-     break;}
+ #line 407 "compile.y"
- case 82:
+     {yyval=yyvsp[-1]}
+     break;
+   case 79:
  #line 408 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+     {yyval=yyvsp[-1]}
-     break;}
+     break;
- case 84:
- #line 412 "compile.y"
+   case 81:
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+ #line 411 "compile.y"
-     break;}
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) }
- case 85:
+     break;
- #line 414 "compile.y"
- {
+   case 83:
+ #line 415 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) }
+     break;
+   case 85:
+ #line 419 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) }
+     break;
+   case 86:
+ #line 421 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_STORE_PARAM);
- ;
+ }
-     break;}
+     break;
- case 86:
- #line 418 "compile.y"
+   case 87:
- {
+ #line 425 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]);
- ;
+ }
-     break;}
+     break;
- case 87:
- #line 422 "compile.y"
+   case 88:
- {
+ #line 429 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
- ;
+ }
-     break;}
+     break;
- case 91:
- #line 431 "compile.y"
+   case 92:
- {
+ #line 438 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_PREPARE_TO_EXPRESSION);
          P(*yyval, *yyvsp[0]);
          O(*yyval, OP_WRITE_EXPR_RESULT);
- ;
+ }
-     break;}
+     break;
- case 93:
- #line 440 "compile.y"
+   case 94:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 447 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- case 95:
+     break;
- #line 442 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 96:
-     break;}
+ #line 449 "compile.y"
- case 97:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- #line 444 "compile.y"
+     break;
- {
+   case 98:
+ #line 451 "compile.y"
+     {
          // we know that name_advance1 not called from ^xxx context
          // so we'll not check for operator call possibility as we do in name_advance2
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ }
-     break;}
+     break;
- case 98:
- #line 452 "compile.y"
+   case 99:
- {
+ #line 459 "compile.y"
+     {
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ }
-     break;}
+     break;
- case 104:
- #line 465 "compile.y"
+   case 105:
- {
+ #line 472 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT);
- ;
+ }
-     break;}
+     break;
- case 105:
- #line 469 "compile.y"
+   case 106:
- {
+ #line 476 "compile.y"
-         ArrayOperationPtr code;
+     {
+         ArrayOperation* code;
          {
                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
                  P(*code, *yyvsp[0]);
          }
          yyval=N();
          OA(*yyval, OP_STRING_POOL, code);
- ;
+ }
-     break;}
+     break;
- case 106:
- #line 478 "compile.y"
+   case 107:
- {
+ #line 485 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ }
-     break;}
+     break;
- case 107:
- #line 484 "compile.y"
+   case 108:
- {
+ #line 491 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_READ);
          P(*yyval, *yyvsp[0]);
- ;
+ }
-     break;}
+     break;
- case 109:
- #line 489 "compile.y"
+   case 110:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 496 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) }
- case 110:
+     break;
- #line 490 "compile.y"
- {
+   case 111:
+ #line 497 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT__WRITE);
- ;
+ }
-     break;}
+     break;
- case 113:
- #line 499 "compile.y"
+   case 114:
- {
+ #line 506 "compile.y"
+     {
          yyval=yyvsp[-1]; // stack: class name string
-         if(*LA2S(*yyval) == BASE_NAME) { // pseude BASE class
+         if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
                  if(VStateless_class* base=PC.cclass->base_class()) {
                          change_string_literal_value(*yyval, base->name());
                  } else {
- Line 1471  case 113:
+ Line 1834  case 113:
                  }
          }
          O(*yyval, OP_GET_CLASS);
- ;
+ }
-     break;}
+     break;
- case 114:
- #line 511 "compile.y"
+   case 115:
- {
+ #line 518 "compile.y"
+     {
          yyval=yyvsp[-1];
          if(!PC.in_call_value) {
                  strcpy(PC.error, ":: not allowed here");
                  YYERROR;
          }
          O(*yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);
- ;
+ }
-     break;}
+     break;
- case 115:
- #line 523 "compile.y"
+   case 116:
- {
+ #line 530 "compile.y"
+     {
          // see OP_PREPARE_TO_EXPRESSION!!
          if((yyval=yyvsp[0])->count()==2) // only one string literal in there?
                  change_string_literal_to_double_literal(*yyval); // make that string literal Double
- ;
+ }
-     break;}
+     break;
- case 119:
- #line 532 "compile.y"
+   case 120:
- { yyval = yyvsp[-1]; ;
-     break;}
- case 120:
- #line 533 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 121:
- #line 534 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 122:
- #line 536 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;
-     break;}
- case 123:
- #line 537 "compile.y"
- { yyval=yyvsp[0] ;
-     break;}
- case 124:
- #line 538 "compile.y"
- { yyval=yyvsp[0];        O(*yyval, OP_INV) ;
-     break;}
- case 125:
  #line 539 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;
+     { yyval = yyvsp[-1]; }
-     break;}
+     break;
- case 126:
+   case 121:
  #line 540 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;
+     { yyval = yyvsp[-1]; }
-     break;}
+     break;
- case 127:
+   case 122:
  #line 541 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_IN) ;
+     { yyval = yyvsp[-1]; }
-     break;}
+     break;
- case 128:
- #line 542 "compile.y"
+   case 123:
- { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;
-     break;}
- case 129:
  #line 543 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_NEG) }
-     break;}
+     break;
- case 130:
+   case 124:
+ #line 544 "compile.y"
+     { yyval=yyvsp[0] }
+     break;
+   case 125:
  #line 545 "compile.y"
- {       yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;
+     { yyval=yyvsp[0];    O(*yyval, OP_INV) }
-     break;}
+     break;
- case 131:
+   case 126:
  #line 546 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_NOT) }
-     break;}
+     break;
- case 132:
+   case 127:
  #line 547 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_DEF) }
-     break;}
+     break;
- case 133:
+   case 128:
  #line 548 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_IN) }
-     break;}
+     break;
- case 134:
+   case 129:
  #line 549 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) }
-     break;}
+     break;
- case 135:
+   case 130:
  #line 550 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) }
-     break;}
+     break;
- case 136:
- #line 551 "compile.y"
+   case 131:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;
-     break;}
- case 137:
  #line 552 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;
+     {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) }
-     break;}
+     break;
- case 138:
+   case 132:
  #line 553 "compile.y"
- { yyval=yyvsp[-2];      P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) }
-     break;}
+     break;
- case 139:
+   case 133:
  #line 554 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) }
-     break;}
+     break;
- case 140:
+   case 134:
  #line 555 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) }
-     break;}
+     break;
- case 141:
+   case 135:
  #line 556 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) }
-     break;}
+     break;
- case 142:
+   case 136:
  #line 557 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) }
-     break;}
+     break;
- case 143:
+   case 137:
  #line 558 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) }
-     break;}
+     break;
- case 144:
+   case 138:
  #line 559 "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 145:
+   case 139:
  #line 560 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) }
-     break;}
+     break;
- case 146:
+   case 140:
  #line 561 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) }
-     break;}
+     break;
- case 147:
+   case 141:
  #line 562 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) }
-     break;}
+     break;
- case 148:
+   case 142:
  #line 563 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;
+     { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) }
-     break;}
+     break;
- case 149:
+   case 143:
  #line 564 "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_OR) }
-     break;}
+     break;
- case 150:
+   case 144:
  #line 565 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) }
-     break;}
+     break;
- case 151:
+   case 145:
  #line 566 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) }
-     break;}
+     break;
- case 152:
+   case 146:
  #line 567 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) }
-     break;}
+     break;
- case 153:
+   case 147:
  #line 568 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) }
-     break;}
+     break;
- case 154:
+   case 148:
  #line 569 "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_GE) }
-     break;}
+     break;
- case 155:
+   case 149:
  #line 570 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) }
-     break;}
+     break;
- case 156:
+   case 150:
  #line 571 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) }
-     break;}
+     break;
- case 157:
+   case 151:
+ #line 572 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) }
+     break;
+   case 152:
+ #line 573 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) }
+     break;
+   case 153:
  #line 574 "compile.y"
- {
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) }
+     break;
+   case 154:
+ #line 575 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) }
+     break;
+   case 155:
+ #line 576 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) }
+     break;
+   case 156:
+ #line 577 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) }
+     break;
+   case 157:
+ #line 578 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) }
+     break;
+   case 158:
+ #line 581 "compile.y"
+     {
          yyval=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;}
+     break;
- case 158:
- #line 583 "compile.y"
+   case 159:
- {
+ #line 590 "compile.y"
+     {
          // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
          change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
- ;
-     break;}
- case 159:
- #line 588 "compile.y"
- { yyval=VL(ValuePtr(new VVoid())) ;
-     break;}
- case 160:
- #line 589 "compile.y"
- { yyval=N() ;
-     break;}
  }
-    /* the action file gets copied in in place of this dollarsign */
+     break;
- #line 543 "/usr/share/bison.simple"
+   case 160:
+ #line 595 "compile.y"
+     { yyval=VL(new VVoid(), 0, 0, 0) }
+     break;
+   case 161:
+ #line 596 "compile.y"
+     { yyval=N() }
+     break;
+     }
+ /* Line 1016 of /usr/local/share/bison/yacc.c.  */
+ #line 2084 "compile.tab.C"
    yyvsp -= yylen;
    yyssp -= yylen;
- #ifdef YYLSP_NEEDED
-   yylsp -= yylen;
- #endif
- #if YYDEBUG != 0
+ #if YYDEBUG
    if (yydebug)
      {
-       short *ssp1 = yyss - 1;
+       short *yyssp1 = yyss - 1;
-       fprintf (stderr, "state stack now");
+       YYFPRINTF (stderr, "state stack now");
-       while (ssp1 != yyssp)
+       while (yyssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
+         YYFPRINTF (stderr, " %d", *++yyssp1);
-       fprintf (stderr, "\n");
+       YYFPRINTF (stderr, "\n");
      }
  #endif
    *++yyvsp = yyval;
- #ifdef YYLSP_NEEDED
-   yylsp++;
-   if (yylen == 0)
-     {
-       yylsp->first_line = yylloc.first_line;
-       yylsp->first_column = yylloc.first_column;
-       yylsp->last_line = (yylsp-1)->last_line;
-       yylsp->last_column = (yylsp-1)->last_column;
-       yylsp->text = 0;
-     }
-   else
-     {
-       yylsp->last_line = (yylsp+yylen-1)->last_line;
-       yylsp->last_column = (yylsp+yylen-1)->last_column;
-     }
- #endif
-   /* Now "shift" the result of the reduction.
+   /* 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];
-   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];
    else
-     yystate = yydefgoto[yyn - YYNTBASE];
+     yystate = yydefgoto[yyn - YYNTOKENS];
    goto yynewstate;
- yyerrlab:   /* here on detecting error */
-   if (! yyerrstatus)
+ /*------------------------------------.
-     /* If not already recovering from an error, report this error.  */
+ | yyerrlab -- here on detecting error |
+ `------------------------------------*/
+ yyerrlab:
+   /* If not already recovering from an error, report this error.  */
+   if (!yyerrstatus)
      {
        ++yynerrs;
+ #if YYERROR_VERBOSE
- #ifdef YYERROR_VERBOSE
        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;
+           char *yymsg;
+           int yyx, yycount;
-           count = 0;
-           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+           yycount = 0;
-           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)
+           for (yyx = yyn < 0 ? -yyn : 0;
-               size += strlen(yytname[x]) + 15, count++;
+                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
-           msg = (char *) malloc(size + 15);
+             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-           if (msg != 0)
+               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+           yysize += yystrlen ("parse error, unexpected ") + 1;
+           yysize += yystrlen (yytname[yytype]);
+           yymsg = (char *) YYSTACK_ALLOC (yysize);
+           if (yymsg != 0)
              {
-               strcpy(msg, "parse error");
+               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+               yyp = yystpcpy (yyp, yytname[yytype]);
-               if (count < 5)
+               if (yycount < 5)
                  {
-                   count = 0;
+                   yycount = 0;
-                   for (x = (yyn < 0 ? -yyn : 0);
+                   for (yyx = yyn < 0 ? -yyn : 0;
-                        x < (sizeof(yytname) / sizeof(char *)); x++)
+                        yyx < (int) (sizeof (yytname) / sizeof (char *));
-                     if (yycheck[x + yyn] == x)
+                        yyx++)
+                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                        {
-                         strcat(msg, count == 0 ? ", expecting `" : " or `");
+                         const char *yyq = ! yycount ? ", expecting " : " or ";
-                         strcat(msg, yytname[x]);
+                         yyp = yystpcpy (yyp, yyq);
-                         strcat(msg, "'");
+                         yyp = yystpcpy (yyp, yytname[yyx]);
-                         count++;
+                         yycount++;
                        }
                  }
-               yyerror(msg);
+               yyerror (yymsg);
-               free(msg);
+               YYSTACK_FREE (yymsg);
              }
            else
-             yyerror ("parse error; also virtual memory exceeded");
+             yyerror ("parse error; also virtual memory exhausted");
          }
        else
  #endif /* YYERROR_VERBOSE */
-         yyerror("parse error");
+         yyerror ("parse error");
      }
    goto yyerrlab1;
- yyerrlab1:   /* here on error raised explicitly by an action */
+ /*----------------------------------------------------.
+ | yyerrlab1 -- error raised explicitly by an action.  |
+ `----------------------------------------------------*/
+ yyerrlab1:
    if (yyerrstatus == 3)
      {
-       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+       /* If just tried and failed to reuse lookahead token after an
+          error, discard it.  */
-       /* return failure if at end of input */
+       /* Return failure if at end of input.  */
        if (yychar == YYEOF)
-         YYABORT;
+         {
+           /* Pop the error token.  */
- #if YYDEBUG != 0
+           YYPOPSTACK;
-       if (yydebug)
+           /* Pop the rest of the stack.  */
-         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+           while (yyssp > yyss)
- #endif
+             {
+               YYDPRINTF ((stderr, "Error: popping "));
+               YYDSYMPRINT ((stderr,
+                             yystos[*yyssp],
+                             *yyvsp));
+               YYDPRINTF ((stderr, "\n"));
+               yydestruct (yystos[*yyssp], *yyvsp);
+               YYPOPSTACK;
+             }
+           YYABORT;
+         }
+       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+                   yychar, yytname[yychar1]));
+       yydestruct (yychar1, yylval);
        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.  */
-   yyerrstatus = 3;              /* Each real token shifted decrements this */
+   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
-   goto yyerrhandle;
+   for (;;)
+     {
+       yyn = yypact[yystate];
+       if (yyn != YYPACT_NINF)
+         {
+           yyn += YYTERROR;
+           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+             {
+               yyn = yytable[yyn];
+               if (0 < yyn)
+                 break;
+             }
+         }
- yyerrdefault:  /* current state does not do anything special for the error token. */
+       /* Pop the current state because it cannot handle the error token.  */
+       if (yyssp == yyss)
+         YYABORT;
- #if 0
+       YYDPRINTF ((stderr, "Error: popping "));
-   /* This is wrong; only states that explicitly want error tokens
+       YYDSYMPRINT ((stderr,
-      should shift them.  */
+                     yystos[*yyssp], *yyvsp));
-   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+       YYDPRINTF ((stderr, "\n"));
-   if (yyn) goto yydefault;
- #endif
- yyerrpop:   /* pop the current state because it cannot handle the error token */
+       yydestruct (yystos[yystate], *yyvsp);
+       yyvsp--;
+       yystate = *--yyssp;
-   if (yyssp == yyss) YYABORT;
-   yyvsp--;
-   yystate = *--yyssp;
- #ifdef YYLSP_NEEDED
-   yylsp--;
- #endif
- #if YYDEBUG != 0
+ #if YYDEBUG
-   if (yydebug)
+       if (yydebug)
-     {
+         {
-       short *ssp1 = yyss - 1;
+           short *yyssp1 = yyss - 1;
-       fprintf (stderr, "Error: state stack now");
+           YYFPRINTF (stderr, "Error: state stack now");
-       while (ssp1 != yyssp)
+           while (yyssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
+             YYFPRINTF (stderr, " %d", *++yyssp1);
-       fprintf (stderr, "\n");
+           YYFPRINTF (stderr, "\n");
-     }
+         }
  #endif
- yyerrhandle:
-   yyn = yypact[yystate];
-   if (yyn == YYFLAG)
-     goto yyerrdefault;
-   yyn += YYTERROR;
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-     goto yyerrdefault;
-   yyn = yytable[yyn];
-   if (yyn < 0)
-     {
-       if (yyn == YYFLAG)
-         goto yyerrpop;
-       yyn = -yyn;
-       goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrpop;
    if (yyn == YYFINAL)
      YYACCEPT;
- #if YYDEBUG != 0
+   YYDPRINTF ((stderr, "Shifting error token, "));
-   if (yydebug)
-     fprintf(stderr, "Shifting error token, ");
- #endif
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
    yystate = yyn;
    goto yynewstate;
-  yyacceptlab:
-   /* YYACCEPT comes here.  */
-   if (yyfree_stacks)
-     {
-       free (yyss);
-       free (yyvs);
- #ifdef YYLSP_NEEDED
-       free (yyls);
- #endif
-     }
-   return 0;
-  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
-     }
+   return yyresult;
-   return 1;
  }
- #line 591 "compile.y"
+ #line 598 "compile.y"
  #endif
  /*
-$111(2222)00
+(2222)00
-$111{3333}00
+{3333}00
          $,^: push,=0
 :( { break=pop
 :( )  pop
- Line 1910  yyerrhandle:
+ Line 2319  yyerrhandle:
 :[^({]=pop
  */
- static int yylex(YYSTYPE *lvalp, void *pc) {
+ inline void ungetc(Parse_control& pc, uint last_line_end_col) {
-         #define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp]
+         pc.source--;
+         if(pc.pos.col==0) {
+                 --pc.pos.line; pc.pos.col=last_line_end_col;
+         } else
+                 --pc.pos.col;
+ }
+ static int yylex(YYSTYPE *lvalp, void *apc) {
+         register Parse_control& pc=*static_cast<Parse_control*>(apc);
+         #define lexical_brackets_nestage pc.brackets_nestages[pc.ls_sp]
          #define RC {result=c; goto break2; }
-     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;
          }
-         const char *begin=PC.source;
+         const char *begin=pc.source;
+         Pos begin_pos=pc.pos;
+         uint last_line_end_col=0;
          const char *end;
-         int begin_line=PC.line;
          int skip_analized=0;
          while(true) {
-                 c=*(end=(PC.source++));
+                 c=*(end=(pc.source++));
- //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp);
+ //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp);
                  if(c=='\n') {
-                         PC.line++;
+                         pc.pos.line++;
-                         PC.col=0;
+                         last_line_end_col=pc.pos.col;
+                         pc.pos.col=0;
                  } else
-                         PC.col++;
+                         pc.pos.col+=c=='\t'?TAB_SIZE:1;
-                 if(c=='@' && PC.col==0+1) {
+                 if(c=='@' && pc.pos.col==0+1) {
-                         if(PC.ls==LS_DEF_SPECIAL_BODY) {
+                         if(pc.ls==LS_DEF_SPECIAL_BODY) {
                                  // @SPECIAL
                                  // ...
                                  // @<here =
-                                 pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state
+                                 pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state
                          } // continuing checks
-                         if(PC.ls==LS_USER) {
+                         if(pc.ls==LS_USER) {
-                                 push_LS(PC, LS_DEF_NAME);
+                                 push_LS(pc, LS_DEF_NAME);
                                  RC;
                          } else // @ in first column inside some code [when could that be?]
                                  result=BAD_METHOD_DECL_START;
                          goto break2;
                  } else if(c=='^') {
-                         if(PC.ls==LS_METHOD_AFTER) {
+                         if(pc.ls==LS_METHOD_AFTER) {
                                  // handle after-method situation
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  result=EON;
                                  skip_analized=-1; // return to punctuation afterwards to assure it's literality
                                  goto break2;
                          }
-                         switch(PC.ls) {
+                         switch(pc.ls) {
  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
  case LS_VAR_NAME_SIMPLE_WITH_COLON:
- Line 1970  case LS_DEF_COMMENT:
+ Line 2391  case LS_DEF_COMMENT:
          // no literals in names, please
          break;
  default:
-                         switch(*PC.source) {
+                         switch(*pc.source) {
                          // ^escaping some punctuators
                          case '^': case '$': case ';':
                          case '(': case ')':
- Line 1978  default:
+ Line 2399  default:
                          case '{': case '}':
                          case '"':  case ':':
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till ^
-                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                         pc.string.append_strdup(begin, end-begin);
                                  }
                                  // reset piece 'begin' position & line
-                                 begin=PC.source; // ->punctuation
+                                 begin=pc.source; // ->punctuation
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
                                  // skip over _ after ^
-                                 PC.source++;  PC.col++;
+                                 pc.source++;  pc.pos.col++;
                                  // skip analysis = forced literal
                                  continue;
                          // converting ^#HH into char(hex(HH))
                          case '#':
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till ^
-                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                         pc.string.append_strdup(begin, end-begin);
                                  }
                                  // #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=
-                                         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;
                                                  goto break2; // wrong hex value[no ^#00 chars allowed]: bail out
                                          }
                                          // append char(hex(HH))
-                                         PC.string->APPEND_CLEAN(hex, 1, PC.file, begin_line);
+                                         pc.string.append(c);
                                          // skip over ^#HH
-                                         PC.source+=3;
+                                         pc.source+=3;
-                                         PC.col+=3;
+                                         pc.pos.col+=3;
                                          // reset piece 'begin' position & line
-                                         begin=PC.source; // ->after ^#HH
+                                         begin=pc.source; // ->after ^#HH
-                                         begin_line=PC.line;
+                                         begin_pos=pc.pos;
                                          // skip analysis = forced literal
                                          continue;
                                  }
- Line 2022  default:
+ Line 2446  default:
                          }
                  }
                  // #comment  start skipping
-                 if(c=='#' && PC.col==1) {
+                 if(c=='#' && pc.pos.col==1) {
                          if(end!=begin) {
+                                 if(!pc.string_start)
+                                         pc.string_start=begin_pos;
                                  // append piece till #
-                                 PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                 pc.string.append_strdup(begin, end-begin);
                          }
                          // fall into COMMENT lexical state [wait for \n]
-                         push_LS(PC, LS_USER_COMMENT);
+                         push_LS(pc, LS_USER_COMMENT);
                          continue;
                  }
-                 switch(PC.ls) {
+                 switch(pc.ls) {
                  // USER'S = NOT OURS
                  case LS_USER:
-         case LS_NAME_SQUARE_PART: // name.[here].xxx
+                 case LS_NAME_SQUARE_PART: // name.[here].xxx
-                         if(PC.trim_bof)
+                         if(pc.trim_bof)
                                  switch(c) {
                                  case '\n': case ' ': case '\t':
-                                         begin=PC.source;
+                                         begin=pc.source;
-                                         begin_line=PC.line;
+                                         begin_pos=pc.pos;
                                          continue; // skip it
                                  default:
-                                         PC.trim_bof=false;
+                                         pc.trim_bof=false;
                                  }
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ']':
-                                 if(PC.ls==LS_NAME_SQUARE_PART)
+                                 if(pc.ls==LS_NAME_SQUARE_PART)
                                          if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
-                                                 pop_LS(PC); // $name.[co<]>de<]!>
+                                                 pop_LS(pc); // $name.[co<]>de<]!>
                                                  RC;
                                          }
                                  break;
                          case '[': // $name.[co<[>de]
-                                 if(PC.ls==LS_NAME_SQUARE_PART)
+                                 if(pc.ls==LS_NAME_SQUARE_PART)
                                          lexical_brackets_nestage++;
                                  break;
                          }
- Line 2070  default:
+ Line 2496  default:
                  case LS_USER_COMMENT:
                          if(c=='\n') {
                                  // skip comment
-                                 begin=PC.source;
+                                 begin=pc.source;
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  continue;
                          }
                          break;
- Line 2085  default:
+ Line 2511  default:
                          case '"':
                          case '\'':
                                  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;
                                  }
                                  break;
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          }
                          break;
- Line 2104  default:
+ Line 2530  default:
                  case LS_DEF_NAME:
                          switch(c) {
                          case '[':
-                                 PC.ls=LS_DEF_PARAMS;
+                                 pc.ls=LS_DEF_PARAMS;
                                  RC;
                          case '\n':
-                                 PC.ls=LS_DEF_SPECIAL_BODY;
+                                 pc.ls=LS_DEF_SPECIAL_BODY;
                                  RC;
                          }
                          break;
- Line 2120  default:
+ Line 2546  default:
                          case ';':
                                  RC;
                          case ']':
-                                 PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
+                                 pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
                                  RC;
                          case '\n': // wrong. bailing out
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
- Line 2134  default:
+ Line 2560  default:
                          case ';':
                                  RC;
                          case ']':
-                                 PC.ls=LS_DEF_COMMENT;
+                                 pc.ls=LS_DEF_COMMENT;
                                  RC;
                          case '\n': // wrong. bailing out
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
                  case LS_DEF_COMMENT:
                          if(c=='\n') {
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
- Line 2160  default:
+ Line 2586  default:
                          switch(c) {
                          case ')':
                                  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;
                          case '#': // comment start skipping
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till #
-                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                         pc.string.append_strdup(begin, end-begin);
                                  }
                                  // fall into COMMENT lexical state [wait for \n]
-                                 push_LS(PC, LS_EXPRESSION_COMMENT);
+                                 push_LS(pc, LS_EXPRESSION_COMMENT);
                                  lexical_brackets_nestage=1;
                                  continue;
                          case '$':
-                                 push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);
+                                 push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case '(':
                                  lexical_brackets_nestage++;
                                  RC;
                          case '-':
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case 'f': // -f
                                          skip_analized=1;
                                          result=FEXISTS;
- Line 2203  default:
+ Line 2631  default:
                          case ';':
                                  RC;
                          case '&': case '|':
-                                 if(*PC.source==c) { // && ||
+                                 if(*pc.source==c) { // && ||
                                          result=c=='&'?LAND:LOR;
                                          skip_analized=1;
                                  } else
                                          result=c;
                                  goto break2;
                          case '!':
-                                 switch(PC.source[0]) {
+                                 switch(pc.source[0]) {
                                  case '|': // !| !||
                                          skip_analized=1;
-                                         if(PC.source[1]=='|') {
+                                         if(pc.source[1]=='|') {
                                                  skip_analized++;
                                                  result=LXOR;
                                          } else
- Line 2227  default:
+ Line 2655  default:
                                  RC;
                          case '<': // <<, <=, <
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '<': // <[<]
                                          skip_analized=1; result=NSL; break;
                                  case '=': // <[=]
- Line 2237  default:
+ Line 2665  default:
                                  }
                                  goto break2;
                          case '>': // >>, >=, >
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '>': // >[>]
                                          skip_analized=1; result=NSR; break;
                                  case '=': // >[=]
- Line 2247  default:
+ Line 2675  default:
                                  }
                                  goto break2;
                          case '=': // ==
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '=': // =[=]
                                          skip_analized=1; result=NEQ; break;
                                  default: // =[]
- Line 2256  default:
+ Line 2684  default:
                                  goto break2;
                          case '"':
-                                 push_LS(PC, LS_EXPRESSION_STRING_QUOTED);
+                                 push_LS(pc, LS_EXPRESSION_STRING_QUOTED);
                                  RC;
                          case '\'':
-                                 push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED);
+                                 push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED);
                                  RC;
                          case 'l': case 'g': case 'e': case 'n':
                                  if(end==begin) // right after whitespace
-                                         if(isspace(PC.source[1])) {
+                                         if(isspace(pc.source[1])) {
-                                                 switch(*PC.source) {
+                                                 switch(*pc.source) {
                                                          //                                      case '?': // ok [and bad cases, yacc would bark at them]
                                                  case 't': // lt gt [et nt]
                                                          result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;
- Line 2283  default:
+ Line 2711  default:
                                  break;
                          case 'i':
                                  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
                                                          skip_analized=1;
                                                          result=IN;
- Line 2298  default:
+ Line 2726  default:
                                  break;
                          case 'd':
                                  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;
                                                  result=DEF;
                                                  goto break2;
- Line 2312  default:
+ Line 2740  default:
                                  // that's a leading|traling space or after-operator-space
                                  // ignoring it
                                  // reset piece 'begin' position & line
-                                 begin=PC.source; // after whitespace char
+                                 begin=pc.source; // after whitespace char
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
                                  continue;
                          }
                          break;
- Line 2321  default:
+ Line 2749  default:
                          if(c=='(')
                                  lexical_brackets_nestage++;
-                         switch(*PC.source) {
+                         switch(*pc.source) {
                          case '\n': case ')':
-                                 if(*PC.source==')')
+                                 if(*pc.source==')')
                                          if(--lexical_brackets_nestage!=0)
                                                  continue;
                                  // skip comment
-                                 begin=PC.source;
+                                 begin=pc.source;
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  continue;
                          }
                          break;
- Line 2342  default:
+ Line 2770  default:
                  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
                  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
                          if(
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                  // name in expr ends also before
                                  switch(c) {
                                  // expression minus
                                  case '-':
                                  // expression integer division
                                  case '\\':
-                                         pop_LS(PC);
+                                         pop_LS(pc);
-                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                         ungetc(pc, last_line_end_col);
                                          result=EON;
                                          goto break2;
                                  }
                          }
                          if(
-                                 PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||
+                                 pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                  // name already has ':', stop before next
                                  switch(c) {
                                  case ':':
-                                         pop_LS(PC);
+                                         pop_LS(pc);
-                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                         ungetc(pc, last_line_end_col);
                                          result=EON;
                                          goto break2;
                                  }
- Line 2382  default:
+ Line 2810  default:
                          case ',': case '?': case '#':
                          // before call
                          case '^':
-                                 pop_LS(PC);
+                                 pop_LS(pc);
-                                 PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                 ungetc(pc, last_line_end_col);
                                  result=EON;
                                  goto break2;
                          case '[':
                                  // $name.<[>code]
-                                 if(PC.col>1/*not first column*/ && (
+                                 if(pc.pos.col>1/*not first column*/ && (
                                          end[-1]=='$'/*was start of get*/ ||
                                          end[-1]==':'/*was class name delim */ ||
                                          end[-1]=='.'/*was name delim */
                                          )) {
-                                         push_LS(PC, LS_NAME_SQUARE_PART);
+                                         push_LS(pc, LS_NAME_SQUARE_PART);
                                          lexical_brackets_nestage=1;
                                          RC;
                                  }
-                                 PC.ls=LS_VAR_SQUARE;
+                                 pc.ls=LS_VAR_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '{':
                                  if(begin==end) { // ${name}, no need of EON, switching LS
-                                         PC.ls=LS_VAR_NAME_CURLY;
+                                         pc.ls=LS_VAR_NAME_CURLY;
                                  } else {
-                                         PC.ls=LS_VAR_CURLY;
+                                         pc.ls=LS_VAR_CURLY;
                                          lexical_brackets_nestage=1;
                                  }
                                  RC;
                          case '(':
-                                 PC.ls=LS_VAR_ROUND;
+                                 pc.ls=LS_VAR_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '.': // name part delim
                          case '$': // name part subvar
                          case ':': // class<:>name
                                  // go to _WITHOUT_COLON state variant...
-                                 if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
+                                 if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
-                                         PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
+                                         pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
-                                 else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
+                                 else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
-                                         PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
+                                         pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
                                  // ...stop before next ':'
                                  RC;
                          }
- Line 2430  default:
+ Line 2858  default:
                          switch(c) {
                          case '[':
                                  // ${name.<[>code]}
-                                 push_LS(PC, LS_NAME_SQUARE_PART);
+                                 push_LS(pc, LS_NAME_SQUARE_PART);
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '}': // ${name} finished, restoring LS
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          case '.': // name part delim
                          case '$': // name part subvar
- Line 2446  default:
+ Line 2874  default:
                  case LS_VAR_SQUARE:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ']':
                                  if(--lexical_brackets_nestage==0) {
-                                         pop_LS(PC);
+                                         pop_LS(pc);
                                          RC;
                                  }
                                  break;
- Line 2468  default:
+ Line 2896  default:
                  case LS_VAR_CURLY:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case '}':
                                  if(--lexical_brackets_nestage==0) {
-                                         pop_LS(PC);
+                                         pop_LS(pc);
                                          RC;
                                  }
                                  break;
- Line 2490  default:
+ Line 2918  default:
                          switch(c) {
                          case '[':
                                  // ^name.<[>code].xxx
-                                 if(PC.col>1/*not first column*/ && (
+                                 if(pc.pos.col>1/*not first column*/ && (
                                          end[-1]=='^'/*was start of call*/ || // never, ^[ is literal...
                                          end[-1]==':'/*was class name delim */ ||
                                          end[-1]=='.'/*was name delim */
                                          )) {
-                                         push_LS(PC, LS_NAME_SQUARE_PART);
+                                         push_LS(pc, LS_NAME_SQUARE_PART);
                                          lexical_brackets_nestage=1;
                                          RC;
                                  }
-                                 PC.ls=LS_METHOD_SQUARE;
+                                 pc.ls=LS_METHOD_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '{':
-                                 PC.ls=LS_METHOD_CURLY;
+                                 pc.ls=LS_METHOD_CURLY;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '(':
-                                 PC.ls=LS_METHOD_ROUND;
+                                 pc.ls=LS_METHOD_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '.': // name part delim
- Line 2522  default:
+ Line 2950  default:
                  case LS_METHOD_SQUARE:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ';': // param delim
                                  RC;
                          case ']':
                                  if(--lexical_brackets_nestage==0) {
-                                         PC.ls=LS_METHOD_AFTER;
+                                         pc.ls=LS_METHOD_AFTER;
                                          RC;
                                  }
                                  break;
- Line 2544  default:
+ Line 2972  default:
                  case LS_METHOD_CURLY:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ';': // param delim
                                  RC;
                          case '}':
                                  if(--lexical_brackets_nestage==0) {
-                                         PC.ls=LS_METHOD_AFTER;
+                                         pc.ls=LS_METHOD_AFTER;
                                          RC;
                                  }
                                  break;
- Line 2565  default:
+ Line 2993  default:
                  case LS_METHOD_AFTER:
                          if(c=='[') {/* ][ }[ )[ */
-                                 PC.ls=LS_METHOD_SQUARE;
+                                 pc.ls=LS_METHOD_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='{') {/* ]{ }{ ){ */
-                                 PC.ls=LS_METHOD_CURLY;
+                                 pc.ls=LS_METHOD_CURLY;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='(') {/* ]( }( )( */
-                                 PC.ls=LS_METHOD_ROUND;
+                                 pc.ls=LS_METHOD_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
-                         pop_LS(PC);
+                         pop_LS(pc);
-                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                         ungetc(pc, last_line_end_col);
                          result=EON;
                          goto break2;
                  }
- Line 2598  break2:
+ Line 3026  break2:
                          if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
                                  end--;
                  }
-                 if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
+                 if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
+                         if(!pc.string_start)
+                                 pc.string_start=begin_pos;
                          // append it
-                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/*, start_col*/);
+                         pc.string.append_strdup(begin, end-begin);
                  }
          }
-         if(PC.string->size()) { // something accumulated?
+         if(!pc.string.is_empty()) { // something accumulated?
                  // create STRING value: array of OP_VALUE+vstring
-                 *lvalp=VL(ValuePtr(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
-                 PC.string=String* (new String);
+                 pc.string.clear();
+                 pc.string_start.clear();
                  // make current result be pending for next call, return STRING for now
-                 PC.pending_state=result;  result=STRING;
+                 pc.pending_state=result;  result=STRING;
          }
          if(skip_analized) {
-                 PC.source+=skip_analized;  PC.col+=skip_analized;
+                 pc.source+=skip_analized;  pc.pos.col+=skip_analized;
          }
          return result;
  }
- static int real_yyerror(parse_control *pc, char *s) {  // Called by yyparse on error
+ static int real_yyerror(Parse_control *pc, char *s) {  // Called by yyparse on error
             strncpy(PC.error, s, MAX_STRING);
             return 1;
  }
  static void yyprint(FILE *file, int type, YYSTYPE value) {
          if(type==STRING)
-                 fprintf(file, " \"%s\"", LA2S(*value)->cstr().get());
+                 fprintf(file, " \"%s\"", LA2S(*value)->cstr());
  }

E-mail:

Removed from v.1.81.2.13.2.2
changed lines
	Added in v.1.81.2.13.2.25