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.55 and 1.145

-version 1.55, 2002/06/10 13:50:02
+version 1.145, 2009/08/14 23:58:55
  Line 1
+ /* A Bison parser, made by GNU Bison 1.875d.  */
- /*  A Bison parser, made from compile.y
+ /* Skeleton parser for Yacc-like parsing with Bison,
-     by GNU Bison version 1.28  */
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
- #define YYBISON 1  /* Identify Bison output.  */
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
- #define EON     257
+    This program is distributed in the hope that it will be useful,
- #define STRING  258
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
- #define BOGUS   259
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- #define BAD_STRING_COMPARISON_OPERATOR  260
+    GNU General Public License for more details.
- #define BAD_HEX_LITERAL 261
- #define BAD_METHOD_DECL_START   262
- #define LAND    263
- #define LOR     264
- #define LXOR    265
- #define NLE     266
- #define NGE     267
- #define NEQ     268
- #define NNE     269
- #define SLT     270
- #define SGT     271
- #define SLE     272
- #define SGE     273
- #define SEQ     274
- #define SNE     275
- #define DEF     276
- #define IN      277
- #define FEXISTS 278
- #define DEXISTS 279
- #define IS      280
- #define NEG     281
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.  */
+ /* As a special exception, when this file is copied by Bison into a
+    Bison output file, you may use that output file without restriction.
+    This special exception was added by the Free Software Foundation
+    in version 1.24 of Bison.  */
+ /* Written by Richard Stallman by simplifying the original so called
+    ``semantic'' parser.  */
+ /* All symbols defined below should begin with yy or YY, to avoid
+    infringing on user name space.  This should be done even for local
+    variables, as they might otherwise be expanded by user macros.
+    There are some unavoidable exceptions within include files to
+    define necessary library symbols; they are noted "INFRINGES ON
+    USER NAME SPACE" below.  */
+ /* Identify Bison output.  */
+ #define YYBISON 1
+ /* Skeleton name.  */
+ #define YYSKELETON_NAME "yacc.c"
+ /* Pure parsers.  */
+ #define YYPURE 1
+ /* Using locations.  */
+ #define YYLSP_NEEDED 0
+ /* Tokens.  */
+ #ifndef YYTOKENTYPE
+ # define YYTOKENTYPE
+    /* Put the tokens into the symbol table, so that GDB and other debuggers
+       know about them.  */
+    enum yytokentype {
+      EON = 258,
+      STRING = 259,
+      BOGUS = 260,
+      BAD_STRING_COMPARISON_OPERATOR = 261,
+      BAD_HEX_LITERAL = 262,
+      BAD_METHOD_DECL_START = 263,
+      BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
+      BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,
+      LAND = 266,
+      LOR = 267,
+      LXOR = 268,
+      NXOR = 269,
+      NLE = 270,
+      NGE = 271,
+      NEQ = 272,
+      NNE = 273,
+      NSL = 274,
+      NSR = 275,
+      SLT = 276,
+      SGT = 277,
+      SLE = 278,
+      SGE = 279,
+      SEQ = 280,
+      SNE = 281,
+      DEF = 282,
+      IN = 283,
+      FEXISTS = 284,
+      DEXISTS = 285,
+      IS = 286,
+      LITERAL_TRUE = 287,
+      LITERAL_FALSE = 288,
+      NUNARY = 289
+    };
+ #endif
+ #define EON 258
+ #define STRING 259
+ #define BOGUS 260
+ #define BAD_STRING_COMPARISON_OPERATOR 261
+ #define BAD_HEX_LITERAL 262
+ #define BAD_METHOD_DECL_START 263
+ #define BAD_METHOD_PARAMETER_NAME_CHARACTER 264
+ #define BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE 265
+ #define LAND 266
+ #define LOR 267
+ #define LXOR 268
+ #define NXOR 269
+ #define NLE 270
+ #define NGE 271
+ #define NEQ 272
+ #define NNE 273
+ #define NSL 274
+ #define NSR 275
+ #define SLT 276
+ #define SGT 277
+ #define SLE 278
+ #define SGE 279
+ #define SEQ 280
+ #define SNE 281
+ #define DEF 282
+ #define IN 283
+ #define FEXISTS 284
+ #define DEXISTS 285
+ #define IS 286
+ #define LITERAL_TRUE 287
+ #define LITERAL_FALSE 288
+ #define NUNARY 289
+ /* Copy the first part of user declarations.  */
  #line 1 "compile.y"
  /** @file
          Parser: compiler(lexical parser and grammar).
-         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
+         Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
          $Id$
- Line 52
+ Line 146
                  -#:     in iis make up specialized Pool object for that
  */
- #define YYSTYPE  Array/*<Operation>*/ *
+ #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 67
+ Line 163
  #include "pa_vdouble.h"
  #include "pa_globals.h"
  #include "pa_vvoid.h"
+ #include "pa_vmethod_frame.h"
- #define SELF_ELEMENT_NAME "self"
+ // defines
- #define USE_CONTROL_METHOD_NAME "USE"
- static int real_yyerror(parse_control *pc, char *s);
- static void yyprint(FILE *file, int type, YYSTYPE value);
- static int yylex(YYSTYPE *lvalp, void *pc);
+ #define USE_CONTROL_METHOD_NAME "USE"
+ #define OPTIONS_CONTROL_METHOD_NAME "OPTIONS"
+ #define OPTION_ALL_VARS_LOCAL_NAME "locals"
+ #define OPTION_PARTIAL_CLASS "partial"
+ #define REM_OPERATOR_NAME "rem"
+ // forwards
+ static int real_yyerror(Parse_control* pc, char* s);
+ static void yyprint(FILE* file, int type, YYSTYPE value);
+ static int yylex(YYSTYPE* lvalp, void* pc);
+ static const VBool vfalse(false);
+ static const VBool vtrue(true);
+ static const VVoid vvoid;
  // local convinient inplace typecast & var
- #define PC  (*(parse_control *)pc)
+ #undef PC
+ #define PC  (*(Parse_control *)pc)
+ #undef POOL
  #define POOL  (*PC.pool)
- #undef NEW
- #define NEW new(POOL)
  #ifndef DOXYGEN
- #ifndef YYSTYPE
- #define YYSTYPE int
- #endif
- #include <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
+ #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+ typedef int YYSTYPE;
+ # define yystype YYSTYPE /* obsolescent; will be withdrawn */
+ # define YYSTYPE_IS_DECLARED 1
+ # define YYSTYPE_IS_TRIVIAL 1
+ #endif
+ /* Copy the second part of user declarations.  */
+ /* Line 214 of yacc.c.  */
+ #line 221 "compile.tab.C"
+ #if ! defined (yyoverflow) || YYERROR_VERBOSE
+ # ifndef YYFREE
+ #  define YYFREE free
+ # endif
+ # ifndef YYMALLOC
+ #  define YYMALLOC malloc
+ # endif
+ /* The parser invokes alloca or malloc; define the necessary symbols.  */
+ # ifdef YYSTACK_USE_ALLOCA
+ #  if YYSTACK_USE_ALLOCA
+ #   define YYSTACK_ALLOC alloca
+ #  endif
+ # else
+ #  if defined (alloca) || defined (_ALLOCA_H)
+ #   define YYSTACK_ALLOC alloca
+ #  else
+ #   ifdef __GNUC__
+ #    define YYSTACK_ALLOC __builtin_alloca
+ #   endif
+ #  endif
+ # endif
+ # ifdef YYSTACK_ALLOC
+    /* Pacify GCC's `empty if-body' warning. */
+ #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ # else
+ #  if defined (__STDC__) || defined (__cplusplus)
+ #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ #   define YYSIZE_T size_t
+ #  endif
+ #  define YYSTACK_ALLOC YYMALLOC
+ #  define YYSTACK_FREE YYFREE
+ # endif
+ #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+ #if (! defined (yyoverflow) \
+      && (! defined (__cplusplus) \
+          || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+ /* A type that is properly aligned for any stack member.  */
+ union yyalloc
+ {
+   short int yyss;
+   YYSTYPE yyvs;
+   };
+ /* The size of the maximum gap between one aligned stack and the next.  */
+ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+ /* The size of an array large to enough to hold all stacks, each with
+    N elements.  */
+ # define YYSTACK_BYTES(N) \
+      ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
+       + YYSTACK_GAP_MAXIMUM)
+ /* Copy COUNT objects from FROM to TO.  The source and destination do
+    not overlap.  */
+ # ifndef YYCOPY
+ #  if defined (__GNUC__) && 1 < __GNUC__
+ #   define YYCOPY(To, From, Count) \
+       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+ #  else
+ #   define YYCOPY(To, From, Count)              \
+       do                                        \
+         {                                       \
+           register YYSIZE_T yyi;                \
+           for (yyi = 0; yyi < (Count); yyi++)   \
+             (To)[yyi] = (From)[yyi];            \
+         }                                       \
+       while (0)
+ #  endif
+ # endif
+ /* Relocate STACK from its old location to the new one.  The
+    local variables YYSIZE and YYSTACKSIZE give the old and new number of
+    elements in the stack, and YYPTR gives the new location of the
+    stack.  Advance YYPTR to a properly aligned location for the next
+    stack.  */
+ # define YYSTACK_RELOCATE(Stack)                                        \
+     do                                                                  \
+       {                                                                 \
+         YYSIZE_T yynewbytes;                                            \
+         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
+         Stack = &yyptr->Stack;                                          \
+         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+         yyptr += yynewbytes / sizeof (*yyptr);                          \
+       }                                                                 \
+     while (0)
+ #endif
- #define YYFINAL         248
+ #if defined (__STDC__) || defined (__cplusplus)
- #define YYFLAG          -32768
+    typedef signed char yysigned_char;
- #define YYNTBASE        56
+ #else
+    typedef short int yysigned_char;
- #define YYTRANSLATE(x) ((unsigned)(x) <= 281 ? yytranslate[x] : 135)
+ #endif
- static const char yytranslate[] = {     0,
-,     2,     2,     2,     2,     2,     2,     2,     2,    42,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,    29,    54,    30,    46,    38,    32,    55,    50,
-,    36,    35,     2,    34,    49,    37,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,    53,    45,    27,
-,    28,     2,    41,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,    39,    44,    52,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,    47,    31,    48,    33,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     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,
-,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-,    18,    19,    20,    21,    22,    23,    24,    25,    26,
- };
- #if YYDEBUG != 0
+ /* YYFINAL -- State number of the termination state. */
- static const short yyprhs[] = {     0,
+ #define YYFINAL  51
-,     2,     4,     6,     9,    11,    13,    15,    20,    22,
+ /* YYLAST -- Last index in YYTABLE.  */
-,    26,    29,    32,    34,    36,    44,    46,    48,    52,
+ #define YYLAST   470
-,    56,    58,    62,    64,    66,    68,    70,    72,    75,
-,    79,    81,    83,    85,    87,    90,    93,    95,    99,
+ /* YYNTOKENS -- Number of terminals. */
-,   103,   105,   108,   110,   113,   117,   119,   121,   123,
+ #define YYNTOKENS  62
-,   128,   131,   133,   135,   137,   141,   145,   149,   151,
+ /* YYNNTS -- Number of nonterminals. */
-,   155,   157,   159,   161,   164,   166,   167,   168,   175,
+ #define YYNNTS  89
-,   179,   182,   184,   186,   188,   192,   196,   200,   202,
+ /* YYNRULES -- Number of rules. */
-,   208,   212,   214,   218,   220,   222,   224,   226,   228,
+ #define YYNRULES  172
-,   232,   234,   237,   239,   242,   245,   247,   249,   252,
+ /* YYNRULES -- Number of states. */
-,   256,   258,   260,   263,   266,   270,   272,   274,   277,
+ #define YYNSTATES  263
-,   282,   284,   287,   290,   292,   294,   296,   298,   302,
-,   310,   313,   316,   319,   322,   325,   328,   331,   334,
+ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-,   342,   346,   350,   354,   358,   362,   366,   370,   374,
+ #define YYUNDEFTOK  2
-,   382,   386,   390,   394,   398,   402,   406,   410,   414,
+ #define YYMAXUTOK   289
-,   422,   426,   430,   434,   436,   438,   439
+ #define YYTRANSLATE(YYX)                                                \
+   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+ /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+ static const unsigned char yytranslate[] =
+ {
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,    46,    60,     2,    52,    43,    37,    61,
+,    57,    40,    38,     2,    39,    55,    41,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,    59,    51,
+,     2,    35,     2,    47,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,    49,    42,    50,    58,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,    53,    36,    54,    45,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     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,    32,    33,    44
  };
- static const short yyrhs[] = {    58,
+ #if YYDEBUG
-,    57,     0,    59,     0,    57,    59,     0,    71,     0,
+ /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-,     0,    65,     0,    41,     4,    42,    61,     0,   134,
+    YYRHS.  */
-,    62,     0,    63,     0,    62,    63,     0,    64,    42,
+ static const unsigned short int yyprhs[] =
-,   134,     0,     4,     0,    41,     4,    67,    66,    70,
+ {
-,    71,     0,   134,     0,    67,     0,    43,    68,    44,
+,     0,     3,     5,     7,     9,    12,    14,    16,    18,
-,   134,     0,    69,     0,     4,     0,    69,    45,     4,
+,    25,    27,    29,    32,    35,    37,    39,    40,    49,
-,   134,     0,     4,     0,   134,     0,    72,     0,    73,
+,    53,    57,    59,    61,    63,    67,    69,    71,    73,
-,    72,    73,     0,   132,     0,    74,     0,    75,     0,
+,    77,    80,    82,    84,    86,    88,    90,    92,    95,
-,     0,    96,     0,    76,     0,    46,    77,     0,    79,
+,   100,   104,   106,   108,   110,   113,   115,   118,   122,
-,     0,    78,     0,    47,    79,    48,     0,    80,     0,
+,   126,   128,   130,   133,   136,   138,   140,   142,   143,
-,     0,    82,     0,   126,    82,     0,   118,     0,   115,
+,   150,   154,   158,   160,   162,   164,   166,   168,   170,
-,     0,    46,    84,    88,     0,    85,     0,    86,     0,
+,   175,   176,   177,   184,   186,   188,   191,   193,   195,
-,     0,   114,     0,    49,   114,     0,   126,   114,     0,
+,   198,   199,   205,   209,   213,   215,   219,   221,   225,
-,     0,    90,     0,    91,     0,    43,    92,    44,     0,
+,   231,   233,   235,   237,   239,   241,   243,   245,   248,
-,   129,    51,     0,    47,    71,    48,     0,   133,     0,
+,   253,   256,   258,   260,   263,   265,   267,   269,   271,
-,     0,    93,     0,    94,     0,    95,     0,    74,     0,
+,   277,   278,   279,   285,   287,   289,   292,   295,   297,
-,    72,     0,    97,     0,     0,     0,    52,    98,   100,
+,   302,   305,   307,   309,   311,   313,   315,   317,   321,
-,   101,     3,     0,    79,     0,   102,     0,   101,   102,
+,   329,   332,   335,   338,   341,   344,   347,   350,   353,
-,   103,     0,   104,     0,   105,     0,    43,   106,    44,
+,   361,   365,   369,   373,   377,   381,   385,   389,   393,
-,    50,   107,    51,     0,    47,   108,    48,     0,   109,
+,   401,   405,   409,   413,   417,   421,   425,   429,   433,
-,   106,    45,   109,     0,   110,     0,   107,    45,   110,
+,   441,   445,   449,   453,   457,   461,   463,   465,   467,
-,   111,     0,   108,    45,   111,     0,   112,     0,   113,
+,   470,   472
-,    71,     0,   133,     0,     4,     0,    93,     0,   129,
-,   119,     0,   115,   119,     0,   116,     0,   115,   116,
-,   117,    49,     0,   119,     0,   119,     0,     4,     5,
-,     4,     0,   120,     0,   121,     0,   122,     0,    46,
-,     0,     4,   124,     0,    43,    72,    44,     0,     4,
-,   125,     0,   124,   125,     0,    46,   123,     0,   127,
-,   128,     0,     4,    53,     0,   127,    53,     0,   130,
-,     4,     0,    76,     0,    97,     0,    54,   131,    54,
-,    55,   131,    55,     0,    50,   130,    51,     0,    34,
-,     0,    35,   130,     0,    33,   130,     0,    29,   130,
-,    22,   130,     0,    23,   130,     0,    24,   130,     0,
-,   130,     0,   130,    34,   130,     0,   130,    35,   130,
-,   130,    36,   130,     0,   130,    37,   130,     0,   130,
-,   130,     0,   130,    39,   130,     0,   130,    32,   130,
-,   130,    31,   130,     0,   130,    30,   130,     0,   130,
-,   130,     0,   130,    10,   130,     0,   130,    11,   130,
-,   130,    27,   130,     0,   130,    28,   130,     0,   130,
-,   130,     0,   130,    13,   130,     0,   130,    14,   130,
-,   130,    15,   130,     0,   130,    16,   130,     0,   130,
-,   130,     0,   130,    18,   130,     0,   130,    19,   130,
-,   130,    20,   130,     0,   130,    21,   130,     0,   130,
-,   130,     0,    71,     0,     4,     0,     0,     0
  };
- #endif
+ /* YYRHS -- A `-1'-separated list of the rules' RHS. */
+ static const short int yyrhs[] =
+ {
+,     0,    -1,    65,    -1,    64,    -1,    66,    -1,    64,
+,    -1,    79,    -1,    67,    -1,    72,    -1,    47,     4,
+,    68,    -1,   150,    -1,    69,    -1,    70,    -1,    69,
+,    -1,    71,    48,    -1,   150,    -1,     4,    -1,    -1,
+,     4,    75,    74,    78,    48,    73,    79,    -1,   150,
+       -1,    75,    -1,    49,    76,    50,    -1,   150,    -1,    77,
+       -1,     4,    -1,    77,    51,     4,    -1,   150,    -1,     4,
+       -1,   150,    -1,    80,    -1,    81,    -1,    80,    81,    -1,
+,    -1,    82,    -1,    83,    -1,    91,    -1,   106,    -1,
+,    -1,    52,    85,    -1,    87,     3,    -1,    86,    -1,
+,    87,    54,    -1,    88,    -1,    89,    -1,    90,    -1,
+,    90,    -1,   129,    -1,   126,   129,    -1,    52,    92,
+,    -1,    93,    -1,    94,    -1,    95,    -1,   125,    -1,
+,   125,    -1,   139,   125,    -1,    97,    -1,   100,    -1,
+,    -1,    -1,    -1,    49,    98,   102,    99,    50,    -1,
+,   142,    57,    -1,    53,    79,    54,    -1,   147,    -1,
+,    -1,   103,    -1,   104,    -1,   105,    -1,    82,    -1,
+,    80,    -1,   107,    -1,    -1,    -1,    58,   108,   110,
+,   111,     3,    -1,    87,    -1,   112,    -1,   111,   112,
+       -1,   113,    -1,   116,    -1,   117,    -1,    -1,    -1,    49,
+,   118,   115,    50,    -1,    56,   119,    57,    -1,    53,
+,    54,    -1,   121,    -1,   118,    51,   121,    -1,   122,
+       -1,   119,    51,   122,    -1,   123,    -1,   120,    51,   123,
+       -1,   124,    -1,   142,    -1,    79,    -1,   147,    -1,     4,
+       -1,   103,    -1,   130,    -1,   126,   130,    -1,   127,    -1,
+,   127,    -1,   128,    55,    -1,   130,    -1,   130,    -1,
+,     5,    -1,     4,    -1,   131,    -1,   132,    -1,   133,
+       -1,    52,   136,    -1,     4,   137,    -1,    -1,    -1,    49,
+,    80,   135,    50,    -1,     4,    -1,   138,    -1,   137,
+,    -1,    52,   136,    -1,   140,    -1,   141,    -1,     4,
+,    -1,   140,    59,    -1,   143,    -1,   144,    -1,   148,
+       -1,   149,    -1,    84,    -1,   107,    -1,    60,   145,    60,
+       -1,    61,   145,    61,    -1,    56,   143,    57,    -1,    39,
+,    -1,    38,   143,    -1,    45,   143,    -1,    46,   143,
+       -1,    27,   143,    -1,    28,   143,    -1,    29,   143,    -1,
+,   143,    -1,   143,    39,   143,    -1,   143,    38,   143,
+       -1,   143,    40,   143,    -1,   143,    41,   143,    -1,   143,
+,   143,    -1,   143,    42,   143,    -1,   143,    19,   143,
+       -1,   143,    20,   143,    -1,   143,    37,   143,    -1,   143,
+,   143,    -1,   143,    14,   143,    -1,   143,    11,   143,
+       -1,   143,    12,   143,    -1,   143,    13,   143,    -1,   143,
+,   143,    -1,   143,    35,   143,    -1,   143,    15,   143,
+       -1,   143,    16,   143,    -1,   143,    17,   143,    -1,   143,
+,   143,    -1,   143,    21,   143,    -1,   143,    22,   143,
+       -1,   143,    23,   143,    -1,   143,    24,   143,    -1,   143,
+,   143,    -1,   143,    26,   143,    -1,   143,    31,   143,
+       -1,     4,    -1,    79,    -1,     4,    -1,    -1,    32,    -1,
+,    -1,    -1
+ };
- #if YYDEBUG != 0
+ /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
- static const short yyrline[] = { 0,
+ static const unsigned short int yyrline[] =
-,   117,   119,   119,   120,   122,   122,   124,   190,   190,
+ {
-,   191,   192,   193,   193,   195,   224,   224,   225,   226,
+,   132,   132,   139,   141,   141,   142,   144,   144,   146,
-,   227,   227,   229,   229,   233,   233,   235,   235,   236,
+,   247,   248,   248,   249,   250,   250,   252,   252,   302,
-,   237,   237,   237,   241,   248,   249,   249,   250,   251,
+,   303,   304,   304,   305,   305,   307,   307,   311,   311,
-,   254,   276,   277,   277,   281,   285,   287,   288,   289,
+,   313,   314,   314,   315,   315,   315,   319,   360,   361,
-,   311,   313,   315,   316,   318,   324,   332,   338,   340,
+,   362,   364,   365,   366,   419,   420,   420,   424,   437,
-,   343,   349,   350,   350,   354,   360,   363,   366,   379,
+,   439,   440,   466,   471,   474,   475,   476,   478,   481,
-,   381,   382,   384,   385,   387,   388,   389,   390,   392,
+,   489,   497,   504,   505,   506,   508,   514,   515,   515,
-,   396,   398,   400,   402,   406,   410,   414,   416,   417,
+,   531,   534,   531,   578,   580,   580,   582,   583,   584,
-,   428,   428,   430,   430,   431,   432,   440,   445,   447,
+,   589,   586,   592,   593,   595,   596,   599,   600,   603,
-,   450,   451,   453,   457,   466,   472,   477,   477,   478,
+,   606,   609,   623,   628,   629,   630,   635,   635,   637,
-,   485,   487,   491,   503,   508,   510,   511,   512,   513,
+,   638,   639,   647,   652,   655,   656,   657,   658,   660,
-,   516,   517,   518,   519,   520,   521,   522,   523,   525,
+,   673,   676,   673,   684,   689,   689,   690,   696,   697,
-,   527,   528,   529,   530,   531,   532,   533,   534,   535,
+,   716,   728,   730,   731,   732,   733,   734,   735,   736,
-,   537,   538,   539,   540,   541,   542,   543,   544,   545,
+,   739,   740,   741,   742,   743,   744,   745,   746,   748,
-,   547,   548,   549,   552,   561,   566,   567
+,   750,   751,   752,   753,   754,   755,   756,   757,   758,
+,   760,   761,   762,   763,   764,   765,   766,   767,   768,
+,   770,   771,   772,   773,   774,   777,   782,   803,   808,
+,   810,   812
  };
  #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",
+ {
- "\"&&\"","\"||\"","\"##\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"lt\"","\"gt\"",
+   "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
- "\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"","\"-d\"","\"is\"",
+   "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
- "'<'","'>'","'!'","'#'","'|'","'&'","'~'","'-'","'+'","'*'","'/'","'%'","'\\\\'",
+   "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
- "NEG","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'","'('","')'","'^'",
+   "BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
- "':'","'\\\"'","'\\''","all","methods","one_big_piece","method","control_method",
+   "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
- "maybe_control_strings","control_strings","control_string","maybe_string","code_method",
+   "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
- "maybe_bracketed_strings","bracketed_maybe_strings","maybe_strings","strings",
+   "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
- "maybe_comment","maybe_codes","codes","code","action","get","get_value","get_name_value",
+   "\"false\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'",
- "name_in_curly_rdive","name_without_curly_rdive","name_without_curly_rdive_read",
+   "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", "'['", "']'",
- "name_without_curly_rdive_class","name_without_curly_rdive_code","put","name_expr_wdive",
+   "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'", "':'", "'\"'",
- "name_expr_wdive_root","name_expr_wdive_write","name_expr_wdive_class","construct",
+   "'''", "$accept", "all", "methods", "one_big_piece", "method",
- "construct_square","construct_round","construct_curly","any_constructor_code_value",
+   "control_method", "maybe_control_strings", "control_strings",
- "constructor_code_value","constructor_code","codes__excluding_sole_str_literal",
+   "control_string", "maybe_string", "code_method", "@1",
- "call","call_value","@1","@2","call_name","store_params","store_param","store_square_param",
+   "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
- "store_round_param","store_curly_param","store_code_param_parts","store_expr_param_parts",
+   "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
- "store_curly_param_parts","store_code_param_part","store_expr_param_part","store_curly_param_part",
+   "get", "get_value", "get_name_value", "name_in_curly_rdive",
- "code_param_value","write_expr_value","name_expr_dive_code","name_path","name_step",
+   "name_without_curly_rdive", "name_without_curly_rdive_read",
- "name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",
+   "name_without_curly_rdive_class", "name_without_curly_rdive_code", "put",
- "name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",
+   "name_expr_wdive", "name_expr_wdive_root", "name_expr_wdive_write",
- "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",
+   "name_expr_wdive_class", "construct", "construct_square", "@2", "@3",
- "expr","string_inside_quotes_value","write_string","void_value","empty", NULL
+   "construct_round", "construct_curly", "any_constructor_code_value",
+   "constructor_code_value", "constructor_code",
+   "codes__excluding_sole_str_literal", "call", "call_value", "@4", "@5",
+   "call_name", "store_params", "store_param", "store_square_param", "@6",
+   "@7", "store_round_param", "store_curly_param", "store_code_param_parts",
+   "store_expr_param_parts", "store_curly_param_parts",
+   "store_code_param_part", "store_expr_param_part",
+   "store_curly_param_part", "code_param_value", "name_expr_dive_code",
+   "name_path", "name_step", "name_advance1", "name_advance2",
+   "name_expr_value", "name_expr_subvar_value",
+   "name_expr_with_subvar_value", "name_square_code_value", "@8", "@9",
+   "subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write",
+   "class_prefix", "class_static_prefix", "class_constructor_prefix",
+   "expr_value", "expr", "double_or_STRING", "string_inside_quotes_value",
+   "write_string", "void_value", "true_value", "false_value", "empty", 0
  };
  #endif
- static const short yyr1[] = {     0,
+ # ifdef YYPRINT
-,    56,    57,    57,    58,    59,    59,    60,    61,    61,
+ /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-,    62,    63,    64,    64,    65,    66,    66,    67,    68,
+    token YYLEX-NUM.  */
-,    69,    69,    70,    70,    71,    71,    72,    72,    73,
+ static const unsigned short int yytoknum[] =
-,    74,    74,    74,    75,    76,    77,    77,    78,    79,
+ {
-,    80,    81,    82,    82,    83,    84,    84,    84,    85,
+,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-,    87,    88,    88,    88,    89,    90,    91,    92,    92,
+,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-,    93,    94,    95,    95,    96,    98,    99,    97,   100,
+,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-,   101,   102,   102,   102,   103,   104,   105,   106,   106,
+,   286,   287,   288,    60,    62,   124,    38,    43,    45,
-,   107,   108,   108,   109,   110,   111,   112,   112,   112,
+,    47,    92,    37,   289,   126,    33,    64,    10,    91,
-,   114,   114,   115,   115,   116,   117,   118,   118,   119,
+,    59,    36,   123,   125,    46,    40,    41,    94,    58,
-,   119,   119,   120,   121,   122,   123,   124,   124,   125,
+,    39
-,   126,   127,   128,   129,   130,   130,   130,   130,   130,
-,   130,   130,   130,   130,   130,   130,   130,   130,   130,
-,   130,   130,   130,   130,   130,   130,   130,   130,   130,
-,   130,   130,   130,   130,   130,   130,   130,   130,   130,
-,   130,   130,   130,   131,   132,   133,   134
  };
+ # 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,
+,    62,    63,    63,    64,    64,    65,    66,    66,    67,
-,     1,     1,     1,     1,     2,     2,     1,     3,     1,
+,    68,    69,    69,    70,    71,    71,    73,    72,    74,
-,     1,     2,     1,     2,     3,     1,     1,     1,     1,
+,    75,    76,    76,    77,    77,    78,    78,    79,    79,
-,     2,     1,     1,     1,     3,     3,     3,     1,     1,
+,    80,    81,    81,    82,    82,    82,    83,    84,    85,
-,     1,     1,     1,     2,     1,     0,     0,     6,     1,
+,    86,    87,    87,    88,    89,    90,    90,    91,    92,
-,     2,     1,     1,     1,     3,     3,     3,     1,     3,
+,    92,    93,    94,    95,    96,    96,    96,    98,    99,
-,     3,     1,     3,     1,     1,     1,     1,     1,     1,
+,   100,   101,   102,   102,   102,   103,   104,   105,   105,
-,     1,     2,     1,     2,     2,     1,     1,     2,     1,
+,   108,   109,   107,   110,   111,   111,   112,   112,   112,
-,     1,     1,     2,     2,     3,     1,     1,     2,     2,
+,   115,   113,   116,   117,   118,   118,   119,   119,   120,
-,     1,     2,     2,     1,     1,     1,     1,     3,     3,
+,   121,   122,   123,   124,   124,   124,   125,   125,   126,
-,     2,     2,     2,     2,     2,     2,     2,     2,     3,
+,   127,   128,   129,   129,   130,   130,   130,   130,   131,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   134,   135,   133,   136,   137,   137,   138,   139,   139,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   141,   142,   143,   143,   143,   143,   143,   143,   143,
-,     3,     3,     3,     1,     1,     0,     0
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   143,   143,   143,   144,   145,   146,   147,
+,   149,   150
  };
- static const short yydefact[] = {   158,
+ /* 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,     0,     8,     1,
-,    92,   101,   102,   103,     0,   111,   112,     0,     4,
+,     3,     1,     1,     1,     3,     1,     1,     1,     1,
-,   158,   158,   158,    99,     0,   113,   105,   108,     0,
+,     2,     1,     1,     1,     1,     1,     1,     2,     2,
-,   104,     0,     0,    98,     0,   100,    51,     0,    92,
+,     3,     1,     1,     1,     2,     1,     2,     3,     1,
-,   157,   158,     0,    46,    53,    54,    55,   100,    95,
+,     1,     1,     2,     2,     1,     1,     1,     0,     0,
-,    93,    96,    43,    52,   114,    70,    68,    15,     8,
+,     3,     3,     1,     1,     1,     1,     1,     1,     2,
-,    11,     0,     9,    22,     0,    21,    20,   158,    18,
+,     0,     0,     6,     1,     1,     2,     1,     1,     1,
-,   110,   109,   106,    39,    93,   156,     0,    31,     0,
+,     0,     5,     3,     3,     1,     3,     1,     3,     1,
-,    62,    63,    59,     0,   116,     0,     0,     0,     0,
+,     1,     1,     1,     1,     1,     1,     1,     2,     1,
-,     0,     0,     0,     0,     0,   158,   158,   117,   118,
+,     2,     1,     1,     2,     1,     1,     1,     1,     2,
-,   115,     0,    12,    14,    13,    19,     0,    25,     0,
+,     0,     0,     5,     1,     1,     2,     2,     1,     1,
-,    65,    56,    58,   126,   127,   128,   129,   125,   124,
+,     2,     1,     1,     1,     1,     1,     1,     3,     3,
-,   123,     0,   155,     0,     0,    57,     0,     0,     0,
+,     2,     2,     2,     2,     2,     2,     2,     2,     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,     3,     3,
-,     0,   157,   158,     0,     0,    71,    73,    74,    75,
+,     3,     3,     3,     3,     3,     1,     1,     1,     0,
-,   158,   121,   119,   120,   139,   140,   141,   144,   145,
+,     1,     0
-,   147,   148,   149,   150,   151,   152,   153,   154,   142,
-,   138,   137,   136,   130,   131,   132,   133,   134,   135,
-,    90,     0,    79,    85,    88,    87,     0,    83,     0,
-,    86,    91,    69,    72,    16,    76,   157,   158,    78,
-,    77,    80,    84,    82,     0,     0,     0
  };
- static const short yydefgoto[] = {   246,
+ /* 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,   222,   112,   113,    17,
+ {
-,    49,   133,    88,   186,   187,   188,   189,   190,   223,
+,   168,     0,     0,    71,     0,     3,     2,     4,     7,
-,   228,   224,   231,   229,   225,   232,    37,    64,    39,
+,     6,    29,    30,    33,    34,    37,    35,    36,    70,
-,    41,    65,    43,    44,    45,    62,    58,    59,    66,
+,    28,     0,   105,   111,     0,     0,     0,    38,    40,
-,    48,   233,   132,   155,    19,   226,    20
+,    42,    43,    44,     0,    49,    50,    51,    52,     0,
+,     0,    46,    97,   106,   107,   108,     0,   118,   119,
+,     1,     5,    31,   172,   172,   172,   104,     0,   120,
+,   115,     0,   114,   109,     0,     0,   103,     0,   105,
+,     0,    97,    39,    58,   172,     0,    48,    55,    56,
+,   105,   100,    47,    98,   101,    45,    54,   121,    74,
+,    16,     9,    11,    12,     0,    10,    24,     0,    23,
+,   172,    20,    19,   117,   116,   112,    41,    98,   169,
+,   166,     0,     0,     0,     0,   170,   171,     0,     0,
+,     0,     0,     0,   172,   172,   126,   127,     0,   122,
+,   124,   125,     0,    13,    15,    14,    21,     0,    27,
+,    26,     0,   168,     0,    33,    59,    65,    66,    67,
+,    62,   135,   136,   137,   138,   132,   131,   133,   134,
+,   167,     0,     0,    61,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    80,   172,     0,     0,    75,    77,    78,    79,
+,    17,   113,    69,     0,   130,   128,   129,   150,   151,
+,   149,   155,   156,   157,   158,   145,   146,   159,   160,
+,   162,   163,   164,   165,   153,   154,   148,   147,   140,
+,   141,   142,   144,   143,   169,    93,     0,    89,     0,
+,    92,    73,    76,   172,    60,   168,    96,    81,    85,
+,    94,   172,    84,     0,    83,    18,   169,     0,    90,
+,    86,    82
  };
- static const short yypact[] = {     5,
+ /* YYDEFGOTO[NTERM-NUM]. */
- -32768,    20,    75,-32768,   -34,-32768,-32768,-32768,-32768,-32768,
+ static const short int yydefgoto[] =
-,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ {
-    -27,    31,    18,    27,    97,   102,-32768,-32768,    39,-32768,
+       -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
- -32768,-32768,    91,-32768,-32768,-32768,-32768,   103,-32768,    32,
+,   244,   101,    56,    98,    99,   140,   161,    12,    13,
- -32768,    42,-32768,-32768,-32768,   103,    34,-32768,    97,-32768,
+,    15,   126,    28,    29,    30,    31,    32,    33,    17,
- -32768,    89,    96,    52,-32768,    27,-32768,    56,-32768,    17,
+,    35,    36,    37,    77,    78,   109,   204,    79,    80,
- -32768,-32768,    61,   103,    62,   103,    56,-32768,   102,    62,
+,   247,   148,   149,    18,   127,    50,   133,    90,   195,
- -32768,    36,    18,     4,-32768,-32768,-32768,-32768,    25,-32768,
+,   197,   235,   258,   198,   199,   248,   239,   237,   249,
- -32768,    42,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+,   238,   250,    38,    66,    40,    41,    42,    67,    44,
-,-32768,    74,    78,-32768,    87,    94,-32768,   115,-32768,
+,    46,    62,   142,    64,    60,    61,    68,    48,    49,
- -32768,-32768,-32768,-32768,-32768,    62,    88,    18,    41,   106,
+,   129,   130,   162,    20,   251,   131,   132,    21
- -32768,-32768,-32768,-32768,   105,-32768,     4,     4,     4,     4,
-,     4,     4,     4,    90,     4,    18,    18,-32768,-32768,
-,   277,   104,-32768,-32768,-32768,-32768,   159,-32768,   123,
- -32768,    18,-32768,-32768,   191,   191,   191,   191,   191,   198,
- -32768,-32768,   234,-32768,   112,   113,-32768,     4,     4,     4,
-,     4,     4,     4,     4,     4,     4,     4,     4,     4,
-,     4,     4,     4,     4,     4,     4,     4,     4,     4,
-,     4,    37,    18,     4,    49,-32768,-32768,-32768,-32768,
- -32768,    18,-32768,-32768,-32768,   367,   339,   308,   393,   393,
-,   143,   393,   393,   393,   393,   143,   143,   191,   393,
-,   243,   401,   198,   152,   152,-32768,-32768,-32768,-32768,
-,-32768,    81,-32768,-32768,-32768,-32768,   -28,-32768,    53,
- -32768,-32768,-32768,-32768,-32768,-32768,-32768,    37,    18,-32768,
-,-32768,-32768,-32768,-32768,   170,   171,-32768
  };
- static const short yypgoto[] = {-32768,
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- -32768,-32768,   167,-32768,-32768,-32768,   133,-32768,-32768,-32768,
+    STATE-NUM.  */
-,-32768,-32768,-32768,     3,   -18,    -7,   -71,-32768,     0,
+ #define YYPACT_NINF -107
- -32768,-32768,    -6,-32768,-32768,    51,-32768,-32768,-32768,-32768,
+ static const short int yypact[] =
- -32768,-32768,-32768,-32768,-32768,-32768,   184,-32768,-32768,-32768,
+ {
-,-32768,-32768,-32768,-32768,    71,-32768,-32768,-32768,-32768,
+,  -107,    13,    45,  -107,    28,   -15,  -107,  -107,  -107,
- -32768,-32768,    21,    22,    19,-32768,-32768,   -12,    77,   -20,
+     -107,  -107,    21,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
- -32768,   -32,     9,-32768,-32768,-32768,   211,-32768,   218,   280,
+     -107,  -107,    73,    19,  -107,    50,     6,    44,  -107,  -107,
- -32768,-32768,   210,    38,   172,-32768,   227,    14
+,  -107,  -107,  -107,   -34,  -107,  -107,  -107,  -107,    65,
+     -107,    48,  -107,     5,  -107,  -107,  -107,    65,    24,  -107,
+,  -107,  -107,  -107,    88,   109,    74,  -107,    50,  -107,
+,  -107,    21,  -107,  -107,    86,    65,   101,    65,    76,
+     -107,    44,   101,  -107,  -107,    21,     7,  -107,  -107,  -107,
+     -107,    18,  -107,  -107,     5,  -107,  -107,  -107,  -107,  -107,
+     -107,  -107,  -107,     9,  -107,    94,    99,  -107,    93,   112,
+     -107,   146,  -107,  -107,  -107,  -107,    21,  -107,   101,    29,
+,  -107,     7,     7,     7,     7,  -107,  -107,     7,     7,
+,     7,    52,     7,    21,    21,  -107,  -107,   113,   323,
+     -107,  -107,  -107,    92,  -107,  -107,  -107,  -107,   165,  -107,
+,  -107,   147,   149,    21,    80,  -107,  -107,  -107,  -107,
+     -107,  -107,    96,    96,    96,    96,  -107,  -107,  -107,  -107,
+,  -107,   138,   139,  -107,     7,     7,     7,     7,     7,
+,     7,     7,     7,     7,     7,     7,     7,     7,     7,
+,     7,     7,     7,     7,     7,     7,     7,     7,     7,
+,     7,  -107,    21,     7,    35,  -107,  -107,  -107,  -107,
+     -107,  -107,  -107,    21,   154,  -107,  -107,  -107,   419,   389,
+,   284,   135,   135,   148,   148,   191,   191,   135,   135,
+,   135,   148,   148,    96,   135,   135,   182,   427,   140,
+,  -107,  -107,  -107,  -107,    37,  -107,    31,  -107,   -30,
+     -107,  -107,  -107,  -107,    21,  -107,   108,  -107,   155,  -107,
+     -107,  -107,    21,  -107,     7,  -107,  -107,    37,   161,  -107,
+     -107,  -107,  -107
  };
+ /* YYPGOTO[NTERM-NUM].  */
- #define YYLAST          440
+ static const short int yypgoto[] =
+ {
+     -107,  -107,  -107,  -107,   206,  -107,  -107,  -107,   124,  -107,
- static const short yytable[] = {    15,
+     -107,  -107,  -107,   170,  -107,  -107,  -107,     1,   -58,    -7,
-,    18,    10,    51,    60,    81,     2,   116,     1,    89,
+     -106,  -107,     0,  -107,  -107,    -6,  -107,  -107,   -21,  -107,
-,    42,    18,    68,    52,    53,   239,    80,    63,   240,
+     -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
-,     1,    15,    21,    18,   117,   118,   119,   120,    55,
+     -107,   118,  -107,  -107,  -107,     2,  -107,  -107,  -107,  -107,
-,    81,   121,    85,    70,    55,   122,   123,   124,   107,
+,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,   -17,
-,    71,    87,    80,   -98,     2,    82,  -158,    80,   125,
+      -13,   -16,  -107,   -18,     4,    41,  -107,   -23,     3,  -107,
-,   234,    51,   126,    42,     4,     4,   127,   128,    15,
+     -107,  -107,  -107,  -107,   181,  -107,   183,   239,  -107,  -107,
-,    18,     3,     3,   108,    94,    98,   101,     4,     4,
+,    95,  -107,   123,  -107,   142,  -107,  -107,    64
-,    15,    15,    18,    18,   115,    56,   106,    22,    38,
-,     3,     3,    57,   -64,   -64,    86,     4,     4,   142,
-    -97,   183,    89,    22,    53,   184,    84,   241,   185,    95,
-,    56,    69,   242,   135,    67,    79,    15,   105,    18,
-    -97,   109,   141,   -89,   -89,   136,    84,    23,   139,   -14,
-,    25,    38,    26,   237,   238,    15,    15,    18,    18,
-,   -60,    23,    72,    51,    24,    25,    73,   138,    23,
-,    15,    24,    18,    23,    23,   183,    24,    24,   143,
-,   157,   144,   185,   145,   146,   147,   148,   149,   150,
-,   152,   191,   153,   192,   194,   109,   195,   171,   247,
-,    50,   174,   175,   176,   108,   177,   178,   179,   180,
-,   182,    15,    15,    18,    18,   227,   179,   180,   181,
-,    15,   100,    18,   236,   196,   197,   198,   199,   200,
-,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-,   175,   176,   134,   177,   178,   179,   180,   181,   182,
-,   177,   178,   179,   180,   181,   182,    15,    15,    18,
-,   227,   158,   159,   160,   161,   162,   163,   164,   165,
-,   167,   168,   169,   170,   111,   235,   244,   243,   171,
-,   173,   245,   174,   175,   176,   102,   177,   178,   179,
-,   181,   182,   175,   176,   103,   177,   178,   179,   180,
-,   182,    46,   131,   193,   158,   159,   160,   161,   162,
-,   164,   165,   166,   167,   168,   169,   170,   114,   156,
-,     0,   171,   172,   173,     0,   174,   175,   176,     0,
-,   178,   179,   180,   181,   182,   158,   159,     0,   161,
-,   163,   164,   165,   166,   167,   168,   169,   170,     0,
-,     0,     0,   171,   172,   173,     0,   174,   175,   176,
-,   177,   178,   179,   180,   181,   182,   158,     0,     0,
-,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-,     0,     0,     0,   171,   172,   173,     0,   174,   175,
-,     0,   177,   178,   179,   180,   181,   182,   161,   162,
-,   164,   165,   166,   167,   168,   169,   170,     0,     0,
-,     0,   171,   172,   173,     0,   174,   175,   176,     0,
-,   178,   179,   180,   181,   182,   163,   164,     0,     0,
-,     0,   169,   170,     0,     0,     0,     0,   171,     0,
-,     0,   174,   175,   176,     0,   177,   178,   179,   180,
-,   182,   176,     0,   177,   178,   179,   180,   181,   182
  };
- static const short yycheck[] = {     0,
+ /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-,     0,     0,    11,    23,    38,    41,     4,     4,     4,
+    positive, shift that token.  If negative, reduce the rule which
-,     3,    11,    26,    42,    43,    45,    38,    25,    48,
+    number is the opposite.  If zero, do what YYDEFACT says.
-,     4,    23,     4,    23,    22,    23,    24,    25,     5,
+    If YYTABLE_NINF, syntax error.  */
-,    64,    29,    46,    26,     5,    33,    34,    35,     4,
+ #define YYTABLE_NINF -173
-,     3,    49,    64,     3,    41,    38,    42,    69,    46,
+ static const short int yytable[] =
-,     3,    60,    50,    46,    52,    52,    54,    55,    60,
+ {
-,    60,    46,    46,    72,    52,    53,    54,    52,    52,
+,    11,    19,   145,   106,    53,    43,    39,  -103,    70,
-,    72,    73,    72,    73,    73,    46,    69,     4,     3,
+,   111,    16,    91,    19,    74,    83,    22,     1,    75,
-,    46,    46,    53,    44,    45,    53,    52,    52,   108,
+,   254,    76,    57,    57,     1,    86,   255,    51,    87,
-,    43,     4,     4,    43,    47,    46,    45,    50,     4,
+,    71,     2,   143,   112,   113,   114,   115,   242,   116,
-,    46,    26,    51,    91,     4,     4,   108,    48,   108,
+,   246,    84,    83,    89,   118,   119,    86,    69,    23,
-,   183,    99,    44,    45,    42,    66,    43,     4,    42,
+,    39,   120,   121,    63,    24,    23,  -172,    25,   122,
-,    47,    46,    49,    44,    45,   127,   128,   127,   128,
+     -102,     2,    16,   123,    19,     4,     3,   124,   125,    81,
-,    44,    43,    43,   142,    46,    47,    47,    45,    43,
+,    58,     4,     3,   108,    16,   110,    19,    59,     4,
-,   142,    46,   142,    43,    43,    43,    46,    46,    44,
+,     3,   252,    88,   192,   253,   203,     4,   193,     3,
-,    51,    48,    50,   117,   118,   119,   120,   121,   122,
+,   194,    91,    24,    24,     4,    25,    25,    26,    53,
-,   124,     4,   126,    42,    54,   238,    55,    26,     0,
+,    24,   144,    85,    25,    26,    16,    82,    19,    16,
-,     5,    30,    31,    32,   183,    34,    35,    36,    37,
+,    19,    82,    97,    24,   173,   174,    25,    96,   100,
-,    39,   183,   184,   183,   184,   184,    36,    37,    38,
+,    54,    55,    55,    16,    16,    19,    19,    58,   145,
-,   192,    54,   192,   192,   158,   159,   160,   161,   162,
+      -68,   -68,   184,   185,   186,   187,   188,   189,   190,   191,
-,   164,   165,   166,   167,   168,   169,   170,   171,   172,
+,   192,   136,   137,    16,   193,    19,   -15,   194,   168,
-,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+,   145,   171,   172,   173,   174,  -102,   135,   -95,   -95,
-,    31,    32,    91,    34,    35,    36,    37,    38,    39,
+,   180,   168,   138,   151,   141,   181,   173,   174,   200,
-,    34,    35,    36,    37,    38,    39,   238,   239,   238,
+,   184,   185,   186,   187,   188,   189,   190,   191,   181,
-,   239,     9,    10,    11,    12,    13,    14,    15,    16,
+,   189,   190,   191,   184,   185,   186,   187,   188,   189,
-,    18,    19,    20,    21,    72,   186,   239,   238,    26,
+,   191,   201,    16,   236,    19,    53,   202,   206,   -64,
-,    28,   241,    30,    31,    32,    56,    34,    35,    36,
+,   173,   174,    16,   245,    19,   257,   152,   153,   154,
-,    38,    39,    31,    32,    58,    34,    35,    36,    37,
+,   262,    52,   156,   157,   158,   159,   134,   160,   185,
-,    39,     3,    74,    51,     9,    10,    11,    12,    13,
+,   187,   188,   189,   190,   191,   102,   147,   144,   186,
-,    15,    16,    17,    18,    19,    20,    21,    72,   128,
+,   188,   189,   190,   191,    16,   259,    19,   243,   104,
-     -1,    -1,    26,    27,    28,    -1,    30,    31,    32,    -1,
+,   260,    47,   105,    16,   256,    19,   128,   163,     0,
-,    35,    36,    37,    38,    39,     9,    10,    -1,    12,
+,   150,    16,   236,    19,     0,     0,    16,     0,    19,
-,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
+,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-     -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,    32,
+,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     -1,    34,    35,    36,    37,    38,    39,     9,    -1,    -1,
+,   229,   230,   231,   232,   233,   234,   165,   166,   167,
-,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-     -1,    -1,    -1,    -1,    26,    27,    28,    -1,    30,    31,
+,   179,   180,   173,   174,     0,     0,   181,     0,     0,
-,    -1,    34,    35,    36,    37,    38,    39,    12,    13,
+,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
+,   185,   186,   187,   188,   189,   190,   191,     0,     0,
-     -1,    -1,    26,    27,    28,    -1,    30,    31,    32,    -1,
+,     0,     0,   205,   165,   166,   167,   168,   169,   170,
-,    35,    36,    37,    38,    39,    14,    15,    -1,    -1,
+,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-     -1,    -1,    20,    21,    -1,    -1,    -1,    -1,    26,    -1,
+,     0,     0,     0,   181,     0,     0,   182,   183,   184,
-     -1,    -1,    30,    31,    32,    -1,    34,    35,    36,    37,
+,   186,   187,   188,   189,   190,   191,   165,   166,     0,
-,    39,    32,    -1,    34,    35,    36,    37,    38,    39
+,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+,   179,   180,     0,     0,     0,     0,   181,     0,     0,
+,   183,   184,   185,   186,   187,   188,   189,   190,   191,
+,     0,     0,   168,   169,   170,   171,   172,   173,   174,
+,   176,   177,   178,   179,   180,     0,     0,     0,     0,
+,     0,     0,   182,   183,   184,   185,   186,   187,   188,
+,   190,   191,   168,   169,   170,   171,   172,   173,   174,
+,   176,   177,   178,   179,   180,   173,   174,     0,     0,
+,     0,     0,   182,   183,   184,   185,   186,   187,   188,
+,   190,   191,     0,     0,   186,   187,   188,   189,   190,
  };
- #define YYPURE 1
- /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
- #line 3 "/usr/share/bison.simple"
- /* This file comes from bison-1.28.  */
- /* Skeleton output parser for bison,
-    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2, or (at your option)
-    any later version.
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place - Suite 330,
-    Boston, MA 02111-1307, USA.  */
- /* As a special exception, when this file is copied by Bison into a
+ static const short int yycheck[] =
-    Bison output file, you may use that output file without restriction.
+ {
-    This special exception was added by the Free Software Foundation
+,     0,     0,   109,    62,    12,     3,     3,     3,    27,
-    in version 1.24 of Bison.  */
+,     4,    12,     4,    12,    49,    39,     4,     4,    53,
+,    51,    56,     5,     5,     4,    47,    57,     0,    47,
+,    27,    47,     4,    27,    28,    29,    30,     3,    32,
+,     4,    39,    66,    50,    38,    39,    68,     4,     4,
+,    47,    45,    46,     4,    49,     4,    48,    52,    52,
+,    47,    62,    56,    62,    58,    52,    60,    61,     4,
+,    52,    58,    52,    71,    75,    75,    75,    59,    58,
+,    52,    51,    59,    49,    54,   144,    58,    53,    52,
+,    56,     4,    49,    49,    58,    52,    52,    53,   106,
+,    49,   109,    55,    52,    53,   106,    66,   106,   109,
+,   109,    71,     4,    49,    19,    20,    52,    54,    55,
+,    48,    49,    49,   124,   125,   124,   125,    52,   235,
+,    51,    36,    37,    38,    39,    40,    41,    42,    43,
+,    49,    48,    50,   144,    53,   144,    48,    56,    14,
+,   257,    17,    18,    19,    20,    55,    93,    50,    51,
+,    26,    14,    51,    54,   101,    31,    19,    20,     4,
+,    36,    37,    38,    39,    40,    41,    42,    43,    31,
+,    41,    42,    43,    36,    37,    38,    39,    40,    41,
+,    43,    48,   193,   193,   193,   203,    50,    60,    50,
+,    19,    20,   203,    50,   203,    51,   112,   113,   114,
+,    50,     6,   118,   119,   120,   121,    93,   123,    37,
+,    39,    40,    41,    42,    43,    56,   109,   235,    38,
+,    40,    41,    42,    43,   235,   252,   235,   195,    58,
+,   254,     3,    60,   244,   244,   244,    76,   125,    -1,
+,   109,   252,   252,   252,    -1,    -1,   257,    -1,   257,
+,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+,   176,   177,   178,   179,   180,   181,   182,   183,   184,
+,   186,   187,   188,   189,   190,   191,    11,    12,    13,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    19,    20,    -1,    -1,    31,    -1,    -1,
+,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+,    37,    38,    39,    40,    41,    42,    43,    -1,    -1,
+       -1,    -1,    -1,    57,    11,    12,    13,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+       -1,    -1,    -1,    -1,    31,    -1,    -1,    34,    35,    36,
+,    38,    39,    40,    41,    42,    43,    11,    12,    -1,
+,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,    25,    26,    -1,    -1,    -1,    -1,    31,    -1,    -1,
+,    35,    36,    37,    38,    39,    40,    41,    42,    43,
+,    -1,    -1,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    -1,    -1,    -1,    -1,
+,    -1,    -1,    34,    35,    36,    37,    38,    39,    40,
+,    42,    43,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    19,    20,    -1,    -1,
+,    -1,    -1,    34,    35,    36,    37,    38,    39,    40,
+,    42,    43,    -1,    -1,    38,    39,    40,    41,    42,
+ };
- /* 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,    47,    52,    58,    63,    64,    65,    66,    67,
- #ifndef YYSTACK_USE_ALLOCA
+,    79,    80,    81,    82,    83,    84,    91,   106,   107,
- #ifdef alloca
+,   150,     4,     4,    49,    52,    53,    55,    85,    86,
- #define YYSTACK_USE_ALLOCA
+,    88,    89,    90,    92,    93,    94,    95,   125,   126,
- #else /* alloca not defined */
+,   128,   129,   130,   131,   132,   133,   139,   140,   141,
- #ifdef __GNUC__
+,     0,    66,    81,    48,    49,    75,     5,    52,    59,
- #define YYSTACK_USE_ALLOCA
+,   138,   134,     4,   136,    87,   126,   130,   139,     4,
- #define alloca __builtin_alloca
+,   126,   130,     3,    49,    53,    56,    96,    97,   100,
- #else /* not GNU C.  */
+,     4,   127,   129,   130,    55,    90,   125,    59,    87,
- #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+,     4,    68,    69,    70,    71,   150,     4,    76,    77,
- #define YYSTACK_USE_ALLOCA
+,    74,    75,   150,   136,   138,    80,    54,   130,    98,
- #include <alloca.h>
+,     4,    27,    28,    29,    30,    32,    33,    38,    39,
- #else /* not sparc */
+,    46,    52,    56,    60,    61,    84,   107,   142,   143,
- /* We think this test detects Watcom and Microsoft C.  */
+,   148,   149,   109,    70,   150,    48,    50,    51,     4,
- /* This used to test MSDOS, but that is a bad idea
+,   150,   135,     4,    81,    82,   102,   103,   104,   105,
-    since that symbol is in the user namespace.  */
+,    54,   143,   143,   143,   143,   143,   143,   143,   143,
- #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+,    79,   145,   145,    57,    11,    12,    13,    14,    15,
- #if 0 /* No need for malloc.h, which pollutes the namespace;
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-          instead, just don't use alloca.  */
+,    31,    34,    35,    36,    37,    38,    39,    40,    41,
- #include <malloc.h>
+,    43,    49,    53,    56,   111,   112,   113,   116,   117,
- #endif
+,    48,    50,    80,    99,    57,    60,    61,   143,   143,
- #else /* not MSDOS, or __TURBOC__ */
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
- #if defined(_AIX)
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
- /* I don't know what this was needed for, but it pollutes the namespace.
+,   143,   143,   143,   143,   114,    79,   120,   123,   119,
-    So I turned it off.   rms, 2 May 1997.  */
+,   142,     3,   112,    73,    50,     4,   103,   118,   121,
- /* #include <malloc.h>  */
+,   147,    51,    54,    51,    57,    79,    51,   115,   123,
-  #pragma alloca
+,   121,    50
- #define YYSTACK_USE_ALLOCA
+ };
- #else /* not MSDOS, or __TURBOC__, or _AIX */
- #if 0
- #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
-                  and on HPUX 10.  Eventually we can turn this on.  */
- #define YYSTACK_USE_ALLOCA
- #define alloca __builtin_alloca
- #endif /* __hpux */
- #endif
- #endif /* not _AIX */
- #endif /* not MSDOS, or __TURBOC__ */
- #endif /* not sparc */
- #endif /* not GNU C */
- #endif /* alloca not defined */
- #endif /* YYSTACK_USE_ALLOCA not defined */
- #ifdef YYSTACK_USE_ALLOCA
+ #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
- #define YYSTACK_ALLOC alloca
+ # define YYSIZE_T __SIZE_TYPE__
- #else
+ #endif
- #define YYSTACK_ALLOC malloc
+ #if ! defined (YYSIZE_T) && defined (size_t)
+ # define YYSIZE_T size_t
+ #endif
+ #if ! defined (YYSIZE_T)
+ # if defined (__STDC__) || defined (__cplusplus)
+ #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+ #  define YYSIZE_T size_t
+ # endif
+ #endif
+ #if ! defined (YYSIZE_T)
+ # define YYSIZE_T unsigned int
  #endif
- /* Note: there must be only one dollar sign in this file.
-    It is replaced by the list of actions, each action
-    as one case of the switch.  */
  #define yyerrok         (yyerrstatus = 0)
  #define yyclearin       (yychar = YYEMPTY)
- #define YYEMPTY         -2
+ #define YYEMPTY         (-2)
  #define YYEOF           0
  #define YYACCEPT        goto yyacceptlab
  #define YYABORT         goto yyabortlab
- #define YYERROR         goto yyerrlab1
+ #define YYERROR         goto yyerrorlab
- /* Like YYERROR except do call yyerror.
-    This remains here temporarily to ease the
-    transition to the new meaning of YYERROR, for GCC.
+ /* Like YYERROR except do call yyerror.  This remains here temporarily
+    to ease the transition to the new meaning of YYERROR, for GCC.
     Once GCC version 2 has supplanted version 1, this can go.  */
  #define YYFAIL          goto yyerrlab
  #define YYRECOVERING()  (!!yyerrstatus)
- #define YYBACKUP(token, value) \
+ #define YYBACKUP(Token, Value)                                  \
  do                                                              \
    if (yychar == YYEMPTY && yylen == 1)                          \
-     { yychar = (token), yylval = (value);                       \
+     {                                                           \
-       yychar1 = YYTRANSLATE (yychar);                           \
+       yychar = (Token);                                         \
+       yylval = (Value);                                         \
+       yytoken = YYTRANSLATE (yychar);                           \
        YYPOPSTACK;                                               \
        goto yybackup;                                            \
      }                                                           \
    else                                                          \
-     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
+     {                                                           \
+       yyerror ("syntax error: cannot back up");\
+       YYERROR;                                                  \
+     }                                                           \
  while (0)
  #define YYTERROR        1
  #define YYERRCODE       256
- #ifndef YYPURE
+ /* 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 */
  #endif
- /* If nonreentrant, generate the variables here */
+ /* Enable debugging if requested.  */
+ #if YYDEBUG
- #ifndef YYPURE
+ # ifndef YYFPRINTF
+ #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+ #  define YYFPRINTF fprintf
+ # endif
+ # define YYDPRINTF(Args)                        \
+ do {                                            \
+   if (yydebug)                                  \
+     YYFPRINTF Args;                             \
+ } while (0)
+ # define YYDSYMPRINT(Args)                      \
+ do {                                            \
+   if (yydebug)                                  \
+     yysymprint Args;                            \
+ } while (0)
+ # define YYDSYMPRINTF(Title, Token, Value, Location)            \
+ do {                                                            \
+   if (yydebug)                                                  \
+     {                                                           \
+       YYFPRINTF (stderr, "%s ", Title);                         \
+       yysymprint (stderr,                                       \
+                   Token, Value);        \
+       YYFPRINTF (stderr, "\n");                                 \
+     }                                                           \
+ } while (0)
- int     yychar;                 /*  the lookahead symbol                */
+ /*------------------------------------------------------------------.
- YYSTYPE yylval;                 /*  the semantic value of the           */
+ | yy_stack_print -- Print the state stack from its BOTTOM up to its |
-                                 /*  lookahead symbol                    */
+ | TOP (included).                                                   |
+ `------------------------------------------------------------------*/
- #ifdef YYLSP_NEEDED
+ #if defined (__STDC__) || defined (__cplusplus)
- YYLTYPE yylloc;                 /*  location data for the lookahead     */
+ static void
-                                 /*  symbol                              */
+ yy_stack_print (short int *bottom, short int *top)
+ #else
+ static void
+ yy_stack_print (bottom, top)
+     short int *bottom;
+     short int *top;
  #endif
+ {
+   YYFPRINTF (stderr, "Stack now");
+   for (/* Nothing. */; bottom <= top; ++bottom)
+     YYFPRINTF (stderr, " %d", *bottom);
+   YYFPRINTF (stderr, "\n");
+ }
+ # define YY_STACK_PRINT(Bottom, Top)                            \
+ do {                                                            \
+   if (yydebug)                                                  \
+     yy_stack_print ((Bottom), (Top));                           \
+ } while (0)
- int yynerrs;                    /*  number of parse errors so far       */
- #endif  /* not YYPURE */
- #if YYDEBUG != 0
+ /*------------------------------------------------.
- int yydebug;                    /*  nonzero means print parse trace     */
+ | Report that the YYRULE is going to be reduced.  |
- /* Since this is uninitialized, it does not stop multiple parsers
+ `------------------------------------------------*/
-    from coexisting.  */
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yy_reduce_print (int yyrule)
+ #else
+ static void
+ yy_reduce_print (yyrule)
+     int yyrule;
  #endif
+ {
+   int yyi;
+   unsigned int yylno = yyrline[yyrule];
+   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+              yyrule - 1, yylno);
+   /* Print the symbols being reduced, and their result.  */
+   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
+   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+ }
- /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
+ # define YY_REDUCE_PRINT(Rule)          \
+ do {                                    \
+   if (yydebug)                          \
+     yy_reduce_print (Rule);             \
+ } while (0)
+ /* Nonzero means print parse trace.  It is left uninitialized so that
+    multiple parsers can coexist.  */
+ int yydebug;
+ #else /* !YYDEBUG */
+ # define YYDPRINTF(Args)
+ # define YYDSYMPRINT(Args)
+ # define YYDSYMPRINTF(Title, Token, Value, Location)
+ # define YY_STACK_PRINT(Bottom, Top)
+ # define YY_REDUCE_PRINT(Rule)
+ #endif /* !YYDEBUG */
+ /* YYINITDEPTH -- initial size of the parser's stacks.  */
  #ifndef YYINITDEPTH
- #define YYINITDEPTH 200
+ # define YYINITDEPTH 200
  #endif
- /*  YYMAXDEPTH is the maximum size the stacks can grow to
+ /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-     (effective only if the built-in stack extension method is used).  */
+    if the built-in stack extension method is used).
+    Do not make this value too large; the results are undefined if
+    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+    evaluated with infinite-precision integer arithmetic.  */
- #if YYMAXDEPTH == 0
+ #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
- #undef YYMAXDEPTH
+ # undef YYMAXDEPTH
  #endif
  #ifndef YYMAXDEPTH
- #define YYMAXDEPTH 10000
+ # define YYMAXDEPTH 10000
  #endif
- /* Define __yy_memcpy.  Note that the size argument
-    should be passed with type unsigned int, because that is what the non-GCC
-    definitions require.  With GCC, __builtin_memcpy takes an arg
-    of type size_t, but it can handle unsigned int.  */
- #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
- #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
- #else                           /* not GNU C or C++ */
- #ifndef __cplusplus
- /* This is the most reliable way to avoid incompatibilities
+ #if YYERROR_VERBOSE
-    in available built-in functions on various systems.  */
- static void
+ # ifndef yystrlen
- __yy_memcpy (to, from, count)
+ #  if defined (__GLIBC__) && defined (_STRING_H)
-      char *to;
+ #   define yystrlen strlen
-      char *from;
+ #  else
-      unsigned int count;
+ /* Return the length of YYSTR.  */
- {
+ static YYSIZE_T
-   register char *f = from;
+ #   if defined (__STDC__) || defined (__cplusplus)
-   register char *t = to;
+ yystrlen (const char *yystr)
-   register int i = count;
+ #   else
+ yystrlen (yystr)
+      const char *yystr;
+ #   endif
+ {
+   register const char *yys = yystr;
+   while (*yys++ != '\0')
+     continue;
+   return yys - yystr - 1;
+ }
+ #  endif
+ # endif
+ # ifndef yystpcpy
+ #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+ #   define yystpcpy stpcpy
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+ static char *
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystpcpy (char *yydest, const char *yysrc)
+ #   else
+ yystpcpy (yydest, yysrc)
+      char *yydest;
+      const char *yysrc;
+ #   endif
+ {
+   register char *yyd = yydest;
+   register const char *yys = yysrc;
+   while ((*yyd++ = *yys++) != '\0')
+     continue;
-   while (i-- > 0)
+   return yyd - 1;
-     *t++ = *f++;
  }
+ #  endif
+ # endif
+ #endif /* !YYERROR_VERBOSE */
- #else /* __cplusplus */
+ #if YYDEBUG
+ /*--------------------------------.
+ | Print this symbol on YYOUTPUT.  |
+ `--------------------------------*/
- /* This is the most reliable way to avoid incompatibilities
+ #if defined (__STDC__) || defined (__cplusplus)
-    in available built-in functions on various systems.  */
+ static void
+ yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+ #else
  static void
- __yy_memcpy (char *to, char *from, unsigned int count)
+ yysymprint (yyoutput, yytype, yyvaluep)
+     FILE *yyoutput;
+     int yytype;
+     YYSTYPE *yyvaluep;
+ #endif
  {
-   register char *t = to;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *f = from;
+   (void) yyvaluep;
-   register int i = count;
-   while (i-- > 0)
+   if (yytype < YYNTOKENS)
-     *t++ = *f++;
+     {
+       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ # ifdef YYPRINT
+       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+ # endif
+     }
+   else
+     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+   YYFPRINTF (yyoutput, ")");
  }
+ #endif /* ! YYDEBUG */
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yydestruct (int yytype, YYSTYPE *yyvaluep)
+ #else
+ static void
+ yydestruct (yytype, yyvaluep)
+     int yytype;
+     YYSTYPE *yyvaluep;
  #endif
- #endif
+ {
+   /* Pacify ``unused variable'' warnings.  */
+   (void) yyvaluep;
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+ }
- #line 217 "/usr/share/bison.simple"
- /* The user can define YYPARSE_PARAM as the name of an argument to be passed
+ /* Prevent warnings from -Wmissing-prototypes.  */
-    into yyparse.  The argument should have type void *.
-    It should actually point to an object.
-    Grammar actions can access the variable by casting it
-    to the proper pointer type.  */
  #ifdef YYPARSE_PARAM
- #ifdef __cplusplus
+ # if defined (__STDC__) || defined (__cplusplus)
- #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+ int yyparse (void *YYPARSE_PARAM);
- #define YYPARSE_PARAM_DECL
+ # else
- #else /* not __cplusplus */
+ int yyparse ();
- #define YYPARSE_PARAM_ARG YYPARSE_PARAM
+ # endif
- #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+ #else /* ! YYPARSE_PARAM */
- #endif /* not __cplusplus */
+ #if defined (__STDC__) || defined (__cplusplus)
- #else /* not YYPARSE_PARAM */
+ int yyparse (void);
- #define YYPARSE_PARAM_ARG
+ #else
- #define YYPARSE_PARAM_DECL
+ int yyparse ();
- #endif /* not YYPARSE_PARAM */
+ #endif
+ #endif /* ! YYPARSE_PARAM */
+ /*----------.
+ | yyparse.  |
+ `----------*/
- /* Prevent warning if -Wstrict-prototypes.  */
- #ifdef __GNUC__
  #ifdef YYPARSE_PARAM
- int yyparse (void *);
+ # if defined (__STDC__) || defined (__cplusplus)
+ int yyparse (void *YYPARSE_PARAM)
+ # else
+ int yyparse (YYPARSE_PARAM)
+   void *YYPARSE_PARAM;
+ # endif
+ #else /* ! YYPARSE_PARAM */
+ #if defined (__STDC__) || defined (__cplusplus)
+ int
+ yyparse (void)
  #else
- int yyparse (void);
+ int
+ yyparse ()
  #endif
  #endif
- int
- yyparse(YYPARSE_PARAM_ARG)
-      YYPARSE_PARAM_DECL
  {
+   /* The lookahead symbol.  */
+ int yychar;
+ /* The semantic value of the lookahead symbol.  */
+ YYSTYPE yylval;
+ /* Number of syntax errors so far.  */
+ int yynerrs;
    register int yystate;
    register int yyn;
-   register short *yyssp;
+   int yyresult;
+   /* Number of tokens to shift before error messages enabled.  */
+   int yyerrstatus;
+   /* Lookahead token as an internal (translated) token number.  */
+   int yytoken = 0;
+   /* Three stacks and their tools:
+      `yyss': related to states,
+      `yyvs': related to semantic values,
+      `yyls': related to locations.
+      Refer to the stacks thru separate pointers, to allow yyoverflow
+      to reallocate them elsewhere.  */
+   /* The state stack.  */
+   short int yyssa[YYINITDEPTH];
+   short int *yyss = yyssa;
+   register short int *yyssp;
+   /* The semantic value stack.  */
+   YYSTYPE yyvsa[YYINITDEPTH];
+   YYSTYPE *yyvs = yyvsa;
    register YYSTYPE *yyvsp;
-   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
-   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
-   short yyssa[YYINITDEPTH];     /*  the state stack                     */
-   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
-   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
-   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
-   YYLTYPE *yyls = yylsa;
-   YYLTYPE *yylsp;
- #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
- #else
  #define YYPOPSTACK   (yyvsp--, yyssp--)
- #endif
-   int yystacksize = YYINITDEPTH;
+   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 772  yyparse(YYPARSE_PARAM_ARG)
+ Line 1238  yyparse(YYPARSE_PARAM_ARG)
       so that they stay on the same level as the state stack.
       The wasted elements are never initialized.  */
-   yyssp = yyss - 1;
+   yyssp = yyss;
    yyvsp = yyvs;
- #ifdef YYLSP_NEEDED
-   yylsp = yyls;
- #endif
- /* Push a new state, which is found in  yystate  .  */
- /* In all cases, when you get here, the value and location stacks
-    have just been pushed. so pushing a state here evens the stacks.  */
- yynewstate:
-   *++yyssp = yystate;
+   goto yysetstate;
-   if (yyssp >= yyss + yystacksize - 1)
+ /*------------------------------------------------------------.
-     {
+ | yynewstate -- Push a new state, which is found in yystate.  |
-       /* Give user a chance to reallocate the stack */
+ `------------------------------------------------------------*/
-       /* Use copies of these so that the &'s don't force the real ones into memory. */
+  yynewstate:
-       YYSTYPE *yyvs1 = yyvs;
+   /* In all cases, when you get here, the value and location stacks
-       short *yyss1 = yyss;
+      have just been pushed. so pushing a state here evens the stacks.
- #ifdef YYLSP_NEEDED
+      */
-       YYLTYPE *yyls1 = yyls;
+   yyssp++;
- #endif
+  yysetstate:
+   *yyssp = yystate;
+   if (yyss + yystacksize - 1 <= yyssp)
+     {
        /* Get the current used size of the three stacks, in elements.  */
-       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 int *yyss1 = yyss;
-                  &yyss1, size * sizeof (*yyssp),
-                  &yyvs1, size * sizeof (*yyvsp),
-                  &yyls1, size * sizeof (*yylsp),
+         /* Each stack pointer address is followed by the size of the
-                  &yystacksize);
+            data in use in that stack, in bytes.  This used to be a
- #else
+            conditional around just the two extra args, but that might
-       yyoverflow("parser stack overflow",
+            be undefined if yyoverflow is a macro.  */
-                  &yyss1, size * sizeof (*yyssp),
+         yyoverflow ("parser stack overflow",
-                  &yyvs1, size * sizeof (*yyvsp),
+                     &yyss1, yysize * sizeof (*yyssp),
-                  &yystacksize);
+                     &yyvs1, yysize * sizeof (*yyvsp),
- #endif
+                     &yystacksize);
-       yyss = yyss1; yyvs = yyvs1;
- #ifdef YYLSP_NEEDED
+         yyss = yyss1;
-       yyls = yyls1;
+         yyvs = yyvs1;
- #endif
+       }
  #else /* no yyoverflow */
+ # ifndef YYSTACK_RELOCATE
+       goto yyoverflowlab;
+ # else
        /* Extend the stack our own way.  */
-       if (yystacksize >= YYMAXDEPTH)
+       if (YYMAXDEPTH <= yystacksize)
-         {
+         goto yyoverflowlab;
-           yyerror("parser stack overflow");
-           if (yyfree_stacks)
-             {
-               free (yyss);
-               free (yyvs);
- #ifdef YYLSP_NEEDED
-               free (yyls);
- #endif
-             }
-           return 2;
-         }
        yystacksize *= 2;
-       if (yystacksize > YYMAXDEPTH)
+       if (YYMAXDEPTH < yystacksize)
          yystacksize = YYMAXDEPTH;
- #ifndef YYSTACK_USE_ALLOCA
-       yyfree_stacks = 1;
+       {
- #endif
+         short int *yyss1 = yyss;
-       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
+         union yyalloc *yyptr =
-       __yy_memcpy ((char *)yyss, (char *)yyss1,
+           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
-                    size * (unsigned int) sizeof (*yyssp));
+         if (! yyptr)
-       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
+           goto yyoverflowlab;
-       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
+         YYSTACK_RELOCATE (yyss);
-                    size * (unsigned int) sizeof (*yyvsp));
+         YYSTACK_RELOCATE (yyvs);
- #ifdef YYLSP_NEEDED
-       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
+ #  undef YYSTACK_RELOCATE
-       __yy_memcpy ((char *)yyls, (char *)yyls1,
+         if (yyss1 != yyssa)
-                    size * (unsigned int) sizeof (*yylsp));
+           YYSTACK_FREE (yyss1);
- #endif
+       }
+ # endif
  #endif /* no yyoverflow */
-       yyssp = yyss + size - 1;
+       yyssp = yyss + yysize - 1;
-       yyvsp = yyvs + size - 1;
+       yyvsp = yyvs + yysize - 1;
- #ifdef YYLSP_NEEDED
-       yylsp = yyls + size - 1;
- #endif
- #if YYDEBUG != 0
-       if (yydebug)
-         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
- #endif
-       if (yyssp >= yyss + yystacksize - 1)
+       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                   (unsigned long int) yystacksize));
+       if (yyss + yystacksize - 1 <= yyssp)
          YYABORT;
      }
- #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 884  yynewstate:
+ Line 1337  yynewstate:
    /* First try to decide what to do without reference to lookahead token.  */
    yyn = yypact[yystate];
-   if (yyn == YYFLAG)
+   if (yyn == YYPACT_NINF)
      goto yydefault;
    /* Not known => get a lookahead token if don't already have one.  */
-   /* yychar is either YYEMPTY or YYEOF
+   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-      or a valid token in external form.  */
    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 */
+   if (yychar <= YYEOF)
-   if (yychar <= 0)              /* This means end of input. */
      {
-       yychar1 = 0;
+       yychar = yytoken = YYEOF;
-       yychar = YYEOF;           /* Don't call YYLEX any more */
+       YYDPRINTF ((stderr, "Now at end of input.\n"));
- #if YYDEBUG != 0
-       if (yydebug)
-         fprintf(stderr, "Now at end of input.\n");
- #endif
      }
    else
      {
-       yychar1 = YYTRANSLATE(yychar);
+       yytoken = YYTRANSLATE (yychar);
+       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
- #if YYDEBUG != 0
-       if (yydebug)
-         {
-           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-           /* Give the individual parser a way to print the precise meaning
-              of a token, for further debugging info.  */
- #ifdef YYPRINT
-           YYPRINT (stderr, yychar, yylval);
- #endif
-           fprintf (stderr, ")\n");
-         }
- #endif
      }
-   yyn += yychar1;
+   /* If the proper action on seeing token YYTOKEN is to reduce or to
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+      detect an error, take that action.  */
+   yyn += yytoken;
+   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
      goto yydefault;
    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 %s, ", yytname[yytoken]));
- #if YYDEBUG != 0
-   if (yydebug)
-     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
- #endif
    /* Discard the token being shifted unless it is eof.  */
    if (yychar != YYEOF)
      yychar = YYEMPTY;
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
-   /* count tokens shifted since error; after three, turn off error status.  */
-   if (yyerrstatus) yyerrstatus--;
+   /* Count tokens shifted since error; after three, turn off error
+      status.  */
+   if (yyerrstatus)
+     yyerrstatus--;
    yystate = yyn;
    goto yynewstate;
- /* Do the default action for the current state.  */
- yydefault:
+ /*-----------------------------------------------------------.
+ | yydefault -- do the default action for the current state.  |
+ `-----------------------------------------------------------*/
+ yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
      goto yyerrlab;
+   goto yyreduce;
- /* Do a reduction.  yyn is the number of a rule to reduce with.  */
+ /*-----------------------------.
+ | yyreduce -- Do a reduction.  |
+ `-----------------------------*/
  yyreduce:
+   /* yyn is the number of a rule to reduce with.  */
    yylen = yyr2[yyn];
-   if (yylen > 0)
-     yyval = yyvsp[1-yylen]; /* implement default value of the action */
- #if YYDEBUG != 0
-   if (yydebug)
-     {
-       int i;
-       fprintf (stderr, "Reducing via rule %d (line %d), ",
+   /* If YYLEN is nonzero, implement the default value of the action:
-                yyn, yyrline[yyn]);
+      `$$ = $1'.
-       /* Print the symbols being reduced, and their result.  */
+      Otherwise, the following line sets YYVAL to garbage.
-       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+      This behavior is undocumented and Bison
-         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      users should not rely upon it.  Assigning to YYVAL
-       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+      unconditionally makes the parser a bit smaller, and it avoids a
-     }
+      GCC warning that YYVAL may be used uninitialized.  */
- #endif
+   yyval = yyvsp[1-yylen];
-   switch (yyn) {
+   YY_REDUCE_PRINT (yyn);
+   switch (yyn)
- case 1:
+     {
- #line 108 "compile.y"
+         case 2:
- {
+ #line 132 "compile.y"
-         Method& method=*NEW Method(POOL,
+     {
-                 PC.request->main_method_name,
+         Method* method=new Method(Method::CT_ANY,
-                 Method::CT_ANY,
 , 0, /*min, max numbered_params_count*/
 /*param_names*/, 0/*local_names*/,
                  yyvsp[0]/*parser_code*/, 0/*native_code*/);
-         PC.cclass->add_method(PC.request->main_method_name, method);
+         PC.cclass->set_method(PC.alias_method(main_method_name), method);
- ;
+ ;}
-     break;}
+     break;
- case 8:
- #line 125 "compile.y"
+   case 9:
- {
+ #line 147 "compile.y"
-         const String& command=*LA2S(yyvsp[-2]);
+     {
+         const String& command=*LA2S(*yyvsp[-2]);
          YYSTYPE strings_code=yyvsp[0];
-         if(strings_code->size()<1*2) {
+         if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
                  strcpy(PC.error, "@");
                  strcat(PC.error, command.cstr());
                  strcat(PC.error, " is empty");
                  YYERROR;
          }
          if(command==CLASS_NAME) {
-                 if(PC.cclass->base()) { // already changed from default?
+                 if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
-                         strcpy(PC.error, "class already have a name '");
-                         strncat(PC.error, PC.cclass->name().cstr(), 100);
-                         strcat(PC.error, "'");
-                         YYERROR;
-                 }
-                 if(strings_code->size()==1*2) {
                          // new class' name
-                         const String *name=LA2S(strings_code);
+                         const String& name=*LA2S(*strings_code);
                          // creating the class
-                         PC.cclass=NEW VClass(POOL);
+                         VStateless_class* cclass=new VClass;
-                         PC.cclass->set_name(*name);
+                         PC.cclass_new=cclass;
-                         // append to request's classes
+                         PC.cclass_new->set_name(name);
-                         PC.request->classes().put(*name, PC.cclass);
                  } else {
-                         strcpy(PC.error, "@"CLASS_NAME" must contain sole name");
+                         strcpy(PC.error, "@"CLASS_NAME" must contain only one line with class name (contains more then one)");
                          YYERROR;
                  }
          } else if(command==USE_CONTROL_METHOD_NAME) {
-                 for(int i=0; i<strings_code->size(); i+=2)
+                 for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE)
-                         PC.request->use_file(*LA2S(strings_code, i));
+                         PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i));
          } else if(command==BASE_NAME) {
-                 if(PC.cclass->base()) { // already changed from default?
+                 if(PC.append){
+                         strcpy(PC.error, "can't set base while appending methods to class '");
+                         strncat(PC.error, PC.cclass->name().cstr(), MAX_STRING/2);
+                         strcat(PC.error, "'");
+                         YYERROR;
+                 }
+                 PC.class_add();
+                 if(PC.cclass->base_class()) { // already changed from default?
                          strcpy(PC.error, "class already have a base '");
-                         strncat(PC.error, PC.cclass->base()->name().cstr(), 100);
+                         strncat(PC.error, PC.cclass->base_class()->name().cstr(), MAX_STRING/2);
                          strcat(PC.error, "'");
                          YYERROR;
                  }
-                 if(strings_code->size()==1*2) {
+                 if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
-                         const String& base_name=*LA2S(strings_code);
+                         const String& base_name=*LA2S(*strings_code);
-                         VClass *base=static_cast<VClass *>(
+                         if(Value* base_class_value=PC.request.get_class(base_name)) {
-                                 PC.request->classes().get(base_name));
+                                 // @CLASS == @BASE sanity check
-                         if(!base) {
+                                 if(VStateless_class *base_class=base_class_value->get_class()) {
+                                         if(PC.cclass==base_class) {
+                                                 strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
+                                                 YYERROR;
+                                         }
+                                         PC.cclass->get_class()->set_base(base_class);
+                                 } else { // they asked to derive from a class without methods ['env' & co]
+                                         strcpy(PC.error, base_name.cstr());
+                                         strcat(PC.error, ": you can not derive from this class in @"BASE_NAME);
+                                         YYERROR;
+                                 }
+                         } else {
                                  strcpy(PC.error, base_name.cstr());
                                  strcat(PC.error, ": undefined class in @"BASE_NAME);
                                  YYERROR;
                          }
-                         // @CLASS == @BASE sanity check
-                         if(PC.cclass==base) {
-                                 strcpy(PC.error, "@"CLASS_NAME" equals @"BASE_NAME);
-                                 YYERROR;
-                         }
-                         PC.cclass->set_base(*base);
                  } else {
                          strcpy(PC.error, "@"BASE_NAME" must contain sole name");
                          YYERROR;
                  }
+         } else if(command==OPTIONS_CONTROL_METHOD_NAME) {
+                 for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE) {
+                         const String& option=*LA2S(*strings_code, i);
+                         if(option==OPTION_ALL_VARS_LOCAL_NAME){
+                                 PC.set_all_vars_local();
+                         } else if(option==OPTION_PARTIAL_CLASS){
+                                 if(PC.cclass_new){
+                                         if(VStateless_class* existed=PC.get_existed_class(PC.cclass_new)){
+                                                 if(!PC.reuse_existed_class(existed)){
+                                                         strcpy(PC.error, "can't append methods to '");
+                                                         strncat(PC.error, PC.cclass_new->name().cstr(), MAX_STRING/2);
+                                                         strcat(PC.error, "' - the class wasn't marked as partial");
+                                                         YYERROR;
+                                                 }
+                                         } else {
+                                                 // mark new class as partial. we can add methods to it later.
+                                                 PC.cclass_new->set_partial();
+                                         }
+                                 } else {
+                                         strcpy(PC.error, "'"OPTION_PARTIAL_CLASS"' option should be used straight after @"CLASS_NAME);
+                                         YYERROR;
+                                 }
+                         } else {
+                                 strcpy(PC.error, "'");
+                                 strncat(PC.error, option.cstr(), MAX_STRING/2);
+                                 strcat(PC.error, "' invalid option. valid options are "
+                                         "'"OPTION_PARTIAL_CLASS"' and '"OPTION_ALL_VARS_LOCAL_NAME"'");
+                                 YYERROR;
+                         }
+                 }
          } else {
                  strcpy(PC.error, "'");
                  strncat(PC.error, command.cstr(), MAX_STRING/2);
                  strcat(PC.error, "' invalid special name. valid names are "
-                         "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
+                         "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"', '"BASE_NAME"' and '"OPTIONS_CONTROL_METHOD_NAME"'.");
                  YYERROR;
          }
- ;
+ ;}
-     break;}
+     break;
- case 12:
- #line 191 "compile.y"
+   case 13:
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+ #line 248 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 16:
+     break;
- #line 196 "compile.y"
- {
+   case 17:
-         const String *name=LA2S(yyvsp[-5]);
+ #line 252 "compile.y"
+     {
-         YYSTYPE params_names_code=yyvsp[-4];
+         PC.class_add();
-         Array *params_names=0;
+         PC.explicit_result=false;
-         if(int size=params_names_code->size()) {
-                 params_names=NEW Array(POOL);
+         YYSTYPE params_names_code=yyvsp[-3];
-                 for(int i=0; i<size; i+=2)
+         ArrayString* params_names=0;
-                         *params_names+=LA2S(params_names_code, i);
+         if(int size=params_names_code->count()) {
-         }
+                 params_names=new ArrayString;
+                 for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE)
-         YYSTYPE locals_names_code=yyvsp[-3];
+                         *params_names+=LA2S(*params_names_code, i);
-         Array *locals_names=0;
+         }
-         if(int size=locals_names_code->size()) {
-                 locals_names=NEW Array(POOL);
+         YYSTYPE locals_names_code=yyvsp[-2];
-                 for(int i=0; i<size; i+=2)
+         ArrayString* locals_names=0;
-                         *locals_names+=LA2S(locals_names_code, i);
+         bool all_vars_local=false;
+         if(int size=locals_names_code->count()) {
+                 locals_names=new ArrayString;
+                 for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
+                         const String* local_name=LA2S(*locals_names_code, i);
+                         if(*local_name==RESULT_VAR_NAME)
+                                 PC.explicit_result=true;
+                         else if(*local_name==OPTION_ALL_VARS_LOCAL_NAME)
+                                 all_vars_local=true;
+                         else
+                                 *locals_names+=local_name;
+                 }
          }
+         if(!all_vars_local && PC.cclass && PC.cclass->is_vars_local())
+                 all_vars_local=true;
-         Method& method=*NEW Method(POOL,
+         Method* method=new Method(
-                 *name,
+                 //name,
                  Method::CT_ANY,
 , 0/*min,max numbered_params_count*/,
                  params_names, locals_names,
-                 yyvsp[0], 0);
+/*to be filled later in next {} */, 0, all_vars_local);
-         PC.cclass->add_method(*name, method);
- ;
+         *reinterpret_cast<Method**>(&yyval)=method;
-     break;}
- case 19:
+         // todo: check [][;result;]
- #line 225 "compile.y"
+ ;}
- {yyval=yyvsp[-1];
+     break;
-     break;}
- case 23:
+   case 18:
- #line 227 "compile.y"
+ #line 292 "compile.y"
- { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
+     {
-     break;}
+                 Method* method=reinterpret_cast<Method*>(yyvsp[-1]);
- case 29:
+                 // fill in the code
- #line 235 "compile.y"
+                 method->parser_code=yyvsp[0];
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
-     break;}
+                 // register in class
- case 35:
+                 const String& name=*LA2S(*yyvsp[-6]);
- #line 241 "compile.y"
+                 PC.cclass->set_method(PC.alias_method(name), method);
- {
+ ;}
-         yyval=yyvsp[0]; /* stack: resulting value */
+     break;
-         changetail_or_append(yyval,
-                 OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
+   case 21:
-                 /*or */OP_WRITE_VALUE
+ #line 303 "compile.y"
-                 ); /* value=pop; wcontext.write(value) */
+     {yyval=yyvsp[-1];}
- ;
+     break;
-     break;}
- case 36:
+   case 25:
- #line 248 "compile.y"
+ #line 305 "compile.y"
- { yyval=yyvsp[0] ;
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
-     break;}
+     break;
- case 39:
- #line 250 "compile.y"
+   case 31:
- { yyval=yyvsp[-1] ;
+ #line 313 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 42:
+     break;
- #line 254 "compile.y"
- {
+   case 37:
-         yyval=N(POOL);
+ #line 319 "compile.y"
-         Array *diving_code=yyvsp[0];
+     {
-         const String *first_name=LA2S(diving_code);
+         yyval=N();
-         // self.xxx... -> xxx...
+         YYSTYPE code=yyvsp[0];
-         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
+         size_t count=code->count();
-         if(first_name && *first_name==SELF_ELEMENT_NAME) {
-                 O(yyval, OP_WITH_SELF); /* stack: starting context */
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
-                 P(yyval, diving_code,
+         if(
-                         /* skip over... */
+                 count!=3
-                         diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
+                 || !maybe_change_first_opcode(*code, OP::OP_VALUE__GET_ELEMENT, /*=>*/OP::OP_VALUE__GET_ELEMENT__WRITE)
+         )
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_SELF_ELEMENT
+         if(
+                 count!=3
+                 || !maybe_change_first_opcode(*code, OP::OP_WITH_SELF__VALUE__GET_ELEMENT, /*=>*/OP::OP_WITH_SELF__VALUE__GET_ELEMENT__WRITE)
+         )
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+         if(
+                 count!=5
+                 || !maybe_change_first_opcode(*code, OP::OP_GET_OBJECT_ELEMENT, /*=>*/OP::OP_GET_OBJECT_ELEMENT__WRITE)
+         )
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+         if(
+                 count!=5
+                 || !maybe_change_first_opcode(*code, OP::OP_GET_OBJECT_VAR_ELEMENT, /*=>*/OP::OP_GET_OBJECT_VAR_ELEMENT__WRITE)
+         )
+ #endif
+         {
+                 changetail_or_append(*code,
+                         OP::OP_GET_ELEMENT, false,  /*=>*/OP::OP_GET_ELEMENT__WRITE,
+                         /*or */OP::OP_WRITE_VALUE
+                         ); /* value=pop; wcontext.write(value) */
+         }
+         P(*yyval, *code);
+ ;}
+     break;
+   case 38:
+ #line 360 "compile.y"
+     { yyval=yyvsp[0] ;}
+     break;
+   case 41:
+ #line 362 "compile.y"
+     { yyval=yyvsp[-1] ;}
+     break;
+   case 44:
+ #line 366 "compile.y"
+     {
+         yyval=N();
+         YYSTYPE diving_code=yyvsp[0];
+         size_t count=diving_code->count();
+         if(maybe_make_self(*yyval, *diving_code, count)) {
+                 // $self.
+         } else
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+         if(maybe_make_get_object_element(*yyval, *diving_code, count)){
+                 // optimization for $object.field + ^object.method[
+         } else
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+         if(maybe_make_get_object_var_element(*yyval, *diving_code, count)){
+                 // optimization for $object.$var
+         } else
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
+         if(
+                 count>=4
+                 && (*diving_code)[0].code==OP::OP_VALUE
+                 && (*diving_code)[3].code==OP::OP_GET_ELEMENT
+         ){
+                  // optimization
+                 O(*yyval,
+                         (PC.in_call_value && count==4)
+                         ? OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR // ^object[ : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT_OR_OPERATOR+origin+string
+                         : OP::OP_VALUE__GET_ELEMENT             // $object  : OP_VALUE+origin+string+OP_GET_ELEMENT => OP_VALUE__GET_ELEMENT+origin+string
+                 );
+                 P(*yyval, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value
+                 if(count>4)
+                         P(*yyval, *diving_code, 4); // copy tail
          } else {
-                 O(yyval, OP_WITH_READ); /* stack: starting context */
+                 O(*yyval, OP::OP_WITH_READ); /* stack: starting context */
+                 P(*yyval, *diving_code);
+         }
+ #else
+         {
+                 O(*yyval, OP::OP_WITH_READ); /* stack: starting context */
-                 // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
+                 // ^if OP_ELEMENT => ^if OP_ELEMENT_OR_OPERATOR
-                 // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
+                 // optimized OP_VALUE+origin+string+OP_GET_ELEMENT. => OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR.
-                 if(PC.in_call_value && diving_code->size()==3)
+                 if(PC.in_call_value && count==4)
-                         diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);
+                         diving_code->put(count-1, OP::OP_GET_ELEMENT_OR_OPERATOR);
-                 P(yyval, diving_code);
+                 P(*yyval, *diving_code);
          }
+ #endif
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 43:
- #line 276 "compile.y"
+   case 45:
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+ #line 419 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 45:
+     break;
- #line 277 "compile.y"
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+   case 47:
-     break;}
+ #line 420 "compile.y"
- case 46:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 281 "compile.y"
+     break;
- {
-         yyval=yyvsp[-1]; /* stack: context,name */
+   case 48:
-         P(yyval, yyvsp[0]); /* stack: context,name,constructor_value */
+ #line 424 "compile.y"
- ;
+     {
-     break;}
+         yyval=N();
- case 50:
+ #ifdef OPTIMIZE_BYTECODE_CONSTRUCT
- #line 289 "compile.y"
+         if(maybe_optimize_construct(*yyval, *yyvsp[-1], *yyvsp[0])){
- {
+                 // $a(expr), $.a(expr), $a[value], $.a[value], $self.a[value], $self.a(expr)
-         yyval=N(POOL);
+         } else
-         Array *diving_code=yyvsp[0];
+ #endif
-         const String *first_name=LA2S(diving_code);
+         {
-         // $self.xxx... -> $xxx...
+                 P(*yyval, *yyvsp[-1]); /* stack: context,name */
-         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
+                 P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
-         if(first_name && *first_name==SELF_ELEMENT_NAME) {
+         }
-                 O(yyval, OP_WITH_SELF); /* stack: starting context */
+ ;}
-                 P(yyval, diving_code,
+     break;
-                         /* skip over... */
-                         diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
+   case 52:
-         } else {
+ #line 440 "compile.y"
-                 O(yyval, OP_WITH_ROOT); /* stack: starting context */
+     {
-                 P(yyval, diving_code);
+         yyval=N();
+         YYSTYPE diving_code=yyvsp[0];
+         size_t count=diving_code->count();
+         if(maybe_make_self(*yyval, *diving_code, count)) {
+                 // $self.
+         } else
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
+         if(
+                 count>=4
+                 && (*diving_code)[0].code==OP::OP_VALUE
+                 && (*diving_code)[3].code==OP::OP_GET_ELEMENT
+         ){
+                 O(*yyval, OP::OP_WITH_ROOT__VALUE__GET_ELEMENT);
+                 P(*yyval, *diving_code, 1/*offset*/, 2/*limit*/); // copy origin+value
+                 if(count>4)
+                         P(*yyval, *diving_code, 4); // tail
+         } else
+ #endif
+         {
+                 O(*yyval, OP::OP_WITH_ROOT); /* stack: starting context */
+                 P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 51:
- #line 306 "compile.y"
+   case 53:
- {
+ #line 466 "compile.y"
-         yyval=N(POOL);
+     {
-         O(yyval, OP_WITH_WRITE); /* stack: starting context */
+         yyval=N();
-         P(yyval, yyvsp[0]); /* diving code; stack: context,name */
+         O(*yyval, OP::OP_WITH_WRITE); /* stack: starting context */
- ;
+         P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
-     break;}
+ ;}
- case 52:
+     break;
- #line 311 "compile.y"
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+   case 54:
-     break;}
+ #line 471 "compile.y"
- case 56:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 318 "compile.y"
+     break;
- {
+   case 58:
+ #line 478 "compile.y"
+     {
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 59:
+ #line 481 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 60:
+ #line 483 "compile.y"
+     {
          // stack: context, name
-         yyval=yyvsp[-1]; // stack: context, name, value
+         yyval=yyvsp[-2]; // stack: context, name, value
-         O(yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
+         O(*yyval, OP::OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 57:
- #line 324 "compile.y"
+   case 61:
- {
+ #line 489 "compile.y"
-         yyval=N(POOL);
+     {
-         O(yyval, OP_PREPARE_TO_EXPRESSION);
+         yyval=N();
+         O(*yyval, OP::OP_PREPARE_TO_EXPRESSION);
          // stack: context, name
-         P(yyval, yyvsp[-1]); // stack: context, name, value
+         P(*yyval, *yyvsp[-1]); // stack: context, name, value
-         O(yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
+         O(*yyval, OP::OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 58:
- #line 332 "compile.y"
+   case 62:
- {
+ #line 497 "compile.y"
+     {
          // stack: context, name
-         yyval=N(POOL);
+         yyval=N();
-         OA(yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
+         OA(*yyval, OP::OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
- ;
+ ;}
-     break;}
+     break;
- case 62:
- #line 343 "compile.y"
+   case 66:
- {
+ #line 508 "compile.y"
-         yyval=N(POOL);
+     {
-         OA(yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
+         yyval=N();
+         OA(*yyval, OP::OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ ;}
-     break;}
+     break;
- case 65:
- #line 350 "compile.y"
+   case 69:
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+ #line 515 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 66:
+     break;
- #line 354 "compile.y"
- {
+   case 70:
-         yyval=yyvsp[0]; /* stack: value */
+ #line 519 "compile.y"
-         changetail_or_append(yyval,
+     {
-                 OP_CALL, true,  /*->*/ OP_CALL__WRITE,
+ #ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
-                 /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
+         if((*yyvsp[0]).count())
- ;
+ #endif
-     break;}
+         {
- case 67:
+                 yyval=yyvsp[0]; /* stack: value */
- #line 360 "compile.y"
+                 if(!maybe_change_first_opcode(*yyval, OP::OP_CONSTRUCT_OBJECT, /*=>*/OP::OP_CONSTRUCT_OBJECT__WRITE))
- {
+                         changetail_or_append(*yyval,
+                                 OP::OP_CALL, true,  /*=>*/ OP::OP_CALL__WRITE,
+                                 /*or */OP::OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
+         }
+ ;}
+     break;
+   case 71:
+ #line 531 "compile.y"
+     {
                                          PC.in_call_value=true;
-                         ;
+                         ;}
-     break;}
+     break;
- case 68:
- #line 363 "compile.y"
+   case 72:
- {
+ #line 534 "compile.y"
+     {
                                  PC.in_call_value=false;
-                         ;
+                         ;}
-     break;}
+     break;
- case 69:
- #line 366 "compile.y"
- { /* ^field.$method{vasya} */
-         yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
-         YYSTYPE params_code=yyvsp[-1];
+   case 73:
-         if(params_code->size()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
+ #line 537 "compile.y"
-                 if(Value *value=LA2V(params_code)) // it is OP_VALUE + value?
+     { /* ^field.$method{vasya} */
-                         if(!value->is_defined()) // value is VVoid?
+ #ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
-                                 params_code=0; // ^zzz[] case. don't append lone empty param.
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
-         }
+         const String* operator_name=LA2S(*yyvsp[-3], 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR);
-         /* stack: context, method_junction */
+ #else
-         OA(yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
+         const String* operator_name=LA2S(*yyvsp[-3], 1);
- ;
+ #endif
-     break;}
+         if(operator_name && *operator_name==REM_OPERATOR_NAME){
- case 72:
+                 yyval=N();
- #line 381 "compile.y"
+         } else
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+ #endif
-     break;}
+                 {
- case 76:
+                         YYSTYPE params_code=yyvsp[-1];
- #line 387 "compile.y"
+                         if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void]
- {yyval=yyvsp[-1];
+                                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
-     break;}
+                                         if(value->is_void()) // value is VVoid?
- case 77:
+                                                 params_code=0; // ^zzz[] case. don't append lone empty param.
- #line 388 "compile.y"
+                         }
- {yyval=yyvsp[-1];
+                         /* stack: context, method_junction */
-     break;}
- case 78:
+                         YYSTYPE var_code=yyvsp[-3];
- #line 389 "compile.y"
+                         if(
- {yyval=yyvsp[-1];
+                                 var_code->count()==8
-     break;}
+                                 && (*var_code)[0].code==OP::OP_VALUE__GET_CLASS
- case 80:
+                                 && (*var_code)[3].code==OP::OP_PREPARE_TO_CONSTRUCT_OBJECT
- #line 392 "compile.y"
+                                 && (*var_code)[4].code==OP::OP_VALUE
- { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
+                                 && (*var_code)[7].code==OP::OP_GET_ELEMENT
-     break;}
+                         ){
- case 82:
+                                 yyval=N();
- #line 396 "compile.y"
+                                 O(*yyval, OP::OP_CONSTRUCT_OBJECT);
- { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
+                                 P(*yyval, *var_code, 1/*offset*/, 2/*limit*/); // class name
-     break;}
+                                 P(*yyval, *var_code, 5/*offset*/, 2/*limit*/); // constructor name
- case 84:
+                                 OA(*yyval, params_code);
- #line 400 "compile.y"
+                         } else
- { yyval=yyvsp[-2]; P(yyval, yyvsp[0]) ;
+                                 {
-     break;}
+                                         yyval=var_code; /* with_xxx,diving code; stack: context,method_junction */
- case 85:
+                                         OA(*yyval, OP::OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
- #line 402 "compile.y"
+                                 }
- {
+                 }
+ ;}
+     break;
+   case 76:
+ #line 580 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 80:
+ #line 586 "compile.y"
+     {
+         // allow ^call[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 81:
+ #line 589 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 82:
+ #line 591 "compile.y"
+     {yyval=yyvsp[-2];}
+     break;
+   case 83:
+ #line 592 "compile.y"
+     {yyval=yyvsp[-1];}
+     break;
+   case 84:
+ #line 593 "compile.y"
+     {yyval=yyvsp[-1];}
+     break;
+   case 86:
+ #line 596 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 88:
+ #line 600 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 90:
+ #line 604 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 91:
+ #line 606 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(yyval, OP_STORE_PARAM);
+ ;}
- ;
+     break;
-     break;}
- case 86:
+   case 92:
- #line 406 "compile.y"
+ #line 609 "compile.y"
- {
+     {
-         yyval=N(POOL);
+         YYSTYPE expr_code=yyvsp[0];
-         OA(yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]);
+         if(expr_code->count()==3
- ;
+                 && (*expr_code)[0].code==OP::OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP::OP_VALUE+origin+Double]. no evaluating
-     break;}
+                 yyval=expr_code;
- case 87:
+         } else {
- #line 410 "compile.y"
+                 YYSTYPE code=N();
- {
+                 O(*code, OP::OP_PREPARE_TO_EXPRESSION);
-         yyval=N(POOL);
+                 P(*code, *expr_code);
-         OA(yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
+                 O(*code, OP::OP_WRITE_EXPR_RESULT);
- ;
+                 yyval=N();
-     break;}
+                 OA(*yyval, OP::OP_EXPR_CODE__STORE_PARAM, code);
- case 91:
+         }
- #line 419 "compile.y"
+ ;}
- {
+     break;
-         yyval=N(POOL);
-         O(yyval, OP_PREPARE_TO_EXPRESSION);
+   case 93:
-         P(yyval, yyvsp[0]);
+ #line 623 "compile.y"
-         O(yyval, OP_WRITE_EXPR_RESULT);
+     {
- ;
+         yyval=N();
-     break;}
+         OA(*yyval, OP::OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
- case 93:
+ ;}
- #line 428 "compile.y"
+     break;
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
-     break;}
+   case 98:
- case 95:
+ #line 635 "compile.y"
- #line 430 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+     break;
-     break;}
- case 97:
+   case 100:
- #line 432 "compile.y"
+ #line 637 "compile.y"
- {
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 102:
+ #line 639 "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) */
+         O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 98:
- #line 440 "compile.y"
+   case 103:
- {
+ #line 647 "compile.y"
+     {
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
-         O(yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
+         O(*yyval, OP::OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 104:
- #line 453 "compile.y"
+   case 109:
- {
+ #line 660 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(yyval, OP_GET_ELEMENT);
+         O(*yyval, OP::OP_GET_ELEMENT);
- ;
+ ;}
-     break;}
+     break;
- case 105:
- #line 457 "compile.y"
+   case 110:
- {
+ #line 664 "compile.y"
-         Array *code;
+     {
+         YYSTYPE code;
          {
-                 change_string_literal_to_write_string_literal(code=yyvsp[-1]);
+                 change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
-                 P(code, yyvsp[0]);
+                 P(*code, *yyvsp[0]);
          }
-         yyval=N(POOL);
+         yyval=N();
-         OA(yyval, OP_STRING_POOL, code);
+         OA(*yyval, OP::OP_STRING_POOL, code);
- ;
+ ;}
-     break;}
+     break;
- case 106:
- #line 466 "compile.y"
+   case 111:
- {
+ #line 673 "compile.y"
-         yyval=N(POOL);
+     {
-         OA(yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 112:
+ #line 676 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 113:
+ #line 678 "compile.y"
+     {
+         yyval=N();
+         OA(*yyval, OP::OP_OBJECT_POOL, yyvsp[-2]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ ;}
-     break;}
+     break;
- case 107:
- #line 472 "compile.y"
+   case 114:
- {
+ #line 684 "compile.y"
-         yyval=N(POOL);
+     {
-         O(yyval, OP_WITH_READ);
+         yyval=N();
-         P(yyval, yyvsp[0]);
+         O(*yyval, OP::OP_WITH_READ);
- ;
+         P(*yyval, *yyvsp[0]);
-     break;}
+ ;}
- case 109:
+     break;
- #line 477 "compile.y"
- { yyval=yyvsp[-1]; P(yyval, yyvsp[0]) ;
+   case 116:
-     break;}
+ #line 689 "compile.y"
- case 110:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 478 "compile.y"
+     break;
- {
+   case 117:
+ #line 690 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(yyval, OP_GET_ELEMENT__WRITE);
+         O(*yyval, OP::OP_GET_ELEMENT__WRITE);
- ;
+ ;}
-     break;}
+     break;
- case 113:
- #line 487 "compile.y"
+   case 120:
- {
+ #line 699 "compile.y"
+     {
          yyval=yyvsp[-1]; // stack: class name string
-         O(yyval, OP_GET_CLASS);
+         if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
- ;
+                 if(VStateless_class* base=PC.cclass->base_class()) {
-     break;}
+                         change_string_literal_value(*yyval, base->name());
- case 114:
+                 } else {
- #line 491 "compile.y"
+                         strcpy(PC.error, "no base class declared");
- {
+                         YYERROR;
+                 }
+         }
+ #ifdef OPTIMIZE_BYTECODE_GET_CLASS
+         // optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string
+         maybe_change_first_opcode(*yyval, OP::OP_VALUE, OP::OP_VALUE__GET_CLASS)
+ #else
+         O(*yyval, OP::OP_GET_CLASS);
+ #endif
+ ;}
+     break;
+   case 121:
+ #line 716 "compile.y"
+     {
          yyval=yyvsp[-1];
          if(!PC.in_call_value) {
                  strcpy(PC.error, ":: not allowed here");
                  YYERROR;
          }
-         O(yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);
+         O(*yyval, OP::OP_PREPARE_TO_CONSTRUCT_OBJECT);
- ;
+ ;}
-     break;}
+     break;
- case 115:
- #line 503 "compile.y"
+   case 128:
- {
+ #line 735 "compile.y"
-         // see OP_PREPARE_TO_EXPRESSION!!
+     { yyval = yyvsp[-1] ;}
-         if((yyval=yyvsp[0])->size()==2) // only one string literal in there?
+     break;
-                 change_string_literal_to_double_literal(yyval); // make that string literal Double
- ;
+   case 129:
-     break;}
+ #line 736 "compile.y"
- case 119:
+     { yyval = yyvsp[-1] ;}
- #line 512 "compile.y"
+     break;
- { yyval = yyvsp[-1]; ;
-     break;}
+   case 130:
- case 120:
+ #line 737 "compile.y"
- #line 513 "compile.y"
+     { yyval = yyvsp[-1]; ;}
- { yyval = yyvsp[-1]; ;
+     break;
-     break;}
- case 121:
+   case 131:
- #line 514 "compile.y"
+ #line 739 "compile.y"
- { yyval = yyvsp[-1]; ;
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_NEG) ;}
-     break;}
+     break;
- case 122:
- #line 516 "compile.y"
+   case 132:
- { yyval=yyvsp[0];  O(yyval, OP_NEG) ;
+ #line 740 "compile.y"
-     break;}
+     { yyval=yyvsp[0] ;}
- case 123:
+     break;
- #line 517 "compile.y"
- { yyval=yyvsp[0] ;
+   case 133:
-     break;}
+ #line 741 "compile.y"
- case 124:
+     { yyval=yyvsp[0];    O(*yyval, OP::OP_INV) ;}
- #line 518 "compile.y"
+     break;
- { yyval=yyvsp[0];        O(yyval, OP_INV) ;
-     break;}
+   case 134:
- case 125:
+ #line 742 "compile.y"
- #line 519 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_NOT) ;}
- { yyval=yyvsp[0];  O(yyval, OP_NOT) ;
+     break;
-     break;}
- case 126:
+   case 135:
- #line 520 "compile.y"
+ #line 743 "compile.y"
- { yyval=yyvsp[0];  O(yyval, OP_DEF) ;
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_DEF) ;}
-     break;}
+     break;
- case 127:
- #line 521 "compile.y"
+   case 136:
- { yyval=yyvsp[0];  O(yyval, OP_IN) ;
+ #line 744 "compile.y"
-     break;}
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_IN) ;}
- case 128:
+     break;
- #line 522 "compile.y"
- { yyval=yyvsp[0];  O(yyval, OP_FEXISTS) ;
+   case 137:
-     break;}
+ #line 745 "compile.y"
- case 129:
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_FEXISTS) ;}
- #line 523 "compile.y"
+     break;
- { yyval=yyvsp[0];  O(yyval, OP_DEXISTS) ;
-     break;}
+   case 138:
- case 130:
+ #line 746 "compile.y"
- #line 525 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_DEXISTS) ;}
- {       yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_SUB) ;
+     break;
-     break;}
- case 131:
+   case 139:
- #line 526 "compile.y"
+ #line 748 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_ADD) ;
+     {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_SUB) ;}
-     break;}
+     break;
- case 132:
- #line 527 "compile.y"
+   case 140:
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MUL) ;
+ #line 749 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_ADD) ;}
- case 133:
+     break;
- #line 528 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_DIV) ;
+   case 141:
-     break;}
+ #line 750 "compile.y"
- case 134:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MUL) ;}
- #line 529 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_MOD) ;
-     break;}
+   case 142:
- case 135:
+ #line 751 "compile.y"
- #line 530 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_DIV) ;}
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_INTDIV) ;
+     break;
-     break;}
- case 136:
+   case 143:
- #line 531 "compile.y"
+ #line 752 "compile.y"
- { yyval=yyvsp[-2];      P(yyval, yyvsp[0]);  O(yyval, OP_BIN_AND) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MOD) ;}
-     break;}
+     break;
- case 137:
- #line 532 "compile.y"
+   case 144:
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_OR) ;
+ #line 753 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_INTDIV) ;}
- case 138:
+     break;
- #line 533 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_BIN_XOR) ;
+   case 145:
-     break;}
+ #line 754 "compile.y"
- case 139:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SL) ;}
- #line 534 "compile.y"
+     break;
- { yyval=yyvsp[-2];  OA(yyval, OP_NESTED_CODE, yyvsp[0]);  O(yyval, OP_LOG_AND) ;
-     break;}
+   case 146:
- case 140:
+ #line 755 "compile.y"
- #line 535 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SR) ;}
- { yyval=yyvsp[-2];  OA(yyval, OP_NESTED_CODE, yyvsp[0]);  O(yyval, OP_LOG_OR) ;
+     break;
-     break;}
- case 141:
+   case 147:
- #line 536 "compile.y"
+ #line 756 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_LOG_XOR) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_AND) ;}
-     break;}
+     break;
- case 142:
- #line 537 "compile.y"
+   case 148:
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LT) ;
+ #line 757 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_OR) ;}
- case 143:
+     break;
- #line 538 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GT) ;
+   case 149:
-     break;}
+ #line 758 "compile.y"
- case 144:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_XOR) ;}
- #line 539 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_LE) ;
-     break;}
+   case 150:
- case 145:
+ #line 759 "compile.y"
- #line 540 "compile.y"
+     { yyval=yyvsp[-2];  OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP::OP_LOG_AND) ;}
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_GE) ;
+     break;
-     break;}
- case 146:
+   case 151:
- #line 541 "compile.y"
+ #line 760 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_EQ) ;
+     { yyval=yyvsp[-2];  OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP::OP_LOG_OR) ;}
-     break;}
+     break;
- case 147:
- #line 542 "compile.y"
+   case 152:
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_NUM_NE) ;
+ #line 761 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_LOG_XOR) ;}
- case 148:
+     break;
- #line 543 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LT) ;
+   case 153:
-     break;}
+ #line 762 "compile.y"
- case 149:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LT) ;}
- #line 544 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GT) ;
-     break;}
+   case 154:
- case 150:
+ #line 763 "compile.y"
- #line 545 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_GT) ;}
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_LE) ;
+     break;
-     break;}
- case 151:
+   case 155:
- #line 546 "compile.y"
+ #line 764 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_GE) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LE) ;}
-     break;}
+     break;
- case 152:
- #line 547 "compile.y"
+   case 156:
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_EQ) ;
+ #line 765 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_GE) ;}
- case 153:
+     break;
- #line 548 "compile.y"
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_STR_NE) ;
+   case 157:
-     break;}
+ #line 766 "compile.y"
- case 154:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_EQ) ;}
- #line 549 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(yyval, yyvsp[0]);  O(yyval, OP_IS) ;
-     break;}
+   case 158:
- case 155:
+ #line 767 "compile.y"
- #line 552 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_NE) ;}
- {
+     break;
-         yyval=N(POOL);
-         OA(yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */
+   case 159:
+ #line 768 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_LT) ;}
+     break;
+   case 160:
+ #line 769 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_GT) ;}
+     break;
+   case 161:
+ #line 770 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_LE) ;}
+     break;
+   case 162:
+ #line 771 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_GE) ;}
+     break;
+   case 163:
+ #line 772 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_EQ) ;}
+     break;
+   case 164:
+ #line 773 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_NE) ;}
+     break;
+   case 165:
+ #line 774 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_IS) ;}
+     break;
+   case 166:
+ #line 777 "compile.y"
+     {
+         // optimized OP_STRING => OP_VALUE for doubles
+         maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
+ ;}
+     break;
+   case 167:
+ #line 782 "compile.y"
+     {
+ #ifdef OPTIMIZE_BYTECODE_STRING_POOL
+         // it brakes ^if(" 09 "){...}
+         YYSTYPE code=yyvsp[0];
+         yyval=N();
+         if(code->count()==3 && maybe_change_first_opcode(*code, OP::OP_STRING__WRITE, OP::OP_VALUE)){
+                 // optimized OP_STRING__WRITE+origin+value => OP_VALUE+origin+value without starting OP_STRING_POOL
+                 P(*yyval, *code);
+         } else {
+                 OA(*yyval, OP::OP_STRING_POOL, code); /* stack: empty write context */
+         }
+ #else
+         yyval=N();
+         OA(*yyval, OP::OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */
+ #endif
          /* some code that writes to that context */
          /* context=pop; stack: context.get_string() */
- ;
+ ;}
-     break;}
+     break;
- case 156:
- #line 561 "compile.y"
+   case 168:
- {
+ #line 803 "compile.y"
-         // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
+     {
-         change_string_literal_to_write_string_literal(yyval=yyvsp[0])
+         // optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE
- ;
+         change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
-     break;}
+ ;}
- case 157:
+     break;
- #line 566 "compile.y"
- { yyval=VL(NEW VVoid(POOL)) ;
+   case 169:
-     break;}
+ #line 808 "compile.y"
- case 158:
+     { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0) ;}
- #line 567 "compile.y"
+     break;
- { yyval=N(POOL) ;
-     break;}
+   case 170:
- }
+ #line 809 "compile.y"
-    /* the action file gets copied in in place of this dollarsign */
+     { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vtrue), 0, 0, 0) ;}
- #line 543 "/usr/share/bison.simple"
+     break;
+   case 171:
+ #line 810 "compile.y"
+     { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0) ;}
+     break;
+   case 172:
+ #line 812 "compile.y"
+     { yyval=N() ;}
+     break;
+     }
+ /* Line 1010 of yacc.c.  */
+ #line 2406 "compile.tab.C"
    yyvsp -= yylen;
    yyssp -= yylen;
- #ifdef YYLSP_NEEDED
-   yylsp -= yylen;
- #endif
- #if YYDEBUG != 0
-   if (yydebug)
+   YY_STACK_PRINT (yyss, yyssp);
-     {
-       short *ssp1 = yyss - 1;
-       fprintf (stderr, "state stack now");
-       while (ssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
-       fprintf (stderr, "\n");
-     }
- #endif
    *++yyvsp = yyval;
- #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;
+           const char* yyprefix;
+           char *yymsg;
-           count = 0;
+           int yyx;
-           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
-           for (x = (yyn < 0 ? -yyn : 0);
+           /* Start YYX at -YYN if negative to avoid negative indexes in
-                x < (sizeof(yytname) / sizeof(char *)); x++)
+              YYCHECK.  */
-             if (yycheck[x + yyn] == x)
+           int yyxbegin = yyn < 0 ? -yyn : 0;
-               size += strlen(yytname[x]) + 15, count++;
-           msg = (char *) malloc(size + 15);
+           /* Stay within bounds of both yycheck and yytname.  */
-           if (msg != 0)
+           int yychecklim = YYLAST - yyn;
+           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+           int yycount = 0;
+           yyprefix = ", expecting ";
+           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+               {
+                 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
+                 yycount += 1;
+                 if (yycount == 5)
+                   {
+                     yysize = 0;
+                     break;
+                   }
+               }
+           yysize += (sizeof ("syntax error, unexpected ")
+                      + yystrlen (yytname[yytype]));
+           yymsg = (char *) YYSTACK_ALLOC (yysize);
+           if (yymsg != 0)
              {
-               strcpy(msg, "parse error");
+               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
+               yyp = yystpcpy (yyp, yytname[yytype]);
-               if (count < 5)
+               if (yycount < 5)
                  {
-                   count = 0;
+                   yyprefix = ", expecting ";
-                   for (x = (yyn < 0 ? -yyn : 0);
+                   for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-                        x < (sizeof(yytname) / sizeof(char *)); x++)
+                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-                     if (yycheck[x + yyn] == x)
                        {
-                         strcat(msg, count == 0 ? ", expecting `" : " or `");
+                         yyp = yystpcpy (yyp, yyprefix);
-                         strcat(msg, yytname[x]);
+                         yyp = yystpcpy (yyp, yytname[yyx]);
-                         strcat(msg, "'");
+                         yyprefix = " or ";
-                         count++;
                        }
                  }
-               yyerror(msg);
+               yyerror (yymsg);
-               free(msg);
+               YYSTACK_FREE (yymsg);
              }
            else
-             yyerror ("parse error; also virtual memory exceeded");
+             yyerror ("syntax error; also virtual memory exhausted");
          }
        else
  #endif /* YYERROR_VERBOSE */
-         yyerror("parse error");
+         yyerror ("syntax error");
      }
-   goto yyerrlab1;
- yyerrlab1:   /* here on error raised explicitly by an action */
    if (yyerrstatus == 3)
      {
-       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+       /* If just tried and failed to reuse lookahead token after an
+          error, discard it.  */
-       /* return failure if at end of input */
-       if (yychar == YYEOF)
-         YYABORT;
- #if YYDEBUG != 0
+       if (yychar <= YYEOF)
-       if (yydebug)
+         {
-         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+           /* If at end of input, pop the error token,
- #endif
+              then the rest of the stack, then return failure.  */
+           if (yychar == YYEOF)
+              for (;;)
+                {
+                  YYPOPSTACK;
+                  if (yyssp == yyss)
+                    YYABORT;
+                  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+                  yydestruct (yystos[*yyssp], yyvsp);
+                }
+         }
+       else
+         {
+           YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
+           yydestruct (yytoken, &yylval);
+           yychar = YYEMPTY;
-       yychar = YYEMPTY;
+         }
      }
-   /* Else will try to reuse lookahead token
+   /* Else will try to reuse lookahead token after shifting the error
-      after shifting the error token.  */
+      token.  */
+   goto yyerrlab1;
-   yyerrstatus = 3;              /* Each real token shifted decrements this */
-   goto yyerrhandle;
- yyerrdefault:  /* current state does not do anything special for the error token. */
+ /*---------------------------------------------------.
+ | yyerrorlab -- error raised explicitly by YYERROR.  |
+ `---------------------------------------------------*/
+ yyerrorlab:
- #if 0
+ #ifdef __GNUC__
-   /* This is wrong; only states that explicitly want error tokens
+   /* Pacify GCC when the user code never invokes YYERROR and the label
-      should shift them.  */
+      yyerrorlab therefore never appears in user code.  */
-   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+   if (0)
-   if (yyn) goto yydefault;
+      goto yyerrorlab;
  #endif
- yyerrpop:   /* pop the current state because it cannot handle the error token */
+   yyvsp -= yylen;
+   yyssp -= yylen;
-   if (yyssp == yyss) YYABORT;
+   yystate = *yyssp;
-   yyvsp--;
+   goto yyerrlab1;
-   yystate = *--yyssp;
- #ifdef YYLSP_NEEDED
-   yylsp--;
- #endif
- #if YYDEBUG != 0
-   if (yydebug)
-     {
-       short *ssp1 = yyss - 1;
-       fprintf (stderr, "Error: state stack now");
-       while (ssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
-       fprintf (stderr, "\n");
-     }
- #endif
- yyerrhandle:
+ /*-------------------------------------------------------------.
+ | yyerrlab1 -- common code for both syntax error and YYERROR.  |
+ `-------------------------------------------------------------*/
+ yyerrlab1:
+   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
-   yyn = yypact[yystate];
+   for (;;)
-   if (yyn == YYFLAG)
+     {
-     goto yyerrdefault;
+       yyn = yypact[yystate];
+       if (yyn != YYPACT_NINF)
+         {
+           yyn += YYTERROR;
+           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+             {
+               yyn = yytable[yyn];
+               if (0 < yyn)
+                 break;
+             }
+         }
-   yyn += YYTERROR;
+       /* Pop the current state because it cannot handle the error token.  */
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+       if (yyssp == yyss)
-     goto yyerrdefault;
+         YYABORT;
-   yyn = yytable[yyn];
+       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-   if (yyn < 0)
+       yydestruct (yystos[yystate], yyvsp);
-     {
+       YYPOPSTACK;
-       if (yyn == YYFLAG)
+       yystate = *yyssp;
-         goto yyerrpop;
+       YY_STACK_PRINT (yyss, yyssp);
-       yyn = -yyn;
-       goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrpop;
    if (yyn == YYFINAL)
      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 569 "compile.y"
+ #line 814 "compile.y"
  #endif
- Line 1869  yyerrhandle:
+ Line 2647  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;
          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') {
+                 if(c=='\n')
-                         PC.line++;
+                         pc.pos_next_line();
-                         PC.col=0;
+                 else
-                 } else
+                         pc.pos_next_c(c);
-                         PC.col++;
+ //              fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col);
-                 if(c=='@' && PC.col==0+1) {
+                 if(pc.pos.col==0+1 && c=='@') {
-                         if(PC.ls==LS_DEF_SPECIAL_BODY) {
+                         if(pc.ls==LS_DEF_SPECIAL_BODY) {
                                  // @SPECIAL
                                  // ...
                                  // @<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=='^')
+                 }
-                         switch(PC.ls) {
+                 if(c=='^') {
+                         if(pc.ls==LS_METHOD_AFTER) {
+                                 // handle after-method situation
+                                 pop_LS(pc);
+                                 result=EON;
+                                 skip_analized=-1; // return to punctuation afterwards to assure it's literality
+                                 goto break2;
+                         }
+                         switch(pc.ls) {
  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
  case LS_VAR_NAME_SIMPLE_WITH_COLON:
  case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
  case LS_VAR_NAME_CURLY:
  case LS_METHOD_NAME:
- case LS_COMMENT:
+ case LS_USER_COMMENT:
  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 '$': case ';': case '@':
                          case '(': case ')':
                          case '[': case ']':
                          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_know_length(begin, end-begin);
                                  }
                                  // reset piece 'begin' position & line
-                                 end=begin=PC.source; // ^
+                                 begin=pc.source; // ->punctuation
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
-                                 if(PC.ls==LS_METHOD_AFTER) {
+                                 // skip over _ after ^
-                                         pop_LS(PC);
+                                 pc.source++;  pc.pos.col++;
-                                         result=EON;
+                                 // skip analysis = forced literal
-                                         skip_analized=-1; // return to ^ afterwards to assure it's literality
+                                 continue;
-                                         goto break2;
-                                 } else {
-                                         // skip over _ after ^
-                                         PC.source++;  PC.col++;
-                                         // skip analysis = forced literal
-                                         continue;
-                                 }
                          // converting ^#HH into char(hex(HH))
                          case '#':
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till ^
-                                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                         pc.string.append_strdup_know_length(begin, end-begin);
                                  }
                                  // #HH ?
-                                 if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) {
+                                 if(pc.source[1] && isxdigit(pc.source[1]) && pc.source[2] && isxdigit(pc.source[2])) {
-                                         char *hex=(char *)POOL.malloc(1);
+                                         char c=(char)(
-                                         hex[0]=
+                                                 hex_value[(unsigned char)pc.source[1]]*0x10+
-                                                 hex_value[(unsigned char)PC.source[1]]*0x10+
+                                                 hex_value[(unsigned char)pc.source[2]]);
-                                                 hex_value[(unsigned char)PC.source[2]];
+                                         if(c==0) {
-                                         if(hex[0]==0) {
                                                  result=BAD_HEX_LITERAL;
                                                  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; // ^
+                                         begin=pc.source; // ->after ^#HH
-                                         begin_line=PC.line;
+                                         begin_pos=pc.pos;
+                                         // skip analysis = forced literal
                                          continue;
                                  }
-                                 break;
+                                 // just escaped char
+                                 // reset piece 'begin' position & line
+                                 begin=pc.source;
+                                 begin_pos=pc.pos;
+                                 // skip over _ after ^
+                                 pc.source++;  pc.pos.col++;
+                                 // skip analysis = forced literal
+                                 continue;
                          }
                          break;
+                         }
                  }
                  // #comment  start skipping
-                 if(c=='#' && PC.col==1) {
+                 if(c=='#' && pc.pos.col==1) {
                          if(end!=begin) {
+                                 if(!pc.string_start)
+                                         pc.string_start=begin_pos;
                                  // append piece till #
-                                 PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
+                                 pc.string.append_strdup_know_length(begin, end-begin);
                          }
                          // fall into COMMENT lexical state [wait for \n]
-                         push_LS(PC, LS_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;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  // #COMMENT
-                 case LS_COMMENT:
+                 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 2042  default:
+ Line 2855  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 2061  default:
+ Line 2874  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;
                  case LS_DEF_PARAMS:
                          switch(c) {
+                         case '$': // common error
+                                 result=BAD_METHOD_PARAMETER_NAME_CHARACTER;
+                                 goto break2;
                          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 2088  default:
+ Line 2904  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 2114  default:
+ Line 2930  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_strdup_know_length(begin, end-begin);
+                                 }
+                                 // fall into COMMENT lexical state [wait for \n]
+                                 push_LS(pc, LS_EXPRESSION_COMMENT);
+                                 lexical_brackets_nestage=1;
+                                 continue;
                          case '$':
-                                 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 2138  default:
+ Line 2965  default:
                                          skip_analized=1;
                                          result=DEXISTS;
                                          goto break2;
-                                 default:
+                                 default: // minus
                                          result=c;
                                          goto break2;
                                  }
- Line 2147  default:
+ Line 2974  default:
                          case '~':
                          case ';':
                                  RC;
-                         case '&': case '|':  case '#':
+                         case '&': case '|':
-                                 if(*PC.source==c) { // && ||
+                                 if(*pc.source==c) { // && ||
-                                         result=c=='#'?LXOR:c=='&'?LAND:LOR;
+                                         result=c=='&'?LAND:LOR;
                                          skip_analized=1;
                                  } else
                                          result=c;
                                  goto break2;
-                         case '<': case '>': case '=': case '!':
+                         case '!':
-                                 if(*PC.source=='=') { // <= >= == !=
+                                 switch(pc.source[0]) {
+                                 case '|': // !| !||
                                          skip_analized=1;
-                                         switch(c) {
+                                         if(pc.source[1]=='|') {
-                                         case '<': result=NLE; break;
+                                                 skip_analized++;
-                                         case '>': result=NGE; break;
+                                                 result=LXOR;
-                                         case '=': result=NEQ; break;
+                                         } else
-                                         case '!': result=NNE; break;
+                                                 result=NXOR;
-                                         }
+                                         goto break2;
-                                 } else
+                                 case '=': // !=
-                                         result=c;
+                                         skip_analized=1;
+                                         result=NNE;
+                                         goto break2;
+                                 }
+                                 RC;
+                         case '<': // <<, <=, <
+                                 switch(*pc.source) {
+                                 case '<': // <[<]
+                                         skip_analized=1; result=NSL; break;
+                                 case '=': // <[=]
+                                         skip_analized=1; result=NLE; break;
+                                 default: // <[]
+                                         result=c; break;
+                                 }
+                                 goto break2;
+                         case '>': // >>, >=, >
+                                 switch(*pc.source) {
+                                 case '>': // >[>]
+                                         skip_analized=1; result=NSR; break;
+                                 case '=': // >[=]
+                                         skip_analized=1; result=NGE; break;
+                                 default: // >[]
+                                         result=c; break;
+                                 }
                                  goto break2;
+                         case '=': // ==
+                                 switch(*pc.source) {
+                                 case '=': // =[=]
+                                         skip_analized=1; result=NEQ; break;
+                                 default: // =[]
+                                         result=c; break; // not used now
+                                 }
+                                 goto break2;
                          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 2194  default:
+ Line 3055  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 2209  default:
+ Line 3070  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;
+                                                 switch(pc.source[2]){
-                                                 result=DEF;
+                                                 case ' ': case '\t': case '\n': case '"': case '\'': case '^': case '$': // non-quoted string without whitespace after 'def' is not allowed
+                                                         skip_analized=2;
+                                                         result=DEF;
+                                                         goto break2;
+                                                 }
+                                                 // error: incorrect char after 'def'
+                                         }
+                                 break;
+                         case 't':
+                                 if(end==begin) // right after whitespace
+                                         if(pc.source[0]=='r' && pc.source[1]=='u' && pc.source[2]=='e') { // true
+                                                 skip_analized=3;
+                                                 result=LITERAL_TRUE;
+                                                 goto break2;
+                                         }
+                                 break;
+                         case 'f':
+                                 if(end==begin) // right after whitespace
+                                         if(pc.source[0]=='a' && pc.source[1]=='l' && pc.source[2]=='s' && pc.source[3]=='e') { // false
+                                                 skip_analized=4;
+                                                 result=LITERAL_FALSE;
                                                  goto break2;
                                          }
                                  break;
- Line 2223  default:
+ Line 3104  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;
+                 case LS_EXPRESSION_COMMENT:
+                         if(c=='(')
+                                 lexical_brackets_nestage++;
+                         switch(*pc.source) {
+                         case '\n': case ')':
+                                 if(*pc.source==')')
+                                         if(--lexical_brackets_nestage!=0)
+                                                 continue;
+                                 // skip comment
+                                 begin=pc.source;
+                                 begin_pos=pc.pos;
+                                 pop_LS(pc);
                                  continue;
                          }
                          break;
- Line 2235  default:
+ Line 3134  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; }
+                                         pc.ungetc();
                                          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; }
+                                         pc.ungetc();
                                          result=EON;
                                          goto break2;
                                  }
- Line 2272  default:
+ Line 3171  default:
                          case '&': case '|':
                          case '=': case '!':
                          // common delimiters
-                         case ',': case '?':
+                         case ',': case '?': case '#':
+                         // mysql column separators
+                         case '`':
                          // before call
                          case '^':
-                                 pop_LS(PC);
+                                 pop_LS(pc);
-                                 PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                 pc.ungetc();
                                  result=EON;
                                  goto break2;
                          case '[':
                                  // $name.<[>code]
-                                 if(PC.col>1/*not first column*/ && (
+                                 if(pc.pos.col>1/*not first column*/ && (
                                          end[-1]=='$'/*was start of get*/ ||
                                          end[-1]==':'/*was class name delim */ ||
                                          end[-1]=='.'/*was name delim */
                                          )) {
-                                         push_LS(PC, LS_NAME_SQUARE_PART);
+                                         push_LS(pc, LS_NAME_SQUARE_PART);
                                          lexical_brackets_nestage=1;
                                          RC;
                                  }
-                                 PC.ls=LS_VAR_SQUARE;
+                                 pc.ls=LS_VAR_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '{':
                                  if(begin==end) { // ${name}, no need of EON, switching LS
-                                         PC.ls=LS_VAR_NAME_CURLY;
+                                         pc.ls=LS_VAR_NAME_CURLY;
                                  } else {
-                                         PC.ls=LS_VAR_CURLY;
+                                         pc.ls=LS_VAR_CURLY;
                                          lexical_brackets_nestage=1;
                                  }
                                  RC;
                          case '(':
-                                 PC.ls=LS_VAR_ROUND;
+                                 pc.ls=LS_VAR_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '.': // name part delim
                          case '$': // name part subvar
                          case ':': // class<:>name
                                  // go to _WITHOUT_COLON state variant...
-                                 if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
+                                 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 2323  default:
+ Line 3224  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 2339  default:
+ Line 3240  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 2361  default:
+ Line 3262  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 2383  default:
+ Line 3284  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 2408  default:
+ Line 3309  default:
                          case ':': // ':name' or 'class:name'
                          case '^': // ^abc^xxx wrong. bailing out
                          case ']': case '}': case ')': // ^abc]}) wrong. bailing out
+                         case ' ': // ^if ( wrong. bailing out
                                  RC;
                          }
                          break;
- Line 2415  default:
+ Line 3317  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 2437  default:
+ Line 3339  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 2454  default:
+ Line 3356  default:
                                  lexical_brackets_nestage++;
                                  break;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  case LS_METHOD_AFTER:
                          if(c=='[') {/* ][ }[ )[ */
-                                 PC.ls=LS_METHOD_SQUARE;
+                                 pc.ls=LS_METHOD_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='{') {/* ]{ }{ ){ */
-                                 PC.ls=LS_METHOD_CURLY;
+                                 pc.ls=LS_METHOD_CURLY;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='(') {/* ]( }( )( */
-                                 PC.ls=LS_METHOD_ROUND;
+                                 pc.ls=LS_METHOD_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
-                         pop_LS(PC);
+                         pop_LS(pc);
-                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                         pc.ungetc();
                          result=EON;
                          goto break2;
                  }
- Line 2491  break2:
+ Line 3403  break2:
                          if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
                                  end--;
                  }
-                 if(end!=begin && PC.ls!=LS_COMMENT) { // last piece still alive and not comment?
+                 if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
+                         if(!pc.string_start)
+                                 pc.string_start=begin_pos;
                          // append it
-                         PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line/*, start_col*/);
+                         pc.string.append_strdup_know_length(begin, end-begin);
                  }
          }
-         if(PC.string->size()) { // something accumulated?
+         if(!pc.string.is_empty()) { // something accumulated?
-                 // create STRING value: array of OP_VALUE+vstring
+                 // create STRING value: array of OP_VALUE+origin+vstring
-                 *lvalp=VL(NEW VString(*PC.string));
+                 *lvalp=VL(
+                         new VString(*new String(pc.string, String::L_CLEAN)),
+                         pc.file_no, pc.string_start.line, pc.string_start.col);
                  // new pieces storage
-                 PC.string=NEW String(POOL);
+                 pc.string.clear();
+                 pc.string_start.clear();
                  // make current result be pending for next call, return STRING for now
-                 PC.pending_state=result;  result=STRING;
+                 pc.pending_state=result;  result=STRING;
          }
          if(skip_analized) {
-                 PC.source+=skip_analized;  PC.col+=skip_analized;
+                 pc.source+=skip_analized;  pc.pos.col+=skip_analized;
          }
          return result;
  }
- static int real_yyerror(parse_control *pc, char *s) {  // Called by yyparse on error
+ static int real_yyerror(Parse_control *pc, char *s) {  // Called by yyparse on error
             strncpy(PC.error, s, MAX_STRING);
             return 1;
  }
  static void yyprint(FILE *file, int type, YYSTYPE value) {
          if(type==STRING)
-                 fprintf(file, " \"%s\"", LA2S(value)->cstr());
+                 fprintf(file, " \"%s\"", LA2S(*value)->cstr());
  }

E-mail:

Removed from v.1.55
changed lines
	Added in v.1.145