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.102 and 1.137

-version 1.102, 2004/05/11 15:03:49
+version 1.137, 2009/06/02 10:24:34
  Line 1
+ /* A Bison parser, made by GNU Bison 1.875d.  */
+ /* Skeleton parser for Yacc-like parsing with Bison,
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.  */
+ /* As a special exception, when this file is copied by Bison into a
+    Bison output file, you may use that output file without restriction.
+    This special exception was added by the Free Software Foundation
+    in version 1.24 of Bison.  */
+ /* Written by Richard Stallman by simplifying the original so called
+    ``semantic'' parser.  */
+ /* All symbols defined below should begin with yy or YY, to avoid
+    infringing on user name space.  This should be done even for local
+    variables, as they might otherwise be expanded by user macros.
+    There are some unavoidable exceptions within include files to
+    define necessary library symbols; they are noted "INFRINGES ON
+    USER NAME SPACE" below.  */
+ /* Identify Bison output.  */
+ #define YYBISON 1
+ /* Skeleton name.  */
+ #define YYSKELETON_NAME "yacc.c"
+ /* Pure parsers.  */
+ #define YYPURE 1
+ /* Using locations.  */
+ #define YYLSP_NEEDED 0
+ /* 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
- /*  A Bison parser, made from compile.y
-     by GNU Bison version 1.28  */
- #define YYBISON 1  /* Identify Bison output.  */
- #define EON     257
- #define STRING  258
- #define BOGUS   259
- #define BAD_STRING_COMPARISON_OPERATOR  260
- #define BAD_HEX_LITERAL 261
- #define BAD_METHOD_DECL_START   262
- #define BAD_METHOD_PARAMETER_NAME_CHARACTER     263
- #define BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE     264
- #define LAND    265
- #define LOR     266
- #define LXOR    267
- #define NXOR    268
- #define NLE     269
- #define NGE     270
- #define NEQ     271
- #define NNE     272
- #define NSL     273
- #define NSR     274
- #define SLT     275
- #define SGT     276
- #define SLE     277
- #define SGE     278
- #define SEQ     279
- #define SNE     280
- #define DEF     281
- #define IN      282
- #define FEXISTS 283
- #define DEXISTS 284
- #define IS      285
- #define NUNARY  286
+ /* Copy the first part of user declarations.  */
  #line 1 "compile.y"
  /** @file
          Parser: compiler(lexical parser and grammar).
-         Copyright (c) 2001, 2003 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 79
+ Line 168
  // defines
  #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
- Line 86  static int real_yyerror(Parse_control* p
+ Line 179  static int real_yyerror(Parse_control* p
  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
  #undef PC
  #define PC  (*(Parse_control *)pc)
  #undef POOL
  #define POOL  (*PC.pool)
  #ifndef DOXYGEN
- #ifndef YYSTYPE
- #define YYSTYPE int
- #endif
- #include <stdio.h>
- #ifndef __cplusplus
- #ifndef __STDC__
+ /* Enabling traces.  */
- #define const
+ #ifndef YYDEBUG
+ # define YYDEBUG 0
  #endif
+ /* Enabling verbose error messages.  */
+ #ifdef YYERROR_VERBOSE
+ # undef YYERROR_VERBOSE
+ # define YYERROR_VERBOSE 1
+ #else
+ # define YYERROR_VERBOSE 0
  #endif
+ #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         259
+ #if defined (__STDC__) || defined (__cplusplus)
- #define YYFLAG          -32768
+    typedef signed char yysigned_char;
- #define YYNTBASE        60
+ #else
+    typedef short int yysigned_char;
- #define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 146)
+ #endif
- static const char yytranslate[] = {     0,
-,     2,     2,     2,     2,     2,     2,     2,     2,    46,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,    44,    58,     2,    50,    41,    35,    59,    54,
-,    38,    36,     2,    37,    53,    39,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,    57,    49,    32,
-,    33,     2,    45,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,    40,    48,    56,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,    51,    34,    52,    43,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-,     2,     2,     2,     2,     1,     3,     4,     5,     6,
-,     8,     9,    10,    11,    12,    13,    14,    15,    16,
-,    18,    19,    20,    21,    22,    23,    24,    25,    26,
-,    28,    29,    30,    31,    42
- };
- #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,    37,    46,    48,    50,
+ #define YYLAST   470
-,    56,    58,    60,    64,    66,    68,    70,    72,    74,
-,    79,    81,    83,    85,    87,    89,    92,    95,    97,
+ /* YYNTOKENS -- Number of terminals. */
-,   103,   105,   107,   110,   112,   115,   119,   121,   123,
+ #define YYNTOKENS  62
-,   127,   130,   133,   135,   137,   139,   140,   141,   147,
+ /* YYNNTS -- Number of nonterminals. */
-,   155,   157,   159,   161,   163,   165,   167,   170,   172,
+ #define YYNNTS  89
-,   174,   181,   183,   185,   188,   190,   192,   194,   195,
+ /* YYNRULES -- Number of rules. */
-,   202,   206,   210,   212,   216,   218,   222,   224,   228,
+ #define YYNRULES  172
-,   232,   234,   236,   238,   240,   242,   244,   247,   249,
+ /* YYNRULES -- Number of states. */
-,   255,   257,   259,   262,   264,   266,   268,   270,   273,
+ #define YYNSTATES  263
-,   277,   278,   284,   286,   288,   291,   294,   296,   298,
-,   304,   306,   308,   310,   312,   316,   320,   324,   327,
+ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-,   333,   336,   339,   342,   345,   348,   352,   356,   360,
+ #define YYUNDEFTOK  2
-,   368,   372,   376,   380,   384,   388,   392,   396,   400,
+ #define YYMAXUTOK   289
-,   408,   412,   416,   420,   424,   428,   432,   436,   440,
-,   448,   452,   456,   458,   460,   461
+ #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[] = {    62,
+ #if YYDEBUG
-,    61,     0,    63,     0,    61,    63,     0,    76,     0,
+ /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-,     0,    69,     0,    45,     4,    46,    65,     0,   145,
+    YYRHS.  */
-,    66,     0,    67,     0,    66,    67,     0,    68,    46,
+ static const unsigned short int yyprhs[] =
-,   145,     0,     4,     0,     0,    45,     4,    72,    71,
+ {
-,    46,    70,    76,     0,   145,     0,    72,     0,    47,
+,     0,     3,     5,     7,     9,    12,    14,    16,    18,
-,    48,     0,   145,     0,    74,     0,     4,     0,    74,
+,    25,    27,    29,    32,    35,    37,    39,    40,    49,
-,     4,     0,   145,     0,     4,     0,   145,     0,    77,
+,    53,    57,    59,    61,    63,    67,    69,    71,    73,
-,    78,     0,    77,    78,     0,   143,     0,    79,     0,
+,    77,    80,    82,    84,    86,    88,    90,    92,    95,
-,     0,    88,     0,   103,     0,    81,     0,    50,    82,
+,   100,   104,   106,   108,   110,   113,   115,   118,   122,
-,    84,     3,     0,    83,     0,    51,    84,    52,     0,
+,   126,   128,   130,   133,   136,   138,   140,   142,   143,
-,     0,    86,     0,    87,     0,   137,    87,     0,   127,
+,   150,   154,   158,   160,   162,   164,   166,   168,   170,
-,   124,   127,     0,    50,    89,    93,     0,    90,     0,
+,   175,   176,   177,   184,   186,   188,   191,   193,   195,
-,     0,    92,     0,   123,     0,    53,   123,     0,   137,
+,   198,   199,   205,   209,   213,   215,   219,   221,   225,
-,     0,    94,     0,    97,     0,    98,     0,     0,     0,
+,   231,   233,   235,   237,   239,   241,   243,   245,   248,
-,    95,    99,    96,    48,     0,    54,   140,    55,     0,
+,   253,   256,   258,   260,   263,   265,   267,   269,   271,
-,    76,    52,     0,   144,     0,     4,     0,   100,     0,
+,   277,   278,   279,   285,   287,   289,   292,   295,   297,
-,     0,   102,     0,    79,     0,    78,    77,     0,   104,
+,   302,   305,   307,   309,   311,   313,   315,   317,   321,
-,     0,     0,    56,   105,   107,   106,   108,     3,     0,
+,   329,   332,   335,   338,   341,   344,   347,   350,   353,
-,     0,   109,     0,   108,   109,     0,   110,     0,   113,
+,   361,   365,   369,   373,   377,   381,   385,   389,   393,
-,   114,     0,     0,     0,    47,   111,   115,   112,    48,
+,   401,   405,   409,   413,   417,   421,   425,   429,   433,
-,    54,   116,    55,     0,    51,   117,    52,     0,   118,
+,   441,   445,   449,   453,   457,   461,   463,   465,   467,
-,   115,    49,   118,     0,   119,     0,   116,    49,   119,
+,   470,   472
-,   120,     0,   117,    49,   120,     0,   121,     0,   122,
-,    76,     0,   144,     0,     4,     0,   100,     0,   140,
-,   128,     0,   124,   128,     0,   125,     0,   124,   125,
-,   126,    53,     0,   128,     0,   128,     0,     4,     5,
-,     4,     0,   129,     0,   130,     0,   131,     0,    50,
-,     0,     4,   135,     0,     0,     0,    47,   132,    77,
-,    48,     0,     4,     0,   136,     0,   135,   136,     0,
-,   134,     0,   138,     0,   139,     0,     4,    57,     0,
-,    57,     0,   141,     0,     4,     0,    81,     0,   104,
-,    58,   142,    58,     0,    59,   142,    59,     0,    54,
-,    55,     0,    37,   141,     0,    36,   141,     0,    43,
-,     0,    44,   141,     0,    27,   141,     0,    28,   141,
-,    29,   141,     0,    30,   141,     0,   141,    37,   141,
-,   141,    36,   141,     0,   141,    38,   141,     0,   141,
-,   141,     0,   141,    41,   141,     0,   141,    40,   141,
-,   141,    19,   141,     0,   141,    20,   141,     0,   141,
-,   141,     0,   141,    34,   141,     0,   141,    14,   141,
-,   141,    11,   141,     0,   141,    12,   141,     0,   141,
-,   141,     0,   141,    32,   141,     0,   141,    33,   141,
-,   141,    15,   141,     0,   141,    16,   141,     0,   141,
-,   141,     0,   141,    18,   141,     0,   141,    21,   141,
-,   141,    22,   141,     0,   141,    23,   141,     0,   141,
-,   141,     0,   141,    25,   141,     0,   141,    26,   141,
-,   141,    31,   141,     0,    76,     0,     4,     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[] =
-,   128,   130,   130,   131,   133,   133,   135,   207,   207,
+ {
-,   208,   209,   210,   210,   212,   247,   252,   252,   253,
+,   132,   132,   139,   141,   141,   142,   144,   144,   146,
-,   254,   255,   255,   257,   257,   261,   261,   263,   263,
+,   247,   248,   248,   249,   250,   250,   252,   252,   302,
-,   264,   265,   265,   265,   269,   276,   277,   277,   278,
+,   303,   304,   304,   305,   305,   307,   307,   311,   311,
-,   281,   282,   304,   305,   305,   309,   313,   315,   316,
+,   313,   314,   314,   315,   315,   315,   319,   348,   349,
-,   334,   339,   341,   343,   344,   346,   349,   351,   357,
+,   350,   352,   353,   354,   405,   406,   406,   410,   423,
-,   371,   373,   374,   376,   382,   383,   383,   387,   393,
+,   425,   426,   443,   448,   451,   452,   453,   455,   458,
-,   399,   412,   414,   414,   415,   417,   418,   420,   423,
+,   466,   474,   481,   482,   483,   485,   491,   492,   492,
-,   426,   427,   428,   430,   432,   434,   436,   438,   440,
+,   507,   510,   507,   538,   540,   540,   542,   543,   544,
-,   448,   452,   454,   455,   457,   466,   466,   468,   468,
+,   549,   546,   552,   553,   555,   556,   559,   560,   563,
-,   470,   478,   483,   485,   487,   488,   489,   491,   495,
+,   566,   569,   583,   588,   589,   590,   595,   595,   597,
-,   507,   509,   515,   520,   520,   521,   526,   528,   530,
+,   598,   599,   607,   612,   615,   616,   617,   618,   620,
-,   554,   559,   561,   562,   563,   564,   565,   567,   568,
+,   633,   636,   633,   644,   649,   649,   650,   656,   657,
-,   570,   571,   572,   573,   574,   576,   577,   578,   579,
+,   676,   688,   690,   691,   692,   693,   694,   695,   696,
-,   581,   582,   583,   584,   585,   586,   587,   588,   589,
+,   699,   700,   701,   702,   703,   704,   705,   706,   708,
-,   591,   592,   593,   594,   595,   596,   597,   598,   599,
+,   710,   711,   712,   713,   714,   715,   716,   717,   718,
-,   601,   602,   605,   614,   619,   620
+,   720,   721,   722,   723,   724,   725,   726,   727,   728,
+,   730,   731,   732,   733,   734,   737,   742,   763,   768,
+,   770,   772
  };
  #endif
+ #if YYDEBUG || YYERROR_VERBOSE
- #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+ /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
- static const char * const yytname[] = {   "$","error","$undefined.","EON","STRING",
+ static const char *const yytname[] =
- "BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START",
+ {
- "BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE",
+   "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
- "\"&&\"","\"||\"","\"!||\"","\"!|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"<<\"",
+   "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
- "\">>\"","\"lt\"","\"gt\"","\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"",
+   "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
- "\"-f\"","\"-d\"","\"is\"","'<'","'>'","'|'","'&'","'+'","'-'","'*'","'/'","'\\\\'",
+   "BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
- "'%'","NUNARY","'~'","'!'","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'",
+   "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
- "'.'","'('","')'","'^'","':'","'\\\"'","'\\''","all","methods","one_big_piece",
+   "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
- "method","control_method","maybe_control_strings","control_strings","control_string",
+   "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
- "maybe_string","code_method","@1","maybe_bracketed_strings","bracketed_maybe_strings",
+   "\"false\"", "'<'", "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'",
- "maybe_strings","strings","maybe_comment","maybe_codes","codes","code","action",
+   "'\\\\'", "'%'", "NUNARY", "'~'", "'!'", "'@'", "'\\n'", "'['", "']'",
- "get","get_value","get_name_value","name_in_curly_rdive","name_without_curly_rdive",
+   "';'", "'$'", "'{'", "'}'", "'.'", "'('", "')'", "'^'", "':'", "'\"'",
- "name_without_curly_rdive_read","name_without_curly_rdive_class","name_without_curly_rdive_code",
+   "'''", "$accept", "all", "methods", "one_big_piece", "method",
- "put","name_expr_wdive","name_expr_wdive_root","name_expr_wdive_write","name_expr_wdive_class",
+   "control_method", "maybe_control_strings", "control_strings",
- "construct","construct_square","@2","@3","construct_round","construct_curly",
+   "control_string", "maybe_string", "code_method", "@1",
- "any_constructor_code_value","constructor_code_value","constructor_code","codes__excluding_sole_str_literal",
+   "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
- "call","call_value","@4","@5","call_name","store_params","store_param","store_square_param",
+   "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
- "@6","@7","store_round_param","store_curly_param","store_code_param_parts","store_expr_param_parts",
+   "get", "get_value", "get_name_value", "name_in_curly_rdive",
- "store_curly_param_parts","store_code_param_part","store_expr_param_part","store_curly_param_part",
+   "name_without_curly_rdive", "name_without_curly_rdive_read",
- "code_param_value","write_expr_value","name_expr_dive_code","name_path","name_step",
+   "name_without_curly_rdive_class", "name_without_curly_rdive_code", "put",
- "name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",
+   "name_expr_wdive", "name_expr_wdive_root", "name_expr_wdive_write",
- "name_square_code_value","@8","@9","subvar_ref_name_rdive","subvar_get_writes",
+   "name_expr_wdive_class", "construct", "construct_square", "@2", "@3",
- "subvar__get_write","class_prefix","class_static_prefix","class_constructor_prefix",
+   "construct_round", "construct_curly", "any_constructor_code_value",
- "expr_value","expr","string_inside_quotes_value","write_string","void_value",
+   "constructor_code_value", "constructor_code",
- "empty", NULL
+   "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
-,    60,    61,    61,    62,    63,    63,    64,    65,    65,
+ /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-,    66,    67,    68,    68,    70,    69,    71,    71,    72,
+    token YYLEX-NUM.  */
-,    73,    74,    74,    75,    75,    76,    76,    77,    77,
+ static const unsigned short int yytoknum[] =
-,    78,    79,    79,    79,    80,    81,    82,    82,    83,
+ {
-,    84,    85,    86,    87,    87,    88,    89,    89,    89,
+,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-,    91,    92,    93,    93,    93,    95,    96,    94,    97,
+,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-,    99,    99,    99,   100,   101,   102,   102,   103,   105,
+,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-,   104,   107,   108,   108,   109,   109,   109,   111,   112,
+,   286,   287,   288,    60,    62,   124,    38,    43,    45,
-,   113,   114,   115,   115,   116,   116,   117,   117,   118,
+,    47,    92,    37,   289,   126,    33,    64,    10,    91,
-,   120,   121,   121,   121,   122,   123,   123,   124,   124,
+,    59,    36,   123,   125,    46,    40,    41,    94,    58,
-,   126,   127,   127,   128,   128,   128,   128,   129,   130,
+,    39
-,   133,   131,   134,   135,   135,   136,   137,   137,   138,
-,   140,   141,   141,   141,   141,   141,   141,   141,   141,
-,   141,   141,   141,   141,   141,   141,   141,   141,   141,
-,   141,   141,   141,   141,   141,   141,   141,   141,   141,
-,   141,   141,   141,   141,   141,   141,   141,   141,   141,
-,   141,   141,   142,   143,   144,   145
  };
+ # 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,     0,     8,     1,     1,     3,
+ {
-,     1,     1,     3,     1,     1,     1,     1,     1,     2,
+,    62,    63,    63,    64,    64,    65,    66,    66,    67,
-,     1,     1,     1,     1,     1,     2,     2,     1,     3,
+,    68,    69,    69,    70,    71,    71,    73,    72,    74,
-,     1,     1,     2,     1,     2,     3,     1,     1,     1,
+,    75,    76,    76,    77,    77,    78,    78,    79,    79,
-,     2,     2,     1,     1,     1,     0,     0,     5,     3,
+,    80,    81,    81,    82,    82,    82,    83,    84,    85,
-,     1,     1,     1,     1,     1,     1,     2,     1,     0,
+,    86,    87,    87,    88,    89,    90,    90,    91,    92,
-,     6,     1,     1,     2,     1,     1,     1,     0,     0,
+,    92,    93,    94,    95,    96,    96,    96,    98,    99,
-,     3,     3,     1,     3,     1,     3,     1,     3,     1,
+,   100,   101,   102,   102,   102,   103,   104,   105,   105,
-,     1,     1,     1,     1,     1,     1,     2,     1,     2,
+,   108,   109,   107,   110,   111,   111,   112,   112,   112,
-,     1,     1,     2,     1,     1,     1,     1,     2,     2,
+,   115,   113,   116,   117,   118,   118,   119,   119,   120,
-,     0,     5,     1,     1,     2,     2,     1,     1,     2,
+,   121,   122,   123,   124,   124,   124,   125,   125,   126,
-,     1,     1,     1,     1,     3,     3,     3,     2,     2,
+,   127,   128,   129,   129,   130,   130,   130,   130,   131,
-,     2,     2,     2,     2,     2,     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,     3,     3,     3,     3,     3,     3,
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
-,     3,     3,     1,     1,     0,     0
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   143,   143,   143,   143,   143,   143,   143,
+,   143,   143,   143,   143,   143,   144,   145,   146,   147,
+,   149,   150
  };
- static const short yydefact[] = {   167,
+ /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-,     0,     0,    70,     2,     1,     3,     6,     7,     5,
+ static const unsigned char yyr2[] =
-,    29,    32,    33,    36,    34,    35,    69,    31,    27,
+ {
-,   105,   111,     0,     0,     0,    37,    39,     0,    41,
+,     2,     1,     1,     1,     2,     1,     1,     1,     4,
-,    43,     0,    48,    49,    50,    51,     0,    99,     0,
+,     1,     1,     2,     2,     1,     1,     0,     8,     1,
-,    97,   106,   107,   108,     0,   118,   119,     0,     4,
+,     3,     1,     1,     1,     3,     1,     1,     1,     1,
-,   167,   167,   167,   104,     0,   120,   110,   115,     0,
+,     2,     1,     1,     1,     1,     1,     1,     2,     2,
-,   109,     0,     0,   103,     0,   105,    52,     0,    97,
+,     3,     1,     1,     1,     2,     1,     2,     3,     1,
-,    57,   167,     0,    47,    54,    55,    56,   105,   100,
+,     1,     1,     2,     2,     1,     1,     1,     0,     0,
-,    98,   101,    44,    53,   121,    73,    71,    15,     8,
+,     3,     3,     1,     1,     1,     1,     1,     1,     2,
-,    11,     0,     9,    23,     0,    22,    21,   167,    19,
+,     0,     0,     6,     1,     1,     2,     1,     1,     1,
-,   117,   116,   112,    40,    98,   166,     0,   123,     0,
+,     0,     5,     3,     3,     1,     3,     1,     3,     1,
-,     0,     0,     0,     0,     0,     0,     0,     0,   167,
+,     1,     1,     1,     1,     1,     1,     1,     2,     1,
-,   124,   125,     0,   122,     0,    12,    14,    13,    20,
+,     2,     1,     1,     2,     1,     1,     1,     1,     2,
-,    26,     0,    25,     0,   165,     0,    32,    58,    64,
+,     0,     0,     5,     1,     1,     2,     2,     1,     1,
-,    66,    62,    61,   133,   134,   135,   136,   130,   129,
+,     2,     1,     1,     1,     1,     1,     1,     3,     3,
-,   132,     0,   164,     0,     0,    60,     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,     0,     0,    79,   167,     0,     0,    74,    76,
+,     3,     3,     3,     3,     3,     1,     1,     1,     0,
-,    78,    24,    16,   113,    68,     0,   128,   126,   127,
+,     1,     0
-,   149,   150,   147,   153,   154,   155,   156,   143,   144,
-,   158,   159,   160,   161,   162,   163,   151,   152,   146,
-,   138,   137,   139,   140,   142,   141,   166,    92,     0,
-,     0,    86,    91,    96,    72,    75,   167,    59,   165,
-,    80,    84,    90,    93,   167,    83,     0,    82,    17,
-,     0,    89,    87,    85,    81,     0,     0,     0
  };
- static const short yydefgoto[] = {   257,
+ /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-,     6,     7,     8,    90,    91,    92,    93,     9,   238,
+    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-,    54,    96,    97,   133,   154,    11,    12,    13,    14,
+    means the default is an error.  */
-,    27,    28,    29,    30,    31,    32,    16,    33,    34,
+ static const unsigned char yydefact[] =
-,    36,    75,    76,   107,   197,    77,    78,   139,   241,
+ {
-,   142,    17,   123,    49,   126,    88,   188,   189,   190,
+,   168,     0,     0,    71,     0,     3,     2,     4,     7,
-,   252,   191,   192,   242,   232,   230,   243,   233,   231,
+,     6,    29,    30,    33,    34,    37,    35,    36,    70,
-,   234,    37,    64,    39,    40,    41,    65,    43,    44,
+,    28,     0,   105,   111,     0,     0,     0,    38,    40,
-,    60,   135,    62,    58,    59,    66,    47,    48,   235,
+,    42,    43,    44,     0,    49,    50,    51,    52,     0,
-,   155,    19,   245,    20
+,     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[] = {    34,
+ /* YYDEFGOTO[NTERM-NUM]. */
- -32768,    16,    61,-32768,   -19,-32768,-32768,-32768,-32768,-32768,
+ static const short int yydefgoto[] =
-,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ {
-    -14,     9,-32768,    30,    94,   106,-32768,-32768,    44,-32768,
+       -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
- -32768,-32768,   -26,-32768,-32768,-32768,-32768,   111,-32768,    -2,
+,   244,   101,    56,    98,    99,   140,   161,    12,    13,
- -32768,     5,-32768,-32768,-32768,   111,    -4,-32768,    94,-32768,
+,    15,   126,    28,    29,    30,    31,    32,    33,    17,
- -32768,    65,    72,    31,-32768,    30,-32768,    41,-32768,    11,
+,    35,    36,    37,    77,    78,   109,   204,    79,    80,
- -32768,-32768,    28,   111,    40,   111,    41,-32768,   106,    40,
+,   247,   148,   149,    18,   127,    50,   133,    90,   195,
- -32768,-32768,    11,    27,-32768,-32768,-32768,-32768,    18,-32768,
+,   197,   235,   258,   198,   199,   248,   239,   237,   249,
- -32768,     5,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+,   238,   250,    38,    66,    40,    41,    42,    67,    44,
-,-32768,    59,    67,-32768,    70,    77,-32768,   115,-32768,
+,    46,    62,   142,    64,    60,    61,    68,    48,    49,
- -32768,-32768,-32768,    11,-32768,    40,    38,    75,-32768,    27,
+,   129,   130,   162,    20,   251,   131,   132,    21
-,    27,    27,    27,    27,    27,    27,    83,    27,    11,
-,-32768,-32768,    73,   315,    78,-32768,-32768,-32768,-32768,
-,-32768,    89,-32768,    88,    90,    11,    -3,-32768,-32768,
- -32768,-32768,-32768,-32768,   140,   140,   140,   140,-32768,-32768,
- -32768,-32768,   270,-32768,    84,    87,-32768,    27,    27,    27,
-,    27,    27,    27,    27,    27,    27,    27,    27,    27,
-,    27,    27,    27,    27,    27,    27,    27,    27,    27,
-,    27,    27,    27,-32768,    11,    27,    45,-32768,-32768,
- -32768,-32768,-32768,-32768,-32768,    11,    95,-32768,-32768,-32768,
-,   377,   346,   278,   433,   433,   131,   131,   154,   154,
-,   433,   433,   433,   131,   131,   140,   433,   433,   164,
-,   178,   178,-32768,-32768,-32768,-32768,    39,-32768,   -25,
- -32768,   -33,-32768,-32768,-32768,-32768,-32768,    11,-32768,    68,
- -32768,   100,-32768,-32768,-32768,    11,-32768,    27,-32768,-32768,
-,   104,-32768,-32768,-32768,-32768,   155,   157,-32768
  };
- static const short yypgoto[] = {-32768,
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- -32768,-32768,   158,-32768,-32768,-32768,    82,-32768,-32768,-32768,
+    STATE-NUM.  */
- -32768,   110,-32768,-32768,-32768,     1,   -55,    -7,  -104,-32768,
+ #define YYPACT_NINF -107
-,-32768,-32768,   -13,-32768,-32768,   -27,-32768,-32768,-32768,
+ static const short int yypact[] =
- -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   107,
+ {
- -32768,-32768,-32768,     2,-32768,-32768,-32768,-32768,    -6,-32768,
+,  -107,    13,    45,  -107,    28,   -15,  -107,  -107,  -107,
- -32768,-32768,-32768,-32768,-32768,-32768,-32768,   -66,   -51,   -24,
+     -107,  -107,    21,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
- -32768,-32768,    -9,     4,   -29,-32768,   -20,     3,-32768,-32768,
+     -107,  -107,    73,    19,  -107,    50,     6,    44,  -107,  -107,
- -32768,-32768,-32768,   167,-32768,   162,   221,-32768,-32768,   151,
+,  -107,  -107,  -107,   -34,  -107,  -107,  -107,  -107,    65,
-,   105,-32768,   120,    49
+     -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          482
+ 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,   138,    51,   104,    42,    38,  -103,    80,    89,
+     -106,  -107,     0,  -107,  -107,    -6,  -107,  -107,   -21,  -107,
-,    63,    18,    55,     1,   248,    68,    81,    84,    21,
+     -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,
-,   249,    55,   246,    73,     2,   247,    74,    70,    69,
+     -107,   118,  -107,  -107,  -107,     2,  -107,  -107,  -107,  -107,
-,    52,    53,    61,    80,    87,    85,     1,    84,    80,
+,  -107,  -107,  -107,  -107,  -107,  -107,  -107,  -107,   -17,
-,   136,   240,    81,   -67,   -67,    71,   236,    42,    38,
+      -13,   -16,  -107,   -18,     4,    41,  -107,   -23,     3,  -107,
-,  -167,    86,   110,   111,   112,   113,  -102,    56,    15,
+     -107,  -107,  -107,  -107,   181,  -107,   183,   239,  -107,  -107,
-,    18,   114,   115,    22,    57,     4,    56,    89,   116,
+,    95,  -107,   123,  -107,   142,  -107,  -107,    64
-,   106,    15,   108,    18,    95,   118,    53,     2,   105,
-,   196,     4,     3,   120,   121,    22,     3,     3,     4,
-,   185,  -102,     4,     4,   186,    51,    22,   187,   137,
-,    98,   101,    15,   129,    18,    15,    23,    18,    67,
-,    25,   -14,    26,    79,   -94,   -94,   130,   132,    15,
-,    18,    18,   138,   185,   131,   144,   157,   186,    23,
-,   187,    24,    25,   194,   195,    15,   -63,    18,   128,
-,   199,   239,    24,   161,   200,   138,   134,   251,   166,
-,   256,    23,   161,   258,    24,   259,    23,   166,   167,
-,   174,    50,   100,   177,   178,   179,   180,   181,   182,
-,   184,   127,   177,   178,   179,   180,   181,   182,   183,
-,   237,   166,   167,   255,    15,   229,    18,    51,   179,
-,   181,   182,   183,   184,    15,   254,    18,   178,   179,
-,   181,   182,   183,   184,   145,   146,   147,   148,   149,
-,   151,   152,   140,   153,   181,   182,   183,   184,   103,
-,   253,   102,    46,   124,   156,   143,    15,     0,    18,
-,     0,     0,     0,     0,     0,     0,    15,   250,    18,
-,     0,     0,   137,     0,    15,   229,    18,     0,     0,
-,     0,    18,   201,   202,   203,   204,   205,   206,   207,
-,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-,   159,   160,   161,   162,   163,   164,   165,   166,   167,
-,   169,   170,   171,   172,   173,   166,   167,     0,     0,
-,   175,   176,   177,   178,   179,   180,   181,   182,   183,
-,   177,   178,   179,   180,   181,   182,   183,   184,     0,
-,     0,     0,     0,   198,   158,   159,   160,   161,   162,
-,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-,     0,     0,     0,     0,   174,   175,   176,   177,   178,
-,   180,   181,   182,   183,   184,   158,   159,     0,   161,
-,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-,   173,     0,     0,     0,     0,   174,   175,   176,   177,
-,   179,   180,   181,   182,   183,   184,   158,     0,     0,
-,   162,   163,   164,   165,   166,   167,   168,   169,   170,
-,   172,   173,     0,     0,     0,     0,   174,   175,   176,
-,   178,   179,   180,   181,   182,   183,   184,   161,   162,
-,   164,   165,   166,   167,   168,   169,   170,   171,   172,
-,     0,     0,     0,     0,   174,   175,   176,   177,   178,
-,   180,   181,   182,   183,   184,   161,     0,     0,   164,
-,   166,   167,     0,     0,     0,     0,   172,   173,   166,
-,     0,     0,   174,     0,     0,   177,   178,   179,   180,
-,   182,   183,   184,     0,     0,   179,   180,   181,   182,
-,   184
  };
- static const short yycheck[] = {     0,
+ /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-,     0,   107,    11,    60,     3,     3,     3,    38,     4,
+    positive, shift that token.  If negative, reduce the rule which
-,    25,    11,     5,     4,    49,    26,    38,    46,     4,
+    number is the opposite.  If zero, do what YYDEFACT says.
-,    55,     5,    49,    51,    45,    52,    54,    26,    26,
+    If YYTABLE_NINF, syntax error.  */
-,    46,    47,     4,    64,    49,    46,     4,    66,    69,
+ #define YYTABLE_NINF -173
-,     4,     4,    64,    48,    49,     3,     3,    46,    46,
+ static const short int yytable[] =
-,    46,    57,    27,    28,    29,    30,    53,    50,    60,
+ {
-,    60,    36,    37,     4,    57,    56,    50,     4,    43,
+,    11,    19,   145,   106,    53,    43,    39,  -103,    70,
-,    69,    73,    73,    73,     4,    50,    47,    45,    52,
+,   111,    16,    91,    19,    74,    83,    22,     1,    75,
-,   137,    56,    50,    58,    59,     4,    50,    50,    56,
+,   254,    76,    57,    57,     1,    86,   255,    51,    87,
-,    47,    53,    56,    56,    51,   104,     4,    54,   107,
+,    71,     2,   143,   112,   113,   114,   115,   242,   116,
-,    53,    54,   104,    46,   104,   107,    47,   107,     4,
+,   246,    84,    83,    89,   118,   119,    86,    69,    23,
-,    51,    46,    53,     4,    48,    49,    48,     4,   120,
+,    39,   120,   121,    63,    24,    23,  -172,    25,   122,
-,   120,   121,   228,    47,    49,    52,    55,    51,    47,
+     -102,     2,    16,   123,    19,     4,     3,   124,   125,    81,
-,    54,    50,    51,    46,    48,   137,    48,   137,    91,
+,    58,     4,     3,   108,    16,   110,    19,    59,     4,
-,    58,    48,    50,    14,    59,   251,    99,    49,    19,
+,     3,   252,    88,   192,   253,   203,     4,   193,     3,
-,    48,    47,    14,     0,    50,     0,    47,    19,    20,
+,   194,    91,    24,    24,     4,    25,    25,    26,    53,
-,    31,     5,    54,    34,    35,    36,    37,    38,    39,
+,    24,   144,    85,    25,    26,    16,    82,    19,    16,
-,    41,    91,    34,    35,    36,    37,    38,    39,    40,
+,    19,    82,    97,    24,   173,   174,    25,    96,   100,
-,   188,    19,    20,   251,   186,   186,   186,   196,    36,
+,    54,    55,    55,    16,    16,    19,    19,    58,   145,
-,    38,    39,    40,    41,   196,   248,   196,    35,    36,
+      -68,   -68,   184,   185,   186,   187,   188,   189,   190,   191,
-,    38,    39,    40,    41,   110,   111,   112,   113,   114,
+,   192,   136,   137,    16,   193,    19,   -15,   194,   168,
-,   116,   117,   107,   119,    38,    39,    40,    41,    58,
+,   145,   171,   172,   173,   174,  -102,   135,   -95,   -95,
-,   246,    56,     3,    74,   121,   107,   228,    -1,   228,
+,   180,   168,   138,   151,   141,   181,   173,   174,   200,
-     -1,    -1,    -1,    -1,    -1,    -1,    -1,   238,   238,   238,
+,   184,   185,   186,   187,   188,   189,   190,   191,   181,
-     -1,    -1,    -1,   251,    -1,   246,   246,   246,    -1,    -1,
+,   189,   190,   191,   184,   185,   186,   187,   188,   189,
-,    -1,   251,   158,   159,   160,   161,   162,   163,   164,
+,   191,   201,    16,   236,    19,    53,   202,   206,   -64,
-,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+,   173,   174,    16,   245,    19,   257,   152,   153,   154,
-,   176,   177,   178,   179,   180,   181,   182,   183,   184,
+,   262,    52,   156,   157,   158,   159,   134,   160,   185,
-,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+,   187,   188,   189,   190,   191,   102,   147,   144,   186,
-,    22,    23,    24,    25,    26,    19,    20,    -1,    -1,
+,   188,   189,   190,   191,    16,   259,    19,   243,   104,
-,    32,    33,    34,    35,    36,    37,    38,    39,    40,
+,   260,    47,   105,    16,   256,    19,   128,   163,     0,
-,    34,    35,    36,    37,    38,    39,    40,    41,    -1,
+,   150,    16,   236,    19,     0,     0,    16,     0,    19,
-     -1,    -1,    -1,    -1,    55,    11,    12,    13,    14,    15,
+,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-,    -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,
+,   229,   230,   231,   232,   233,   234,   165,   166,   167,
-,    37,    38,    39,    40,    41,    11,    12,    -1,    14,
+,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,   179,   180,   173,   174,     0,     0,   181,     0,     0,
-,    26,    -1,    -1,    -1,    -1,    31,    32,    33,    34,
+,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-,    36,    37,    38,    39,    40,    41,    11,    -1,    -1,
+,   185,   186,   187,   188,   189,   190,   191,     0,     0,
-,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+,     0,     0,   205,   165,   166,   167,   168,   169,   170,
-,    25,    26,    -1,    -1,    -1,    -1,    31,    32,    33,
+,   172,   173,   174,   175,   176,   177,   178,   179,   180,
-,    35,    36,    37,    38,    39,    40,    41,    14,    15,
+,     0,     0,     0,   181,     0,     0,   182,   183,   184,
-,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,   186,   187,   188,   189,   190,   191,   165,   166,     0,
-,    -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,
+,   169,   170,   171,   172,   173,   174,   175,   176,   177,
-,    37,    38,    39,    40,    41,    14,    -1,    -1,    17,
+,   179,   180,     0,     0,     0,     0,   181,     0,     0,
-,    19,    20,    -1,    -1,    -1,    -1,    25,    26,    19,
+,   183,   184,   185,   186,   187,   188,   189,   190,   191,
-,    -1,    -1,    31,    -1,    -1,    34,    35,    36,    37,
+,     0,     0,   168,   169,   170,   171,   172,   173,   174,
-,    39,    40,    41,    -1,    -1,    36,    37,    38,    39,
+,   176,   177,   178,   179,   180,     0,     0,     0,     0,
-,    41
+,     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,
+ static const short int yycheck[] =
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ {
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+,     0,     0,   109,    62,    12,     3,     3,     3,    27,
-    GNU General Public License for more details.
+,     4,    12,     4,    12,    49,    39,     4,     4,    53,
+,    51,    56,     5,     5,     4,    47,    57,     0,    47,
-    You should have received a copy of the GNU General Public License
+,    27,    47,     4,    27,    28,    29,    30,     3,    32,
-    along with this program; if not, write to the Free Software
+,     4,    39,    66,    50,    38,    39,    68,     4,     4,
-    Foundation, Inc., 59 Temple Place - Suite 330,
+,    47,    45,    46,     4,    49,     4,    48,    52,    52,
-    Boston, MA 02111-1307, USA.  */
+,    47,    62,    56,    62,    58,    52,    60,    61,     4,
+,    52,    58,    52,    71,    75,    75,    75,    59,    58,
- /* As a special exception, when this file is copied by Bison into a
+,    52,    51,    59,    49,    54,   144,    58,    53,    52,
-    Bison output file, you may use that output file without restriction.
+,    56,     4,    49,    49,    58,    52,    52,    53,   106,
-    This special exception was added by the Free Software Foundation
+,    49,   109,    55,    52,    53,   106,    66,   106,   109,
-    in version 1.24 of Bison.  */
+,   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 (i-- > 0)
+   while (*yys++ != '\0')
-     *t++ = *f++;
+     continue;
+   return yys - yystr - 1;
  }
+ #  endif
+ # endif
+ # ifndef yystpcpy
+ #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+ #   define yystpcpy stpcpy
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+ static char *
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystpcpy (char *yydest, const char *yysrc)
+ #   else
+ yystpcpy (yydest, yysrc)
+      char *yydest;
+      const char *yysrc;
+ #   endif
+ {
+   register char *yyd = yydest;
+   register const char *yys = yysrc;
- #else /* __cplusplus */
+   while ((*yyd++ = *yys++) != '\0')
+     continue;
- /* This is the most reliable way to avoid incompatibilities
+   return yyd - 1;
-    in available built-in functions on various systems.  */
+ }
+ #  endif
+ # endif
+ #endif /* !YYERROR_VERBOSE */
+ #if YYDEBUG
+ /*--------------------------------.
+ | Print this symbol on YYOUTPUT.  |
+ `--------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+ #else
  static void
- __yy_memcpy (char *to, char *from, unsigned int count)
+ yysymprint (yyoutput, yytype, yyvaluep)
+     FILE *yyoutput;
+     int yytype;
+     YYSTYPE *yyvaluep;
+ #endif
  {
-   register char *t = to;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *f = from;
+   (void) yyvaluep;
-   register int i = count;
+   if (yytype < YYNTOKENS)
+     {
+       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ # ifdef YYPRINT
+       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+ # endif
+     }
+   else
+     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
-   while (i-- > 0)
+   switch (yytype)
-     *t++ = *f++;
+     {
+       default:
+         break;
+     }
+   YYFPRINTF (yyoutput, ")");
  }
+ #endif /* ! YYDEBUG */
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yydestruct (int yytype, YYSTYPE *yyvaluep)
+ #else
+ static void
+ yydestruct (yytype, yyvaluep)
+     int yytype;
+     YYSTYPE *yyvaluep;
  #endif
- #endif
+ {
+   /* 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=0; /*paf:calm down, vc7 warning level 4*/
+   YYSTYPE yyval;
-   int yynerrs;
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylloc;
- #endif
- #endif
-   YYSTYPE yyval=0; /*paf:calm down, vc7 warning level 4*/               /*  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 805  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 917  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 YYLEN is nonzero, implement the default value of the action:
-   if (yydebug)
+      `$$ = $1'.
-     {
-       int i;
-       fprintf (stderr, "Reducing via rule %d (line %d), ",
+      Otherwise, the following line sets YYVAL to garbage.
-                yyn, yyrline[yyn]);
+      This behavior is undocumented and Bison
+      users should not rely upon it.  Assigning to YYVAL
+      unconditionally makes the parser a bit smaller, and it avoids a
+      GCC warning that YYVAL may be used uninitialized.  */
+   yyval = yyvsp[1-yylen];
-       /* Print the symbols being reduced, and their result.  */
-       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-     }
- #endif
+   YY_REDUCE_PRINT (yyn);
-   switch (yyn) {
+   switch (yyn)
+     {
- case 1:
+         case 2:
- #line 121 "compile.y"
+ #line 132 "compile.y"
- {
+     {
          Method& method=*new Method(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.alias_method(main_method_name), method);
- ;
+ ;}
-     break;}
+     break;
- case 8:
- #line 136 "compile.y"
+   case 9:
- {
+ #line 147 "compile.y"
+     {
          const String& command=*LA2S(*yyvsp[-2]);
          YYSTYPE strings_code=yyvsp[0];
          if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
- Line 1065  case 8:
+ Line 1450  case 8:
                  YYERROR;
          }
          if(command==CLASS_NAME) {
-                 if(PC.cclass->base_class()) { // already changed from default?
-                         strcpy(PC.error, "class already have a name '");
-                         strncat(PC.error, PC.cclass->name().cstr(), 100);
-                         strcat(PC.error, "'");
-                         YYERROR;
-                 }
                  if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                          // new class' name
                          const String& name=*LA2S(*strings_code);
                          // creating the class
                          VStateless_class* cclass=new VClass;
-                         PC.cclass=cclass;
+                         PC.cclass_new=cclass;
-                         PC.cclass->set_name(name);
+                         PC.cclass_new->set_name(name);
-                         // append to request's classes
-                         PC.request.classes().put(name, cclass);
                  } else {
                          strcpy(PC.error, "@"CLASS_NAME" must contain only one line with class name (contains more then one)");
                          YYERROR;
- Line 1088  case 8:
+ Line 1465  case 8:
                  for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE)
                          PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i));
          } else if(command==BASE_NAME) {
+                 if(PC.append){
+                         strcpy(PC.error, "can't set base while appending methods to class '");
+                         strncat(PC.error, PC.cclass->name().cstr(), MAX_STRING/2);
+                         strcat(PC.error, "'");
+                         YYERROR;
+                 }
+                 PC.class_add();
                  if(PC.cclass->base_class()) { // already changed from default?
                          strcpy(PC.error, "class already have a base '");
-                         strncat(PC.error, PC.cclass->base_class()->name().cstr(), 100);
+                         strncat(PC.error, PC.cclass->base_class()->name().cstr(), MAX_STRING/2);
                          strcat(PC.error, "'");
                          YYERROR;
                  }
- Line 1118  case 8:
+ Line 1502  case 8:
                          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 208 "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 212 "compile.y"
- {
+   case 17:
+ #line 252 "compile.y"
+     {
+         PC.class_add();
          PC.explicit_result=false;
-         const String& name=*LA2S(*yyvsp[-4]);
          YYSTYPE params_names_code=yyvsp[-3];
          ArrayString* params_names=0;
- Line 1147  case 16:
+ Line 1563  case 16:
          YYSTYPE locals_names_code=yyvsp[-2];
          ArrayString* locals_names=0;
+         bool all_vars_local=false;
          if(int size=locals_names_code->count()) {
                  locals_names=new ArrayString;
                  for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
                          const String* local_name=LA2S(*locals_names_code, i);
                          if(*local_name==RESULT_VAR_NAME)
                                  PC.explicit_result=true;
+                         else if(*local_name==OPTION_ALL_VARS_LOCAL_NAME)
+                                 all_vars_local=true;
                          else
                                  *locals_names+=local_name;
                  }
          }
+         if(!all_vars_local && PC.cclass && PC.cclass->is_vars_local())
+                 all_vars_local=true;
          Method* method=new Method(
                  //name,
                  Method::CT_ANY,
 , 0/*min,max numbered_params_count*/,
                  params_names, locals_names,
-/*to be filled later in next {} */, 0);
+/*to be filled later in next {} */, 0, all_vars_local);
-         PC.cclass->add_method(PC.alias_method(name), *method);
          *reinterpret_cast<Method**>(&yyval)=method;
          // todo: check [][;result;]
- ;
+ ;}
-     break;}
+     break;
- case 17:
- #line 247 "compile.y"
+   case 18:
- {
+ #line 292 "compile.y"
-         // fill in the code
+     {
-         reinterpret_cast<Method*>(yyvsp[-1])->parser_code=yyvsp[0];
+                 Method& method=*reinterpret_cast<Method*>(yyvsp[-1]);
- ;
+                 // fill in the code
-     break;}
+                 method.parser_code=yyvsp[0];
- case 20:
- #line 253 "compile.y"
+                 // register in class
- {yyval=yyvsp[-1];
+                 const String& name=*LA2S(*yyvsp[-6]);
-     break;}
+                 PC.cclass->add_method(PC.alias_method(name), method);
- case 24:
+ ;}
- #line 255 "compile.y"
+     break;
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
-     break;}
+   case 21:
- case 30:
+ #line 303 "compile.y"
- #line 263 "compile.y"
+     {yyval=yyvsp[-1];}
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+     break;
-     break;}
- case 36:
+   case 25:
- #line 269 "compile.y"
+ #line 305 "compile.y"
- {
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
-         yyval=yyvsp[0]; /* stack: resulting value */
+     break;
-         changetail_or_append(*yyval,
-                 OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
+   case 31:
-                 /*or */OP_WRITE_VALUE
+ #line 313 "compile.y"
-                 ); /* value=pop; wcontext.write(value) */
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- ;
+     break;
-     break;}
- case 37:
+   case 37:
- #line 276 "compile.y"
+ #line 319 "compile.y"
- { yyval=yyvsp[0] ;
+     {
-     break;}
+         yyval=N();
- case 40:
+         YYSTYPE code=yyvsp[0];
- #line 278 "compile.y"
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
- { yyval=yyvsp[-1] ;
+         if(!maybe_change_first_opcode(*code, OP::OP_VALUE__GET_ELEMENT, /*=>*/OP::OP_VALUE__GET_ELEMENT__WRITE))
-     break;}
+ #endif
- case 43:
- #line 282 "compile.y"
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
- {
+                 if(
+                         code->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(
+                         code->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 348 "compile.y"
+     { yyval=yyvsp[0] ;}
+     break;
+   case 41:
+ #line 350 "compile.y"
+     { yyval=yyvsp[-1] ;}
+     break;
+   case 44:
+ #line 354 "compile.y"
+     {
          yyval=N();
-         ArrayOperation* diving_code=yyvsp[0];
+         YYSTYPE diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
-         // self.xxx... -> xxx...
+         size_t count=diving_code->count();
+         // self.xxx... => xxx...
          // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
-                 O(*yyval, OP_WITH_SELF); /* stack: starting context */
+                 O(*yyval, OP::OP_WITH_SELF); /* stack: starting context */
                  P(*yyval, *diving_code,
                          /* skip over... */
-                         diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
+                         count>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP::OP_+origin+string*/);
+         }
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_ELEMENT
+         else if(maybe_make_get_object_element(*yyval, *diving_code, count)){
+                 // optimisation for $object.field + ^object.method[
+         }
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_OBJECT_VAR_ELEMENT
+         else if(maybe_make_get_object_var_element(*yyval, *diving_code, count)){
+                 // optimisation for $object.$var
+         }
+ #endif
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
+         else if(count==4){ // optimization
+                 O(*yyval,
+                         (PC.in_call_value)
+                         ? 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
          } else {
-                 O(*yyval, OP_WITH_READ); /* stack: starting context */
+                 O(*yyval, OP::OP_WITH_READ); /* stack: starting context */
+                 P(*yyval, *diving_code);
+         }
+ #else
+         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+origin+string+OP_GET_ELEMENT. -> OP_VALUE+origin+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->count()==4)
+                 if(PC.in_call_value && count==4)
-                         diving_code->put(4-1, OP_GET_ELEMENT_OR_OPERATOR);
+                         diving_code->put(count-1, OP::OP_GET_ELEMENT_OR_OPERATOR);
                  P(*yyval, *diving_code);
          }
+ #endif
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 44:
- #line 304 "compile.y"
+   case 45:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 405 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 46:
+     break;
- #line 305 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 47:
-     break;}
+ #line 406 "compile.y"
- case 47:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 309 "compile.y"
+     break;
- {
-         yyval=yyvsp[-1]; /* stack: context,name */
+   case 48:
-         P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
+ #line 410 "compile.y"
- ;
+     {
-     break;}
+         yyval=N();
- case 51:
+ #ifdef OPTIMIZE_BYTECODE_CONSTRUCT
- #line 317 "compile.y"
+         if(maybe_optimize_construct(*yyval, *yyvsp[-1], *yyvsp[0])){
- {
+                 // $a(expr), $.a(expr), $a[value], $.a[value]
+         } else
+ #endif
+         {
+                 P(*yyval, *yyvsp[-1]); /* stack: context,name */
+                 P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
+         }
+ ;}
+     break;
+   case 52:
+ #line 426 "compile.y"
+     {
          yyval=N();
-         ArrayOperation* diving_code=yyvsp[0];
+         YYSTYPE diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
-         // $self.xxx... -> $xxx...
+         // $self.xxx... => $xxx...
-         // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
+         // OP_VALUE+origin+string+OP_GET_ELEMENT+... => OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
-                 O(*yyval, OP_WITH_SELF); /* stack: starting context */
+                 O(*yyval, OP::OP_WITH_SELF); /* stack: starting context */
                  P(*yyval, *diving_code,
                          /* skip over... */
-                         diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
+                         diving_code->count()>=4?4/*OP::OP_VALUE+origin+string+OP::OP_GET_ELEMENTx*/:3/*OP::OP_+origin+string*/);
          } else {
-                 O(*yyval, OP_WITH_ROOT); /* stack: starting context */
+                 O(*yyval, OP::OP_WITH_ROOT); /* stack: starting context */
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 52:
- #line 334 "compile.y"
+   case 53:
- {
+ #line 443 "compile.y"
+     {
          yyval=N();
-         O(*yyval, OP_WITH_WRITE); /* stack: starting context */
+         O(*yyval, OP::OP_WITH_WRITE); /* stack: starting context */
          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
- ;
+ ;}
-     break;}
+     break;
- case 53:
- #line 339 "compile.y"
+   case 54:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 448 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 57:
+     break;
- #line 346 "compile.y"
- {
+   case 58:
+ #line 455 "compile.y"
+     {
          // allow $result_or_other_variable[ letters here any time ]
          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
- ;
+ ;}
-     break;}
+     break;
- case 58:
- #line 349 "compile.y"
+   case 59:
- {
+ #line 458 "compile.y"
+     {
          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
- ;
+ ;}
-     break;}
+     break;
- case 59:
- #line 351 "compile.y"
+   case 60:
- {
+ #line 460 "compile.y"
+     {
          // stack: context, name
          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 60:
- #line 357 "compile.y"
+   case 61:
- {
+ #line 466 "compile.y"
+     {
          yyval=N();
-         O(*yyval, OP_PREPARE_TO_EXPRESSION);
+         O(*yyval, OP::OP_PREPARE_TO_EXPRESSION);
          // stack: context, name
          P(*yyval, *yyvsp[-1]); // stack: context, name, value
-         O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
+         O(*yyval, OP::OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 61:
- #line 365 "compile.y"
+   case 62:
- {
+ #line 474 "compile.y"
+     {
          // stack: context, name
          yyval=N();
-         OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
+         OA(*yyval, OP::OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
- ;
+ ;}
-     break;}
+     break;
- case 65:
- #line 376 "compile.y"
+   case 66:
- {
+ #line 485 "compile.y"
+     {
          yyval=N();
-         OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
+         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 68:
- #line 383 "compile.y"
+   case 69:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 492 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 69:
+     break;
- #line 387 "compile.y"
- {
+   case 70:
-         yyval=yyvsp[0]; /* stack: value */
+ #line 496 "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 70:
+                 yyval=yyvsp[0]; /* stack: value */
- #line 393 "compile.y"
+                 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 507 "compile.y"
+     {
                                          PC.in_call_value=true;
-                         ;
+                         ;}
-     break;}
+     break;
- case 71:
- #line 396 "compile.y"
+   case 72:
- {
+ #line 510 "compile.y"
+     {
                                  PC.in_call_value=false;
-                         ;
+                         ;}
-     break;}
+     break;
- case 72:
- #line 399 "compile.y"
+   case 73:
- { /* ^field.$method{vasya} */
+ #line 513 "compile.y"
-         yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
+     { /* ^field.$method{vasya} */
+ #ifdef OPTIMIZE_BYTECODE_CUT_REM_OPERATOR
-         YYSTYPE params_code=yyvsp[-1];
+ #ifdef OPTIMIZE_BYTECODE_GET_ELEMENT
-         if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM]
+         const String* operator_name=LA2S(*yyvsp[-3], 0, OP::OP_VALUE__GET_ELEMENT_OR_OPERATOR);
-                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
+ #else
-                         if(!value->is_defined()) // value is VVoid?
+         const String* operator_name=LA2S(*yyvsp[-3], 1);
-                                 params_code=0; // ^zzz[] case. don't append lone empty param.
+ #endif
-         }
+         if(operator_name && *operator_name == REM_OPERATOR_NAME){
-         /* stack: context, method_junction */
+                 yyval=N();
-         OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
+         } else
- ;
+ #endif
-     break;}
+                 {
- case 75:
+                         yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
- #line 414 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+                         YYSTYPE params_code=yyvsp[-1];
-     break;}
+                         if(params_code->count()==3) { // probably [] case. [OP::OP_VALUE+origin+Void]
- case 79:
+                                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
- #line 420 "compile.y"
+                                         if(value->is_void()) // value is VVoid?
- {
+                                                 params_code=0; // ^zzz[] case. don't append lone empty param.
+                         }
+                         /* stack: context, method_junction */
+                         OA(*yyval, OP::OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
+                 }
+ ;}
+     break;
+   case 76:
+ #line 540 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 80:
+ #line 546 "compile.y"
+     {
          // allow ^call[ letters here any time ]
          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
- ;
+ ;}
-     break;}
+     break;
- case 80:
- #line 423 "compile.y"
+   case 81:
- {
+ #line 549 "compile.y"
+     {
          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
- ;
+ ;}
-     break;}
+     break;
- case 81:
- #line 425 "compile.y"
+   case 82:
- {yyval=yyvsp[-2];
+ #line 551 "compile.y"
-     break;}
+     {yyval=yyvsp[-2];}
- case 82:
+     break;
- #line 426 "compile.y"
- {yyval=yyvsp[-1];
+   case 83:
-     break;}
+ #line 552 "compile.y"
- case 83:
+     {yyval=yyvsp[-1];}
- #line 427 "compile.y"
+     break;
- {yyval=yyvsp[-1];
-     break;}
+   case 84:
- case 85:
+ #line 553 "compile.y"
- #line 430 "compile.y"
+     {yyval=yyvsp[-1];}
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+     break;
-     break;}
- case 87:
+   case 86:
- #line 434 "compile.y"
+ #line 556 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
-     break;}
+     break;
- case 89:
- #line 438 "compile.y"
+   case 88:
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+ #line 560 "compile.y"
-     break;}
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
- case 90:
+     break;
- #line 440 "compile.y"
- {
+   case 90:
+ #line 564 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 91:
+ #line 566 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(*yyval, OP_STORE_PARAM);
+ ;}
- ;
+     break;
-     break;}
- case 91:
+   case 92:
- #line 444 "compile.y"
+ #line 569 "compile.y"
- {
+     {
-         yyval=N();
+         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 92:
+         } else {
- #line 448 "compile.y"
+                 YYSTYPE code=N();
- {
+                 O(*code, OP::OP_PREPARE_TO_EXPRESSION);
-         yyval=N();
+                 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 96:
+         }
- #line 457 "compile.y"
+ ;}
- {
+     break;
+   case 93:
+ #line 583 "compile.y"
+     {
          yyval=N();
-         O(*yyval, OP_PREPARE_TO_EXPRESSION);
+         OA(*yyval, OP::OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
-         P(*yyval, *yyvsp[0]);
+ ;}
-         O(*yyval, OP_WRITE_EXPR_RESULT);
+     break;
- ;
-     break;}
+   case 98:
- case 98:
+ #line 595 "compile.y"
- #line 466 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+     break;
-     break;}
- case 100:
+   case 100:
- #line 468 "compile.y"
+ #line 597 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
-     break;}
+     break;
- case 102:
- #line 470 "compile.y"
+   case 102:
- {
+ #line 599 "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 103:
- #line 478 "compile.y"
+   case 103:
- {
+ #line 607 "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 109:
- #line 491 "compile.y"
+   case 109:
- {
+ #line 620 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(*yyval, OP_GET_ELEMENT);
+         O(*yyval, OP::OP_GET_ELEMENT);
- ;
+ ;}
-     break;}
+     break;
- case 110:
- #line 495 "compile.y"
+   case 110:
- {
+ #line 624 "compile.y"
-         ArrayOperation* code;
+     {
+         YYSTYPE code;
          {
                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
                  P(*code, *yyvsp[0]);
          }
          yyval=N();
-         OA(*yyval, OP_STRING_POOL, code);
+         OA(*yyval, OP::OP_STRING_POOL, code);
- ;
+ ;}
-     break;}
+     break;
- case 111:
- #line 504 "compile.y"
+   case 111:
- {
+ #line 633 "compile.y"
+     {
          // allow $result_or_other_variable[ letters here any time ]
          *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
- ;
+ ;}
-     break;}
+     break;
- case 112:
- #line 507 "compile.y"
+   case 112:
- {
+ #line 636 "compile.y"
+     {
          PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
- ;
+ ;}
-     break;}
+     break;
- case 113:
- #line 509 "compile.y"
+   case 113:
- {
+ #line 638 "compile.y"
+     {
          yyval=N();
-         OA(*yyval, OP_OBJECT_POOL, yyvsp[-2]); /* stack: empty write context */
+         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 114:
- #line 515 "compile.y"
+   case 114:
- {
+ #line 644 "compile.y"
+     {
          yyval=N();
-         O(*yyval, OP_WITH_READ);
+         O(*yyval, OP::OP_WITH_READ);
          P(*yyval, *yyvsp[0]);
- ;
+ ;}
-     break;}
+     break;
- case 116:
- #line 520 "compile.y"
+   case 116:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 649 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 117:
+     break;
- #line 521 "compile.y"
- {
+   case 117:
+ #line 650 "compile.y"
+     {
          yyval=yyvsp[0];
-         O(*yyval, OP_GET_ELEMENT__WRITE);
+         O(*yyval, OP::OP_GET_ELEMENT__WRITE);
- ;
+ ;}
-     break;}
+     break;
- case 120:
- #line 530 "compile.y"
+   case 120:
- {
+ #line 659 "compile.y"
+     {
          yyval=yyvsp[-1]; // stack: class name string
          if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
                  if(VStateless_class* base=PC.cclass->base_class()) {
- Line 1537  case 120:
+ Line 2089  case 120:
                          YYERROR;
                  }
          }
-         O(*yyval, OP_GET_CLASS);
+ #ifdef OPTIMIZE_BYTECODE_GET_CLASS
- ;
+         // optimized OP_VALUE+origin+string+OP_GET_CLASS => OP_VALUE__GET_CLASS+origin+string
-     break;}
+         maybe_change_first_opcode(*yyval, OP::OP_VALUE, OP::OP_VALUE__GET_CLASS, true/*assert if top opcode != OP_VALUE*/)
- case 121:
+ #else
- #line 542 "compile.y"
+         O(*yyval, OP::OP_GET_CLASS);
- {
+ #endif
+ ;}
+     break;
+   case 121:
+ #line 676 "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 122:
- #line 554 "compile.y"
+   case 128:
- {
+ #line 695 "compile.y"
-         // see OP_PREPARE_TO_EXPRESSION!!
+     { yyval = yyvsp[-1] ;}
-         if((yyval=yyvsp[0])->count()==2) // only one string literal in there?
+     break;
-                 change_string_literal_to_double_literal(*yyval); // make that string literal Double
- ;
+   case 129:
-     break;}
+ #line 696 "compile.y"
- case 126:
+     { yyval = yyvsp[-1] ;}
- #line 563 "compile.y"
+     break;
- { yyval = yyvsp[-1]; ;
-     break;}
+   case 130:
- case 127:
+ #line 697 "compile.y"
- #line 564 "compile.y"
+     { yyval = yyvsp[-1]; ;}
- { yyval = yyvsp[-1]; ;
+     break;
-     break;}
- case 128:
+   case 131:
- #line 565 "compile.y"
+ #line 699 "compile.y"
- { yyval = yyvsp[-1]; ;
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_NEG) ;}
-     break;}
+     break;
- case 129:
- #line 567 "compile.y"
+   case 132:
- { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;
+ #line 700 "compile.y"
-     break;}
+     { yyval=yyvsp[0] ;}
- case 130:
+     break;
- #line 568 "compile.y"
- { yyval=yyvsp[0] ;
+   case 133:
-     break;}
+ #line 701 "compile.y"
- case 131:
+     { yyval=yyvsp[0];    O(*yyval, OP::OP_INV) ;}
- #line 569 "compile.y"
+     break;
- { yyval=yyvsp[0];        O(*yyval, OP_INV) ;
-     break;}
+   case 134:
- case 132:
+ #line 702 "compile.y"
- #line 570 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_NOT) ;}
- { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;
+     break;
-     break;}
- case 133:
+   case 135:
- #line 571 "compile.y"
+ #line 703 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_DEF) ;}
-     break;}
+     break;
- case 134:
- #line 572 "compile.y"
+   case 136:
- { yyval=yyvsp[0];  O(*yyval, OP_IN) ;
+ #line 704 "compile.y"
-     break;}
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_IN) ;}
- case 135:
+     break;
- #line 573 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;
+   case 137:
-     break;}
+ #line 705 "compile.y"
- case 136:
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_FEXISTS) ;}
- #line 574 "compile.y"
+     break;
- { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;
-     break;}
+   case 138:
- case 137:
+ #line 706 "compile.y"
- #line 576 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP::OP_DEXISTS) ;}
- {       yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;
+     break;
-     break;}
- case 138:
+   case 139:
- #line 577 "compile.y"
+ #line 708 "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 139:
- #line 578 "compile.y"
+   case 140:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;
+ #line 709 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_ADD) ;}
- case 140:
+     break;
- #line 579 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;
+   case 141:
-     break;}
+ #line 710 "compile.y"
- case 141:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MUL) ;}
- #line 580 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;
-     break;}
+   case 142:
- case 142:
+ #line 711 "compile.y"
- #line 581 "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 143:
+   case 143:
- #line 582 "compile.y"
+ #line 712 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_MOD) ;}
-     break;}
+     break;
- case 144:
- #line 583 "compile.y"
+   case 144:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;
+ #line 713 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_INTDIV) ;}
- case 145:
+     break;
- #line 584 "compile.y"
- { yyval=yyvsp[-2];      P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;
+   case 145:
-     break;}
+ #line 714 "compile.y"
- case 146:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SL) ;}
- #line 585 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;
-     break;}
+   case 146:
- case 147:
+ #line 715 "compile.y"
- #line 586 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_SR) ;}
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;
+     break;
-     break;}
- case 148:
+   case 147:
- #line 587 "compile.y"
+ #line 716 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_AND) ;}
-     break;}
+     break;
- case 149:
- #line 588 "compile.y"
+   case 148:
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;
+ #line 717 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_OR) ;}
- case 150:
+     break;
- #line 589 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;
+   case 149:
-     break;}
+ #line 718 "compile.y"
- case 151:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_BIN_XOR) ;}
- #line 590 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;
-     break;}
+   case 150:
- case 152:
+ #line 719 "compile.y"
- #line 591 "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_GT) ;
+     break;
-     break;}
- case 153:
+   case 151:
- #line 592 "compile.y"
+ #line 720 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;
+     { yyval=yyvsp[-2];  OA(*yyval, OP::OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP::OP_LOG_OR) ;}
-     break;}
+     break;
- case 154:
- #line 593 "compile.y"
+   case 152:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;
+ #line 721 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_LOG_XOR) ;}
- case 155:
+     break;
- #line 594 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;
+   case 153:
-     break;}
+ #line 722 "compile.y"
- case 156:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LT) ;}
- #line 595 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;
-     break;}
+   case 154:
- case 157:
+ #line 723 "compile.y"
- #line 596 "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_LT) ;
+     break;
-     break;}
- case 158:
+   case 155:
- #line 597 "compile.y"
+ #line 724 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_LE) ;}
-     break;}
+     break;
- case 159:
- #line 598 "compile.y"
+   case 156:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;
+ #line 725 "compile.y"
-     break;}
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_GE) ;}
- case 160:
+     break;
- #line 599 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;
+   case 157:
-     break;}
+ #line 726 "compile.y"
- case 161:
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_EQ) ;}
- #line 600 "compile.y"
+     break;
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;
-     break;}
+   case 158:
- case 162:
+ #line 727 "compile.y"
- #line 601 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_NUM_NE) ;}
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;
+     break;
-     break;}
- case 163:
+   case 159:
- #line 602 "compile.y"
+ #line 728 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_LT) ;}
-     break;}
+     break;
- case 164:
- #line 605 "compile.y"
+   case 160:
- {
+ #line 729 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_GT) ;}
+     break;
+   case 161:
+ #line 730 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_LE) ;}
+     break;
+   case 162:
+ #line 731 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_GE) ;}
+     break;
+   case 163:
+ #line 732 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_EQ) ;}
+     break;
+   case 164:
+ #line 733 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_STR_NE) ;}
+     break;
+   case 165:
+ #line 734 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP::OP_IS) ;}
+     break;
+   case 166:
+ #line 737 "compile.y"
+     {
+         // optimized OP_STRING => OP_VALUE for doubles
+         maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
+ ;}
+     break;
+   case 167:
+ #line 742 "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_STRING_POOL, yyvsp[0]); /* stack: empty write context */
+         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 165:
- #line 614 "compile.y"
+   case 168:
- {
+ #line 763 "compile.y"
-         // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
+     {
+         // optimized OP_STRING+OP_WRITE_VALUE => OP_STRING__WRITE
          change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
- ;
+ ;}
-     break;}
+     break;
- case 166:
- #line 619 "compile.y"
+   case 169:
- { yyval=VL(new VVoid(), 0, 0, 0) ;
+ #line 768 "compile.y"
-     break;}
+     { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0) ;}
- case 167:
+     break;
- #line 620 "compile.y"
- { yyval=N() ;
+   case 170:
-     break;}
+ #line 769 "compile.y"
- }
+     { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vtrue), 0, 0, 0) ;}
-    /* the action file gets copied in in place of this dollarsign */
+     break;
- #line 543 "/usr/share/bison.simple"
+   case 171:
+ #line 770 "compile.y"
+     { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0) ;}
+     break;
+   case 172:
+ #line 772 "compile.y"
+     { yyval=N() ;}
+     break;
+     }
+ /* Line 1010 of yacc.c.  */
+ #line 2366 "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 622 "compile.y"
+ #line 774 "compile.y"
  #endif
- Line 2050  case LS_DEF_COMMENT:
+ Line 2680  case LS_DEF_COMMENT:
  default:
                          switch(*pc.source) {
                          // ^escaping some punctuators
-                         case '^': case '$': case ';':
+                         case '^': case '$': case ';': case '@':
                          case '(': case ')':
                          case '[': case ']':
                          case '{': case '}':
- Line 2078  default:
+ Line 2708  default:
                                          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 c=
+                                         char c=(char)(
                                                  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) {
                                                  result=BAD_HEX_LITERAL;
                                                  goto break2; // wrong hex value[no ^#00 chars allowed]: bail out
- Line 2097  default:
+ Line 2727  default:
                                          // 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;
                          }
- Line 2394  default:
+ Line 3031  default:
                          case 'd':
                                  if(end==begin) // right after whitespace
                                          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 2475  default:
+ Line 3132  default:
                          case '=': case '!':
                          // common delimiters
                          case ',': case '?': case '#':
+                         // mysql column separators
+                         case '`':
                          // before call
                          case '^':
                                  pop_LS(pc);
- Line 2737  static void yyprint(FILE *file, int type
+ Line 3396  static void yyprint(FILE *file, int type
          if(type==STRING)
                  fprintf(file, " \"%s\"", LA2S(*value)->cstr());
  }

E-mail:

Removed from v.1.102
changed lines
	Added in v.1.137