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.88.2.1 and 1.114

-version 1.88.2.1, 2003/09/25 09:06:35
+version 1.114, 2007/10/17 13:34:59
  Line 1
+ /* A Bison parser, made by GNU Bison 1.875d.  */
- /*  A Bison parser, made from compile.y
+ /* Skeleton parser for Yacc-like parsing with Bison,
-     by GNU Bison version 1.28  */
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
- #define YYBISON 1  /* Identify Bison output.  */
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+    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
- #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_MATH_OPERATOR_CHARACTER     264
- #define LAND    265
- #define LOR     266
- #define LXOR    267
- #define NXOR    268
- #define NLE     269
- #define NGE     270
- #define NEQ     271
- #define NNE     272
- #define NSL     273
- #define NSR     274
- #define SLT     275
- #define SGT     276
- #define SLE     277
- #define SGE     278
- #define SEQ     279
- #define SNE     280
- #define DEF     281
- #define IN      282
- #define FEXISTS 283
- #define DEXISTS 284
- #define IS      285
- #define NUNARY  286
+ /* 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-2005 ArtLebedev Group (http://www.artlebedev.com)
          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
          $Id$
- Line 86  static int real_yyerror(Parse_control* p
+ Line 175  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
- Line 93  static int yylex(YYSTYPE* lvalp, void* p
+ Line 185  static int yylex(YYSTYPE* lvalp, void* p
  #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 217 "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         252
+ #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] : 139)
+ #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,    44,    46,    48,    52,
+ #define YYLAST   500
-,    56,    58,    62,    64,    66,    68,    70,    72,    75,
-,    79,    81,    83,    85,    87,    90,    93,    95,    99,
+ /* YYNTOKENS -- Number of terminals. */
-,   103,   105,   108,   110,   113,   117,   119,   121,   123,
+ #define YYNTOKENS  62
-,   128,   131,   133,   135,   137,   141,   145,   149,   151,
+ /* YYNNTS -- Number of nonterminals. */
-,   155,   157,   159,   161,   164,   166,   167,   168,   175,
+ #define YYNNTS  88
-,   179,   182,   184,   186,   188,   192,   196,   200,   202,
+ /* YYNRULES -- Number of rules. */
-,   208,   212,   214,   218,   220,   222,   224,   226,   228,
+ #define YYNRULES  171
-,   232,   234,   237,   239,   242,   245,   247,   249,   252,
+ /* YYNRULES -- Number of states. */
-,   256,   258,   260,   263,   266,   270,   272,   274,   277,
+ #define YYNSTATES  262
-,   282,   284,   287,   290,   292,   294,   296,   298,   302,
-,   310,   313,   316,   319,   322,   325,   328,   331,   334,
+ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-,   342,   346,   350,   354,   358,   362,   366,   370,   374,
+ #define YYUNDEFTOK  2
-,   382,   386,   390,   394,   398,   402,   406,   410,   414,
+ #define YYMAXUTOK   289
-,   422,   426,   430,   434,   438,   442,   444,   446,   447
+ #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,    75,     0,
+ /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
-,     0,    69,     0,    45,     4,    46,    65,     0,   138,
+    YYRHS.  */
-,    66,     0,    67,     0,    66,    67,     0,    68,    46,
+ static const unsigned short int yyprhs[] =
-,   138,     0,     4,     0,    45,     4,    71,    70,    74,
+ {
-,    75,     0,   138,     0,    71,     0,    47,    72,    48,
+,     0,     3,     5,     7,     9,    12,    14,    16,    18,
-,   138,     0,    73,     0,     4,     0,    73,    49,     4,
+,    25,    27,    29,    32,    35,    37,    39,    47,    49,
-,   138,     0,     4,     0,   138,     0,    76,     0,    77,
+,    55,    57,    59,    61,    65,    67,    69,    71,    73,
-,    76,    77,     0,   136,     0,    78,     0,    79,     0,
+,    78,    80,    82,    84,    86,    88,    90,    93,    96,
-,     0,   100,     0,    80,     0,    50,    81,     0,    83,
+,   102,   104,   106,   108,   111,   113,   116,   120,   122,
-,     0,    82,     0,    51,    83,    52,     0,    84,     0,
+,   126,   128,   131,   134,   136,   138,   140,   141,   142,
-,     0,    86,     0,   130,    86,     0,   122,     0,   119,
+,   152,   156,   158,   160,   162,   164,   166,   168,   171,
-,     0,    50,    88,    92,     0,    89,     0,    90,     0,
+,   174,   175,   182,   184,   186,   189,   191,   193,   195,
-,     0,   118,     0,    53,   118,     0,   130,   118,     0,
+,   197,   203,   207,   211,   213,   217,   219,   223,   225,
-,     0,    94,     0,    95,     0,    47,    96,    48,     0,
+,   231,   233,   235,   237,   239,   241,   243,   246,   248,
-,   133,    55,     0,    51,    75,    52,     0,   137,     0,
+,   254,   256,   258,   261,   263,   265,   267,   269,   272,
-,     0,    97,     0,    98,     0,    99,     0,    78,     0,
+,   276,   277,   283,   285,   287,   290,   293,   295,   297,
-,    76,     0,   101,     0,     0,     0,    56,   102,   104,
+,   303,   305,   307,   309,   311,   313,   315,   319,   323,
-,   105,     3,     0,    83,     0,   106,     0,   105,   106,
+,   330,   333,   336,   339,   342,   345,   348,   351,   355,
-,   107,     0,   108,     0,   109,     0,    47,   110,    48,
+,   363,   367,   371,   375,   379,   383,   387,   391,   395,
-,    54,   111,    55,     0,    51,   112,    52,     0,   113,
+,   403,   407,   411,   415,   419,   423,   427,   431,   435,
-,   110,    49,   113,     0,   114,     0,   111,    49,   114,
+,   443,   447,   451,   455,   459,   461,   463,   465,   466,
-,   115,     0,   112,    49,   115,     0,   116,     0,   117,
+,   470
-,    75,     0,   137,     0,     4,     0,    97,     0,   133,
-,   123,     0,   119,   123,     0,   120,     0,   119,   120,
-,   121,    53,     0,   123,     0,   123,     0,     4,     5,
-,     4,     0,   124,     0,   125,     0,   126,     0,    50,
-,     0,     4,   128,     0,    47,    76,    48,     0,     4,
-,   129,     0,   128,   129,     0,    50,   127,     0,   131,
-,   132,     0,     4,    57,     0,   131,    57,     0,   134,
-,     4,     0,    80,     0,   101,     0,    58,   135,    58,
-,    59,   135,    59,     0,    54,   134,    55,     0,    37,
-,     0,    36,   134,     0,    43,   134,     0,    44,   134,
-,    27,   134,     0,    28,   134,     0,    29,   134,     0,
-,   134,     0,   134,    37,   134,     0,   134,    36,   134,
-,   134,    38,   134,     0,   134,    39,   134,     0,   134,
-,   134,     0,   134,    40,   134,     0,   134,    19,   134,
-,   134,    20,   134,     0,   134,    35,   134,     0,   134,
-,   134,     0,   134,    14,   134,     0,   134,    11,   134,
-,   134,    12,   134,     0,   134,    13,   134,     0,   134,
-,   134,     0,   134,    33,   134,     0,   134,    15,   134,
-,   134,    16,   134,     0,   134,    17,   134,     0,   134,
-,   134,     0,   134,    21,   134,     0,   134,    22,   134,
-,   134,    23,   134,     0,   134,    24,   134,     0,   134,
-,   134,     0,   134,    26,   134,     0,   134,    31,   134,
-,    75,     0,     4,     0,     0,     0
  };
- #endif
+ /* YYRHS -- A `-1'-separated list of the rules' RHS. */
+ static const short int yyrhs[] =
+ {
+,     0,    -1,    65,    -1,    64,    -1,    66,    -1,    64,
+,    -1,    78,    -1,    67,    -1,    72,    -1,    47,     4,
+,    68,    -1,   149,    -1,    69,    -1,    70,    -1,    69,
+,    -1,    71,    48,    -1,   149,    -1,     4,    -1,    47,
+,    74,    73,    77,    48,    78,    -1,   149,    -1,    74,
+       -1,    49,    75,    50,    -1,   149,    -1,    76,    -1,     4,
+       -1,    76,    51,     4,    -1,   149,    -1,     4,    -1,   149,
+       -1,    79,    -1,    80,    -1,    79,    80,    -1,   145,    -1,
+,    -1,    82,    -1,    90,    -1,   105,    -1,    83,    -1,
+,    84,    -1,    86,     3,    -1,    85,    -1,    53,    86,
+,    -1,    87,    -1,    88,    -1,    89,    -1,   138,    89,
+       -1,   128,    -1,   125,   128,    -1,    52,    91,    95,    -1,
+,    -1,    93,    -1,    94,    -1,   124,    -1,    55,   124,
+       -1,   138,   124,    -1,    96,    -1,    99,    -1,   100,    -1,
+       -1,    -1,    49,    97,   101,    98,    50,    -1,    56,   141,
+,    -1,    53,    78,    54,    -1,   146,    -1,     4,    -1,
+,    -1,   103,    -1,   104,    -1,    81,    -1,    80,    79,
+       -1,   106,    -1,    -1,    -1,    58,   107,   109,   108,   110,
+,    -1,    86,    -1,   111,    -1,   110,   111,    -1,   112,
+       -1,   115,    -1,   116,    -1,    -1,    -1,    49,   113,   117,
+,    50,    -1,    56,   118,    57,    -1,    53,   119,    54,
+       -1,   120,    -1,   117,    51,   120,    -1,   121,    -1,   118,
+,   121,    -1,   122,    -1,   119,    51,   122,    -1,   123,
+       -1,   141,    -1,    78,    -1,   146,    -1,     4,    -1,   102,
+       -1,   129,    -1,   125,   129,    -1,   126,    -1,   125,   126,
+       -1,   127,    55,    -1,   129,    -1,   129,    -1,     4,     5,
+       -1,     4,    -1,   130,    -1,   131,    -1,   132,    -1,    52,
+,    -1,     4,   136,    -1,    -1,    -1,    49,   133,    79,
+,    50,    -1,     4,    -1,   137,    -1,   136,   137,    -1,
+,   135,    -1,   139,    -1,   140,    -1,     4,    59,    -1,
+,    59,    -1,   142,    -1,   143,    -1,   147,    -1,   148,
+       -1,    83,    -1,   106,    -1,    60,   144,    60,    -1,    61,
+,    61,    -1,    56,   142,    57,    -1,    39,   142,    -1,
+,   142,    -1,    45,   142,    -1,    46,   142,    -1,    27,
+,    -1,    28,   142,    -1,    29,   142,    -1,    30,   142,
+       -1,   142,    39,   142,    -1,   142,    38,   142,    -1,   142,
+,   142,    -1,   142,    41,   142,    -1,   142,    43,   142,
+       -1,   142,    42,   142,    -1,   142,    19,   142,    -1,   142,
+,   142,    -1,   142,    37,   142,    -1,   142,    36,   142,
+       -1,   142,    14,   142,    -1,   142,    11,   142,    -1,   142,
+,   142,    -1,   142,    13,   142,    -1,   142,    34,   142,
+       -1,   142,    35,   142,    -1,   142,    15,   142,    -1,   142,
+,   142,    -1,   142,    17,   142,    -1,   142,    18,   142,
+       -1,   142,    21,   142,    -1,   142,    22,   142,    -1,   142,
+,   142,    -1,   142,    24,   142,    -1,   142,    25,   142,
+       -1,   142,    26,   142,    -1,   142,    31,   142,    -1,     4,
+       -1,    78,    -1,     4,    -1,    -1,    32,    -1,    33,    -1,
+       -1
+ };
- #if YYDEBUG != 0
+ /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
- static const short yyrline[] = { 0,
+ static const unsigned short int yyrline[] =
-,   129,   131,   131,   132,   134,   134,   136,   208,   208,
+ {
-,   209,   210,   211,   211,   213,   242,   242,   243,   244,
+,   128,   128,   135,   137,   137,   138,   140,   140,   142,
-,   245,   245,   247,   247,   251,   251,   253,   253,   254,
+,   214,   215,   215,   216,   217,   217,   219,   257,   257,
-,   255,   255,   255,   259,   266,   267,   267,   268,   269,
+,   259,   259,   260,   260,   262,   262,   266,   266,   268,
-,   272,   294,   295,   295,   299,   303,   305,   306,   307,
+,   269,   269,   270,   270,   270,   274,   281,   282,   282,
-,   329,   331,   333,   334,   336,   342,   350,   356,   358,
+,   285,   286,   287,   309,   310,   310,   314,   319,   320,
-,   361,   367,   368,   368,   372,   378,   381,   384,   397,
+,   322,   339,   344,   347,   348,   349,   351,   354,   351,
-,   399,   400,   402,   403,   405,   406,   407,   408,   410,
+,   370,   377,   378,   379,   381,   387,   388,   388,   392,
-,   414,   416,   418,   420,   424,   428,   432,   434,   435,
+,   401,   398,   417,   419,   419,   421,   422,   423,   425,
-,   446,   446,   448,   448,   449,   450,   458,   463,   465,
+,   425,   431,   432,   434,   435,   438,   439,   442,   443,
-,   468,   469,   471,   475,   484,   490,   495,   495,   496,
+,   449,   464,   469,   470,   471,   476,   476,   478,   478,
-,   503,   505,   517,   529,   534,   536,   537,   538,   539,
+,   480,   488,   493,   496,   497,   498,   499,   501,   505,
-,   542,   543,   544,   545,   546,   547,   548,   549,   551,
+,   517,   514,   525,   530,   530,   531,   537,   538,   540,
-,   553,   554,   555,   556,   557,   558,   559,   560,   561,
+,   564,   566,   567,   568,   569,   570,   571,   572,   573,
-,   563,   564,   565,   566,   567,   568,   569,   570,   571,
+,   576,   577,   578,   579,   580,   581,   582,   584,   585,
-,   573,   574,   575,   576,   577,   580,   589,   594,   595
+,   587,   588,   589,   590,   591,   592,   593,   594,   595,
+,   597,   598,   599,   600,   601,   602,   603,   604,   605,
+,   607,   608,   609,   610,   613,   618,   627,   632,   633,
+,   636
  };
  #endif
+ #if YYDEBUG || YYERROR_VERBOSE
- #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+ /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
- static const char * const yytname[] = {   "$","error","$undefined.","EON","STRING",
+ static const char *const yytname[] =
- "BOGUS","BAD_STRING_COMPARISON_OPERATOR","BAD_HEX_LITERAL","BAD_METHOD_DECL_START",
+ {
- "BAD_METHOD_PARAMETER_NAME_CHARACTER","BAD_MATH_OPERATOR_CHARACTER","\"&&\"",
+   "$end", "error", "$undefined", "EON", "STRING", "BOGUS",
- "\"||\"","\"!||\"","\"!|\"","\"<=\"","\">=\"","\"==\"","\"!=\"","\"<<\"","\">>\"",
+   "BAD_STRING_COMPARISON_OPERATOR", "BAD_HEX_LITERAL",
- "\"lt\"","\"gt\"","\"le\"","\"ge\"","\"eq\"","\"ne\"","\"def\"","\"in\"","\"-f\"",
+   "BAD_METHOD_DECL_START", "BAD_METHOD_PARAMETER_NAME_CHARACTER",
- "\"-d\"","\"is\"","'<'","'>'","'|'","'&'","'+'","'-'","'*'","'/'","'\\\\'","'%'",
+   "BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE", "\"&&\"",
- "NUNARY","'~'","'!'","'@'","'\\n'","'['","']'","';'","'$'","'{'","'}'","'.'",
+   "\"||\"", "\"!||\"", "\"!|\"", "\"<=\"", "\">=\"", "\"==\"", "\"!=\"",
- "'('","')'","'^'","':'","'\\\"'","'\\''","all","methods","one_big_piece","method",
+   "\"<<\"", "\">>\"", "\"lt\"", "\"gt\"", "\"le\"", "\"ge\"", "\"eq\"",
- "control_method","maybe_control_strings","control_strings","control_string",
+   "\"ne\"", "\"def\"", "\"in\"", "\"-f\"", "\"-d\"", "\"is\"", "\"true\"",
- "maybe_string","code_method","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","construct_round","construct_curly","any_constructor_code_value",
+   "control_string", "maybe_string", "code_method",
- "constructor_code_value","constructor_code","codes__excluding_sole_str_literal",
+   "maybe_bracketed_strings", "bracketed_maybe_strings", "maybe_strings",
- "call","call_value","@1","@2","call_name","store_params","store_param","store_square_param",
+   "strings", "maybe_comment", "maybe_codes", "codes", "code", "action",
- "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","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",
+   "name_expr_wdive_class", "construct", "construct_square", "@1", "@2",
- "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",
+   "construct_round", "construct_curly", "any_constructor_code_value",
- "expr","string_inside_quotes_value","write_string","void_value","empty", NULL
+   "constructor_code_value", "constructor_code",
+   "codes__excluding_sole_str_literal", "call", "call_value", "@3", "@4",
+   "call_name", "store_params", "store_param", "store_square_param", "@5",
+   "@6", "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", "@7", "@8",
+   "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,    69,    70,    70,    71,    72,
+    token YYLEX-NUM.  */
-,    73,    73,    74,    74,    75,    75,    76,    76,    77,
+ static const unsigned short int yytoknum[] =
-,    78,    78,    78,    79,    80,    81,    81,    82,    83,
+ {
-,    84,    85,    86,    86,    87,    88,    88,    88,    89,
+,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-,    91,    92,    92,    92,    93,    94,    95,    96,    96,
+,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-,    97,    98,    99,    99,   100,   102,   103,   101,   104,
+,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-,   105,   106,   106,   106,   107,   108,   109,   110,   110,
+,   286,   287,   288,    60,    62,   124,    38,    43,    45,
-,   111,   112,   112,   113,   114,   115,   116,   116,   116,
+,    47,    92,    37,   289,   126,    33,    64,    10,    91,
-,   118,   118,   119,   119,   120,   121,   122,   122,   123,
+,    59,    36,   123,   125,    46,    40,    41,    94,    58,
-,   123,   123,   124,   125,   126,   127,   128,   128,   129,
+,    39
-,   130,   131,   132,   133,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   135,   136,   137,   138
  };
+ # endif
- static const short yyr2[] = {     0,
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-,     1,     1,     2,     1,     1,     1,     4,     1,     1,
+ static const unsigned char yyr1[] =
-,     2,     2,     1,     1,     7,     1,     1,     3,     1,
+ {
-,     1,     3,     1,     1,     1,     1,     1,     2,     1,
+,    62,    63,    63,    64,    64,    65,    66,    66,    67,
-,     1,     1,     1,     1,     2,     2,     1,     3,     1,
+,    68,    69,    69,    70,    71,    71,    72,    73,    73,
-,     1,     2,     1,     2,     3,     1,     1,     1,     1,
+,    75,    75,    76,    76,    77,    77,    78,    78,    79,
-,     2,     1,     1,     1,     3,     3,     3,     1,     1,
+,    80,    80,    81,    81,    81,    82,    83,    84,    84,
-,     1,     1,     1,     2,     1,     0,     0,     6,     1,
+,    86,    86,    87,    88,    89,    89,    90,    91,    91,
-,     2,     1,     1,     1,     3,     3,     3,     1,     3,
+,    92,    93,    94,    95,    95,    95,    97,    98,    96,
-,     3,     1,     3,     1,     1,     1,     1,     1,     1,
+,   100,   101,   101,   101,   102,   103,   104,   104,   105,
-,     1,     2,     1,     2,     2,     1,     1,     2,     1,
+,   108,   106,   109,   110,   110,   111,   111,   111,   113,
-,     1,     1,     2,     2,     3,     1,     1,     2,     2,
+,   112,   115,   116,   117,   117,   118,   118,   119,   119,
-,     1,     2,     2,     1,     1,     1,     1,     3,     3,
+,   121,   122,   123,   123,   123,   124,   124,   125,   125,
-,     2,     2,     2,     2,     2,     2,     2,     2,     3,
+,   127,   128,   128,   129,   129,   129,   129,   130,   131,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   134,   132,   135,   136,   136,   137,   138,   138,   139,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   141,   142,   142,   142,   142,   142,   142,   142,   142,
-,     3,     3,     3,     3,     3,     1,     1,     0,     0
+,   142,   142,   142,   142,   142,   142,   142,   142,   142,
+,   142,   142,   142,   142,   142,   142,   142,   142,   142,
+,   142,   142,   142,   142,   142,   142,   142,   142,   142,
+,   142,   142,   142,   142,   143,   144,   145,   146,   147,
+,   149
  };
- static const short yydefact[] = {   160,
+ /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-,     0,     0,    67,     2,     1,     3,     6,     7,     5,
+ static const unsigned char yyr2[] =
-,    28,    31,    32,    35,    33,    34,    66,    30,    26,
+ {
-,   100,     0,     0,     0,     0,    36,    38,     0,    40,
+,     2,     1,     1,     1,     2,     1,     1,     1,     4,
-,    42,     0,    47,    48,    49,    50,     0,    94,     0,
+,     1,     1,     2,     2,     1,     1,     7,     1,     1,
-,    92,   101,   102,   103,     0,   111,   112,     0,     4,
+,     1,     1,     1,     3,     1,     1,     1,     1,     1,
-,   160,   160,   160,    99,     0,   113,   105,   108,     0,
+,     1,     1,     1,     1,     1,     1,     2,     2,     1,
-,   104,     0,     0,    98,     0,   100,    51,     0,    92,
+,     1,     1,     1,     2,     1,     2,     3,     1,     1,
-,   159,   160,     0,    46,    53,    54,    55,   100,    95,
+,     1,     2,     2,     1,     1,     1,     0,     0,     5,
-,    93,    96,    43,    52,   114,    70,    68,    15,     8,
+,     3,     1,     1,     1,     1,     1,     1,     2,     1,
-,    11,     0,     9,    22,     0,    21,    20,   160,    18,
+,     0,     6,     1,     1,     2,     1,     1,     1,     0,
-,   110,   109,   106,    39,    93,   158,     0,    31,     0,
+,     5,     3,     3,     1,     3,     1,     3,     1,     3,
-,    62,    63,    59,     0,   116,     0,     0,     0,     0,
+,     1,     1,     1,     1,     1,     1,     2,     1,     2,
-,     0,     0,     0,     0,     0,   160,   160,   117,   118,
+,     1,     1,     2,     1,     1,     1,     1,     2,     2,
-,   115,     0,    12,    14,    13,    19,     0,    25,     0,
+,     0,     5,     1,     1,     2,     2,     1,     1,     2,
-,    65,    56,    58,   126,   127,   128,   129,   123,   122,
+,     1,     1,     1,     1,     1,     1,     3,     3,     3,
-,   125,     0,   157,     0,     0,    57,     0,     0,     0,
+,     2,     2,     2,     2,     2,     2,     2,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,   159,   160,     0,     0,    71,    73,
+,     3,     3,     3,     3,     1,     1,     1,     0,     1,
-,    75,    23,   160,   121,   119,   120,   141,   142,   143,
+,     0
-,   146,   147,   148,   149,   136,   137,   150,   151,   152,
-,   154,   155,   156,   144,   145,   139,   138,   131,   130,
-,   133,   135,   134,   158,    90,     0,    79,    85,    88,
-,     0,    83,     0,    81,    86,    91,    69,    72,    16,
-,   159,   160,    78,     0,    77,    80,    84,    82,     0,
-,     0
  };
- static const short yydefgoto[] = {   250,
+ /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-,     6,     7,     8,    90,    91,    92,    93,     9,    99,
+    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-,    96,    97,   140,   154,    11,    12,    13,    14,   129,
+    means the default is an error.  */
-,    28,    29,    30,    31,    32,    16,    33,    34,    35,
+ static const unsigned char yydefact[] =
-,    75,    76,    77,    78,   110,   226,   112,   113,    17,
+ {
-,    49,   133,    88,   188,   189,   190,   191,   192,   227,
+,   167,     0,     0,    70,     0,     3,     2,     4,     7,
-,   232,   228,   235,   233,   229,   236,    37,    64,    39,
+,     6,    28,    29,    32,    33,    36,    34,    35,    69,
-,    41,    65,    43,    44,    45,    62,    58,    59,    66,
+,    27,     0,   104,   110,     0,     0,     0,    37,    39,
-,    48,   237,   132,   155,    19,   230,    20
+,    41,    42,    43,     0,    48,    49,    50,    51,     0,
+,     0,    45,    96,   105,   106,   107,     0,   117,   118,
+,     1,     5,    30,   171,   171,   171,   103,     0,   119,
+,   114,     0,   113,   108,     0,     0,   102,     0,   104,
+,     0,    96,    38,    57,   171,     0,    47,    54,    55,
+,   104,    99,    46,    97,   100,    44,    53,   120,    73,
+,    16,     9,    11,    12,     0,    10,    23,     0,    22,
+,   171,    19,    18,   116,   115,   111,    40,    97,   168,
+,   165,     0,     0,     0,     0,   169,   170,     0,     0,
+,     0,     0,     0,   171,   171,   125,   126,     0,   121,
+,   123,   124,     0,    13,    15,    14,    20,     0,    26,
+,    25,     0,   167,     0,    32,    58,    64,    65,    66,
+,    61,   134,   135,   136,   137,   131,   130,   132,   133,
+,   166,     0,     0,    60,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,    79,   171,     0,     0,    74,    76,    77,    78,
+,   171,   112,    68,     0,   129,   127,   128,   149,   150,
+,   148,   154,   155,   156,   157,   144,   145,   158,   159,
+,   161,   162,   163,   164,   152,   153,   147,   146,   139,
+,   140,   141,   143,   142,   168,    92,     0,    88,     0,
+,    91,    72,    75,    17,    59,   167,    95,    80,    84,
+,    93,   171,    83,     0,    82,   168,     0,    89,    87,
+,    81
  };
- static const short yypact[] = {    13,
+ /* YYDEFGOTO[NTERM-NUM]. */
- -32768,    24,    98,-32768,    36,-32768,-32768,-32768,-32768,-32768,
+ static const short int yydefgoto[] =
-,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ {
-    -26,    39,    14,    44,    45,   100,-32768,-32768,    47,-32768,
+       -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
- -32768,-32768,    52,-32768,-32768,-32768,-32768,   118,-32768,    59,
+,   101,    56,    98,    99,   140,   161,    12,    13,    14,
- -32768,     4,-32768,-32768,-32768,   118,    -3,-32768,    45,-32768,
+,   126,    28,    29,    30,    31,    32,    33,    17,    34,
- -32768,   101,   113,    71,-32768,    44,-32768,    70,-32768,    32,
+,    36,    37,    77,    78,   109,   204,    79,    80,   146,
- -32768,-32768,    73,   118,    83,   118,    70,-32768,   100,    83,
+,   148,   149,    18,   127,    50,   133,    90,   195,   196,
- -32768,    27,    14,    57,-32768,-32768,-32768,-32768,     1,-32768,
+,   235,   257,   198,   199,   248,   239,   237,   249,   240,
- -32768,     4,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+,   250,    38,    66,    40,    41,    42,    67,    44,    45,
-,-32768,    78,    91,-32768,    90,    94,-32768,   135,-32768,
+,    62,   142,    64,    60,    61,    68,    48,    49,   241,
- -32768,-32768,-32768,-32768,-32768,    83,    92,    14,   -22,   106,
+,   130,   162,    20,   251,   131,   132,    21
- -32768,-32768,-32768,-32768,   115,-32768,    57,    57,    57,    57,
-,    57,    57,    57,   105,    57,    14,    14,-32768,-32768,
-,   281,    72,-32768,-32768,-32768,-32768,   142,-32768,   107,
- -32768,    14,-32768,-32768,   440,   440,   440,   440,-32768,-32768,
- -32768,-32768,   236,-32768,   112,   120,-32768,    57,    57,    57,
-,    57,    57,    57,    57,    57,    57,    57,    57,    57,
-,    57,    57,    57,    57,    57,    57,    57,    57,    57,
-,    57,    57,    57,    41,    14,    57,     5,-32768,-32768,
- -32768,-32768,-32768,    14,-32768,-32768,-32768,   371,   343,   312,
-,   399,   399,   412,   412,   136,   136,   399,   399,   399,
-,   412,   412,   440,   399,   399,   447,   453,    93,    93,
- -32768,-32768,-32768,-32768,   -11,-32768,    19,-32768,-32768,-32768,
- -32768,   -10,-32768,   -33,-32768,-32768,-32768,-32768,-32768,-32768,
- -32768,    41,    14,-32768,    57,-32768,-32768,-32768,-32768,   180,
-,-32768
  };
- static const short yypgoto[] = {-32768,
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- -32768,-32768,   177,-32768,-32768,-32768,    99,-32768,-32768,-32768,
+    STATE-NUM.  */
-,-32768,-32768,-32768,     3,   -18,    -7,   -71,-32768,     0,
+ #define YYPACT_NINF -104
- -32768,-32768,    -6,-32768,-32768,   -37,-32768,-32768,-32768,-32768,
+ static const short int yypact[] =
- -32768,-32768,-32768,-32768,-32768,-32768,   119,-32768,-32768,-32768,
+ {
-,-32768,-32768,-32768,-32768,    -4,-32768,-32768,-32768,-32768,
+,  -104,    17,    44,  -104,    13,   -22,  -104,  -104,  -104,
- -32768,-32768,   -50,   -52,   -48,-32768,-32768,   -16,    95,   -23,
+     -104,  -104,    12,  -104,  -104,  -104,  -104,  -104,  -104,  -104,
- -32768,   -24,     9,-32768,-32768,-32768,   169,-32768,   168,   224,
+     -104,  -104,    55,     9,  -104,    30,    42,    96,  -104,  -104,
- -32768,-32768,   154,    40,   102,-32768,   157,   -20
+,  -104,  -104,  -104,   -26,  -104,  -104,  -104,  -104,    98,
+     -104,   -16,  -104,    16,  -104,  -104,  -104,    98,   -12,  -104,
+,  -104,  -104,  -104,    39,    45,    56,  -104,    30,  -104,
+,  -104,    12,  -104,  -104,    28,    98,    -3,    98,    58,
+     -104,    96,    -3,  -104,  -104,    12,    27,  -104,  -104,  -104,
+     -104,    -2,  -104,  -104,    16,  -104,  -104,  -104,  -104,  -104,
+     -104,  -104,  -104,     3,  -104,    60,    72,  -104,    68,    76,
+     -104,   124,  -104,  -104,  -104,  -104,    12,  -104,    -3,    34,
+,  -104,    27,    27,    27,    27,  -104,  -104,    27,    27,
+,    27,    86,    27,    12,    12,  -104,  -104,    77,   325,
+     -104,  -104,  -104,    70,  -104,  -104,  -104,  -104,   132,  -104,
+,  -104,   102,   105,    12,    62,  -104,  -104,  -104,  -104,
+     -104,  -104,   426,   426,   426,   426,  -104,  -104,  -104,  -104,
+,  -104,    99,    85,  -104,    27,    27,    27,    27,    27,
+,    27,    27,    27,    27,    27,    27,    27,    27,    27,
+,    27,    27,    27,    27,    27,    27,    27,    27,    27,
+,    27,  -104,    12,    27,    25,  -104,  -104,  -104,  -104,
+     -104,    12,  -104,    12,   106,  -104,  -104,  -104,   388,   358,
+,   451,   418,   418,   291,   291,   190,   190,   418,   418,
+,   418,   291,   291,   426,   418,   418,   204,   457,   100,
+,  -104,  -104,  -104,  -104,    37,  -104,   -25,  -104,   -33,
+     -104,  -104,  -104,  -104,  -104,  -104,    71,  -104,   107,  -104,
+     -104,  -104,    12,  -104,    27,  -104,    37,   126,  -104,  -104,
+     -104,  -104
  };
+ /* YYPGOTO[NTERM-NUM].  */
- #define YYLAST          494
+ static const short int yypgoto[] =
+ {
+     -104,  -104,  -104,  -104,   151,  -104,  -104,  -104,    84,  -104,
- static const short yytable[] = {    15,
+     -104,  -104,   122,  -104,  -104,  -104,     1,   -60,    -8,  -103,
-,    18,    10,    51,    60,    55,   -98,   238,    84,    68,
+     -104,     0,  -104,  -104,    -6,  -104,  -104,   -36,  -104,  -104,
-,    42,    18,    81,    80,   245,     1,     1,    63,    52,
+     -104,  -104,  -104,  -104,  -104,  -104,  -104,  -104,  -104,  -104,
-,   246,    15,    89,    18,   -64,   -64,    21,    84,    85,
+,  -104,  -104,  -104,     5,  -104,  -104,  -104,  -104,   -14,
-,    94,    98,   101,    70,     1,   -89,   -89,   243,    81,
+     -104,  -104,  -104,  -104,  -104,  -104,  -104,  -104,   -77,   -58,
-,   244,    87,    55,   225,    80,    82,    61,    22,    71,
+      -55,  -104,    -5,   104,   -31,  -104,   -29,     6,  -104,  -104,
-,   185,    51,    86,    42,   186,   -97,     2,   187,    15,
+     -104,  -104,  -104,   141,  -104,   140,   201,  -104,  -104,   129,
-,    18,     3,     3,   108,  -160,   241,   242,     4,     4,
+,  -104,    82,  -104,   110,  -104,  -104,    61
-,    15,    15,    18,    18,   115,     3,   106,   141,   104,
-,     3,     4,   117,   118,   119,   120,     4,    56,   142,
-,    23,   121,   122,    24,    57,     4,    38,    72,   123,
-,    22,    73,    67,    89,    74,   125,    15,    22,    18,
-,    83,     4,   109,   127,   128,    95,    53,   185,    56,
-,    79,   186,   136,   105,   187,    15,    15,    18,    18,
-,   182,   183,   184,    51,   -97,   -14,   137,   139,   -60,
-,    15,   138,    18,    23,   193,    23,    24,    25,    24,
-,    23,   194,   143,    24,    25,   145,   146,   147,   148,
-,   150,   151,   152,    23,   153,   144,    24,   157,   196,
-,   179,   180,   181,   182,   183,   184,   108,   197,   251,
-,    50,   100,   239,    15,    15,    18,    18,   231,   134,
-,   247,   249,    15,   248,    18,   240,   198,   199,   200,
-,   202,   203,   204,   205,   206,   207,   208,   209,   210,
-,   212,   213,   214,   215,   216,   217,   218,   219,   220,
-,   222,   223,   224,   102,   103,    46,   131,   114,   156,
-,     0,     0,     0,   108,     0,     0,     0,     0,     0,
-,    15,    15,    18,    18,   231,   158,   159,   160,   161,
-,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-,   173,   166,   167,     0,     0,   174,   175,   176,   177,
-,   179,   180,   181,   182,   183,   184,   177,   178,   179,
-,   181,   182,   183,   184,     0,     0,     0,     0,     0,
-,   158,   159,   160,   161,   162,   163,   164,   165,   166,
-,   168,   169,   170,   171,   172,   173,     0,     0,     0,
-,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-,   184,   158,   159,     0,   161,   162,   163,   164,   165,
-,   167,   168,   169,   170,   171,   172,   173,     0,     0,
-,     0,   174,   175,   176,   177,   178,   179,   180,   181,
-,   183,   184,   158,     0,     0,   161,   162,   163,   164,
-,   166,   167,   168,   169,   170,   171,   172,   173,     0,
-,     0,     0,   174,   175,   176,   177,   178,   179,   180,
-,   182,   183,   184,   161,   162,   163,   164,   165,   166,
-,   168,   169,   170,   171,   172,   173,     0,     0,     0,
-,   174,   175,   176,   177,   178,   179,   180,   181,   182,
-,   184,   161,     0,     0,   164,   165,   166,   167,     0,
-,     0,     0,   172,   173,   161,     0,     0,     0,   174,
-,   167,   177,   178,   179,   180,   181,   182,   183,   184,
-,     0,   174,     0,     0,   177,   178,   179,   180,   181,
-,   183,   184,   161,     0,     0,     0,     0,   166,   167,
-,     0,     0,     0,     0,   166,   167,     0,     0,     0,
-,   166,   167,   177,   178,   179,   180,   181,   182,   183,
-,   178,   179,   180,   181,   182,   183,   184,   179,   180,
-,   182,   183,   184
  };
- static const short yycheck[] = {     0,
+ /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
-,     0,     0,    11,    23,     5,     3,     3,    46,    26,
+    positive, shift that token.  If negative, reduce the rule which
-,     3,    11,    38,    38,    49,     4,     4,    25,    46,
+    number is the opposite.  If zero, do what YYDEFACT says.
-,    55,    23,     4,    23,    48,    49,     4,    66,    46,
+    If YYTABLE_NINF, syntax error.  */
-,    52,    53,    54,    26,     4,    48,    49,    49,    64,
+ #define YYTABLE_NINF -172
-,    52,    49,     5,     4,    69,    38,     4,     4,     3,
+ static const short int yytable[] =
-,    47,    60,    57,    46,    51,    53,    45,    54,    60,
+ {
-,    60,    50,    50,    72,    46,    48,    49,    56,    56,
+,    11,   106,    57,    53,    19,   145,    91,    82,    43,
-,    72,    73,    72,    73,    73,    50,    69,    99,    48,
+,    86,    16,    51,    57,     1,     1,    19,   254,  -102,
-,    50,    56,    27,    28,    29,    30,    56,    50,   108,
+,    22,    70,    74,   255,     2,   252,    75,   242,   253,
-,    47,    36,    37,    50,    57,    56,     3,    47,    43,
+,   111,    86,    72,    63,    82,    73,    83,   143,    85,
-,     4,    51,     4,     4,    54,    50,   108,     4,   108,
+,   246,    87,    91,    89,    84,    23,    88,    23,    97,
-,    53,    56,   185,    58,    59,     4,    47,    47,    50,
+,  -171,  -101,    43,   112,   113,   114,   115,     2,   116,
-,     4,    51,    46,    52,    54,   127,   128,   127,   128,
+,    58,    16,     3,     3,   118,   119,    19,    59,     4,
-,    39,    40,    41,   142,    53,    46,    48,     4,    48,
+,  -101,   120,   121,   192,    16,   110,   108,   193,   122,
-,   142,    49,   142,    47,     4,    47,    50,    51,    50,
+,   194,   107,   123,   203,     4,     3,   124,   125,     3,
-,    47,    46,    48,    50,    51,   117,   118,   119,   120,
+,    24,     4,    24,    25,     4,    25,    26,    53,    27,
-,   122,   123,   124,    47,   126,    52,    50,    55,    58,
+,   144,    81,    54,    55,    55,    16,    39,   136,    16,
-,    36,    37,    38,    39,    40,    41,   185,    59,     0,
+,    19,   -67,   -67,    19,    96,   100,   103,   137,   192,
-,     5,    54,   188,   185,   186,   185,   186,   186,    91,
+      -15,   -94,   -94,   193,    16,    16,   194,   138,   139,    19,
-,   242,   245,   194,   243,   194,   194,   158,   159,   160,
+,    71,   145,   151,   164,    24,   200,   201,    25,    26,
-,   162,   163,   164,   165,   166,   167,   168,   169,   170,
+,   189,   190,   191,    16,    24,   207,    24,    25,    19,
-,   172,   173,   174,   175,   176,   177,   178,   179,   180,
+,    39,   202,   145,   135,   -63,   245,    52,   256,   206,
-,   182,   183,   184,    56,    58,     3,    74,    72,   128,
+,   166,   141,   168,   169,   170,   171,   172,   173,   174,
-     -1,    -1,    -1,    -1,   242,    -1,    -1,    -1,    -1,    -1,
+,   176,   177,   178,   179,   180,   261,   134,   102,   260,
-     -1,   242,   243,   242,   243,   243,    11,    12,    13,    14,
+,   243,   147,   182,   183,   184,   185,   186,   187,   188,
-,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,   190,   191,    16,   236,    53,   259,   258,    19,   104,
-,    26,    19,    20,    -1,    -1,    31,    32,    33,    34,
+,    16,   244,    16,    47,   128,    19,   163,    19,   152,
-,    36,    37,    38,    39,    40,    41,    34,    35,    36,
+,   154,   155,     0,     0,   156,   157,   158,   159,   150,
-,    38,    39,    40,    41,    -1,    -1,    -1,    -1,    -1,
+,     0,     0,   173,   174,     0,     0,   144,   186,   187,
-,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,   189,   190,   191,     0,    16,     0,     0,     0,     0,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,   185,   186,   187,   188,   189,   190,   191,   144,     0,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,     0,    16,   236,     0,     0,    16,    19,     0,     0,
-,    41,    11,    12,    -1,    14,    15,    16,    17,    18,
+,    19,   208,   209,   210,   211,   212,   213,   214,   215,
-,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,   217,   218,   219,   220,   221,   222,   223,   224,   225,
-     -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
+,   227,   228,   229,   230,   231,   232,   233,   234,   165,
-,    40,    41,    11,    -1,    -1,    14,    15,    16,    17,
+,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+,   177,   178,   179,   180,   168,     0,     0,     0,   181,
-     -1,    -1,    -1,    31,    32,    33,    34,    35,    36,    37,
+,   174,   182,   183,   184,   185,   186,   187,   188,   189,
-,    39,    40,    41,    14,    15,    16,    17,    18,    19,
+,   191,   181,     0,     0,     0,     0,   184,   185,   186,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,   188,   189,   190,   191,   205,   165,   166,   167,   168,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,   170,   171,   172,   173,   174,   175,   176,   177,   178,
-,    41,    14,    -1,    -1,    17,    18,    19,    20,    -1,
+,   180,     0,     0,     0,     0,   181,     0,     0,   182,
-     -1,    -1,    -1,    25,    26,    14,    -1,    -1,    -1,    31,
+,   184,   185,   186,   187,   188,   189,   190,   191,   165,
-,    20,    34,    35,    36,    37,    38,    39,    40,    41,
+,     0,   168,   169,   170,   171,   172,   173,   174,   175,
-     -1,    -1,    31,    -1,    -1,    34,    35,    36,    37,    38,
+,   177,   178,   179,   180,     0,     0,     0,     0,   181,
-,    40,    41,    14,    -1,    -1,    -1,    -1,    19,    20,
+,     0,   182,   183,   184,   185,   186,   187,   188,   189,
-     -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    -1,    -1,
+,   191,   168,   169,   170,   171,   172,   173,   174,   175,
-     -1,    19,    20,    34,    35,    36,    37,    38,    39,    40,
+,   177,   178,   179,   180,     0,     0,     0,     0,   181,
-,    35,    36,    37,    38,    39,    40,    41,    36,    37,
+,     0,   182,   183,   184,   185,   186,   187,   188,   189,
-,    39,    40,    41
+,   191,   168,     0,     0,   171,   172,   173,   174,     0,
+,     0,     0,   179,   180,   173,   174,     0,     0,   181,
+,     0,     0,     0,   184,   185,   186,   187,   188,   189,
+,   191,   184,   185,   186,   187,   188,   189,   190,   191,
+,   174,     0,     0,     0,     0,   173,   174,     0,     0,
+,     0,     0,     0,     0,     0,     0,   184,   185,   186,
+,   188,   189,   190,   191,   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,    62,     5,    12,     0,   109,     4,    39,     3,
-    GNU General Public License for more details.
+,    47,    12,     0,     5,     4,     4,    12,    51,     3,
+,     4,    27,    49,    57,    47,    51,    53,     3,    54,
-    You should have received a copy of the GNU General Public License
+,     4,    68,    27,     4,    66,     3,    66,     4,    55,
-    along with this program; if not, write to the Free Software
+,     4,    47,     4,    50,    39,     4,    59,     4,     4,
-    Foundation, Inc., 59 Temple Place - Suite 330,
+,    48,    55,    47,    27,    28,    29,    30,    47,    32,
-    Boston, MA 02111-1307, USA.  */
+,    52,    62,    52,    52,    38,    39,    62,    59,    58,
+,    55,    45,    46,    49,    75,    75,    71,    53,    52,
- /* As a special exception, when this file is copied by Bison into a
+,    56,    54,    56,   144,    58,    52,    60,    61,    52,
-    Bison output file, you may use that output file without restriction.
+,    49,    58,    49,    52,    58,    52,    53,   106,    55,
-    This special exception was added by the Free Software Foundation
+,   109,     4,    48,    49,    49,   106,     3,    48,   109,
-    in version 1.24 of Bison.  */
+,   106,    50,    51,   109,    54,    55,    56,    50,    49,
+,    50,    51,    53,   124,   125,    56,    51,     4,   124,
+,    27,   235,    54,    57,    49,     4,    48,    52,    53,
+,    41,    42,    43,   144,    49,    61,    49,    52,   144,
+,    47,    50,   256,    93,    50,    50,     6,    51,    60,
+,    12,   101,    14,    15,    16,    17,    18,    19,    20,
+,    22,    23,    24,    25,    26,    50,    93,    56,   256,
+,   195,   109,    34,    35,    36,    37,    38,    39,    40,
+,    42,    43,   193,   193,   203,   254,   252,   193,    58,
+,   201,   201,   203,     3,    76,   201,   125,   203,   112,
+,   114,   115,    -1,    -1,   118,   119,   120,   121,   109,
+,    -1,    -1,    19,    20,    -1,    -1,   235,    38,    39,
+,    41,    42,    43,    -1,   235,    -1,    -1,    -1,    -1,
+,    37,    38,    39,    40,    41,    42,    43,   256,    -1,
+       -1,    -1,   252,   252,    -1,    -1,   256,   252,    -1,    -1,
+       -1,   256,   165,   166,   167,   168,   169,   170,   171,   172,
+,   174,   175,   176,   177,   178,   179,   180,   181,   182,
+,   184,   185,   186,   187,   188,   189,   190,   191,    11,
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    14,    -1,    -1,    -1,    31,
+,    20,    34,    35,    36,    37,    38,    39,    40,    41,
+,    43,    31,    -1,    -1,    -1,    -1,    36,    37,    38,
+,    40,    41,    42,    43,    57,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    -1,    -1,    -1,    -1,    31,    -1,    -1,    34,
+,    36,    37,    38,    39,    40,    41,    42,    43,    11,
+       -1,    -1,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    31,
+       -1,    -1,    34,    35,    36,    37,    38,    39,    40,    41,
+,    43,    14,    15,    16,    17,    18,    19,    20,    21,
+,    23,    24,    25,    26,    -1,    -1,    -1,    -1,    31,
+       -1,    -1,    34,    35,    36,    37,    38,    39,    40,    41,
+,    43,    14,    -1,    -1,    17,    18,    19,    20,    -1,
+,    -1,    -1,    25,    26,    19,    20,    -1,    -1,    31,
+       -1,    -1,    -1,    -1,    36,    37,    38,    39,    40,    41,
+,    43,    36,    37,    38,    39,    40,    41,    42,    43,
+,    20,    -1,    -1,    -1,    -1,    19,    20,    -1,    -1,
+       -1,    -1,    -1,    -1,    -1,    -1,    -1,    36,    37,    38,
+,    40,    41,    42,    43,    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
+,    78,    79,    80,    81,    82,    83,    90,   105,   106,
- #ifdef alloca
+,   149,     4,     4,    49,    52,    53,    55,    84,    85,
- #define YYSTACK_USE_ALLOCA
+,    87,    88,    89,    91,    92,    93,    94,   124,   125,
- #else /* alloca not defined */
+,   127,   128,   129,   130,   131,   132,   138,   139,   140,
- #ifdef __GNUC__
+,     0,    66,    80,    48,    49,    74,     5,    52,    59,
- #define YYSTACK_USE_ALLOCA
+,   137,   133,     4,   135,    86,   125,   129,   138,     4,
- #define alloca __builtin_alloca
+,   125,   129,     3,    49,    53,    56,    95,    96,    99,
- #else /* not GNU C.  */
+,     4,   126,   128,   129,    55,    89,   124,    59,    86,
- #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+,     4,    68,    69,    70,    71,   149,     4,    75,    76,
- #define YYSTACK_USE_ALLOCA
+,    73,    74,   149,   135,   137,    79,    54,   129,    97,
- #include <alloca.h>
+,     4,    27,    28,    29,    30,    32,    33,    38,    39,
- #else /* not sparc */
+,    46,    52,    56,    60,    61,    83,   106,   141,   142,
- /* We think this test detects Watcom and Microsoft C.  */
+,   147,   148,   108,    70,   149,    48,    50,    51,     4,
- /* This used to test MSDOS, but that is a bad idea
+,   149,   134,     4,    80,    81,   101,   102,   103,   104,
-    since that symbol is in the user namespace.  */
+,    54,   142,   142,   142,   142,   142,   142,   142,   142,
- #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+,    78,   144,   144,    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,   110,   111,   112,   115,   116,
- #endif
+,    48,    50,    79,    98,    57,    60,    61,   142,   142,
- #else /* not MSDOS, or __TURBOC__ */
+,   142,   142,   142,   142,   142,   142,   142,   142,   142,
- #if defined(_AIX)
+,   142,   142,   142,   142,   142,   142,   142,   142,   142,
- /* I don't know what this was needed for, but it pollutes the namespace.
+,   142,   142,   142,   142,   113,    78,   119,   122,   118,
-    So I turned it off.   rms, 2 May 1997.  */
+,   141,     3,   111,    78,    50,     4,   102,   117,   120,
- /* #include <malloc.h>  */
+,   146,    51,    54,    51,    57,    51,   114,   122,   121,
-  #pragma alloca
+,    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]]);
+ }
+ # define YY_REDUCE_PRINT(Rule)          \
+ do {                                    \
+   if (yydebug)                          \
+     yy_reduce_print (Rule);             \
+ } while (0)
+ /* Nonzero means print parse trace.  It is left uninitialized so that
+    multiple parsers can coexist.  */
+ int yydebug;
+ #else /* !YYDEBUG */
+ # define YYDPRINTF(Args)
+ # define YYDSYMPRINT(Args)
+ # define YYDSYMPRINTF(Title, Token, Value, Location)
+ # define YY_STACK_PRINT(Bottom, Top)
+ # define YY_REDUCE_PRINT(Rule)
+ #endif /* !YYDEBUG */
- /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
+ /* YYINITDEPTH -- initial size of the parser's stacks.  */
  #ifndef YYINITDEPTH
- #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).
- #if YYMAXDEPTH == 0
+    Do not make this value too large; the results are undefined if
- #undef YYMAXDEPTH
+    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+    evaluated with infinite-precision integer arithmetic.  */
+ #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
+ # undef YYMAXDEPTH
  #endif
  #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
- __yy_memcpy (to, from, count)
-      char *to;
-      char *from;
-      unsigned int count;
- {
-   register char *f = from;
-   register char *t = to;
-   register int i = count;
-   while (i-- > 0)
+ # ifndef yystrlen
-     *t++ = *f++;
+ #  if defined (__GLIBC__) && defined (_STRING_H)
+ #   define yystrlen strlen
+ #  else
+ /* Return the length of YYSTR.  */
+ static YYSIZE_T
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystrlen (const char *yystr)
+ #   else
+ yystrlen (yystr)
+      const char *yystr;
+ #   endif
+ {
+   register const char *yys = yystr;
+   while (*yys++ != '\0')
+     continue;
+   return yys - yystr - 1;
+ }
+ #  endif
+ # endif
+ # ifndef yystpcpy
+ #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+ #   define yystpcpy stpcpy
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+ static char *
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystpcpy (char *yydest, const char *yysrc)
+ #   else
+ yystpcpy (yydest, yysrc)
+      char *yydest;
+      const char *yysrc;
+ #   endif
+ {
+   register char *yyd = yydest;
+   register const char *yys = yysrc;
+   while ((*yyd++ = *yys++) != '\0')
+     continue;
+   return yyd - 1;
  }
+ #  endif
+ # endif
- #else /* __cplusplus */
+ #endif /* !YYERROR_VERBOSE */
- /* This is the most reliable way to avoid incompatibilities
-    in available built-in functions on various systems.  */
+ #if YYDEBUG
+ /*--------------------------------.
+ | Print this symbol on YYOUTPUT.  |
+ `--------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
  static void
- __yy_memcpy (char *to, char *from, unsigned int count)
+ yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+ #else
+ static void
+ yysymprint (yyoutput, yytype, yyvaluep)
+     FILE *yyoutput;
+     int yytype;
+     YYSTYPE *yyvaluep;
+ #endif
  {
-   register char *t = to;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *f = from;
+   (void) yyvaluep;
-   register int i = count;
-   while (i-- > 0)
+   if (yytype < YYNTOKENS)
-     *t++ = *f++;
+     {
+       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ # ifdef YYPRINT
+       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+ # endif
+     }
+   else
+     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+   YYFPRINTF (yyoutput, ")");
  }
+ #endif /* ! YYDEBUG */
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yydestruct (int yytype, YYSTYPE *yyvaluep)
+ #else
+ static void
+ yydestruct (yytype, yyvaluep)
+     int yytype;
+     YYSTYPE *yyvaluep;
  #endif
- #endif
+ {
+   /* Pacify ``unused variable'' warnings.  */
+   (void) yyvaluep;
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+ }
- #line 217 "/usr/share/bison.simple"
- /* The user can define YYPARSE_PARAM as the name of an argument to be passed
+ /* Prevent warnings from -Wmissing-prototypes.  */
-    into yyparse.  The argument should have type void *.
-    It should actually point to an object.
-    Grammar actions can access the variable by casting it
-    to the proper pointer type.  */
  #ifdef YYPARSE_PARAM
- #ifdef __cplusplus
+ # if defined (__STDC__) || defined (__cplusplus)
- #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+ int yyparse (void *YYPARSE_PARAM);
- #define YYPARSE_PARAM_DECL
+ # else
- #else /* not __cplusplus */
+ int yyparse ();
- #define YYPARSE_PARAM_ARG YYPARSE_PARAM
+ # endif
- #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+ #else /* ! YYPARSE_PARAM */
- #endif /* not __cplusplus */
+ #if defined (__STDC__) || defined (__cplusplus)
- #else /* not YYPARSE_PARAM */
+ int yyparse (void);
- #define YYPARSE_PARAM_ARG
+ #else
- #define YYPARSE_PARAM_DECL
+ int yyparse ();
- #endif /* not YYPARSE_PARAM */
+ #endif
+ #endif /* ! YYPARSE_PARAM */
+ /*----------.
+ | yyparse.  |
+ `----------*/
- /* Prevent warning if -Wstrict-prototypes.  */
- #ifdef __GNUC__
  #ifdef YYPARSE_PARAM
- int yyparse (void *);
+ # if defined (__STDC__) || defined (__cplusplus)
+ int yyparse (void *YYPARSE_PARAM)
+ # else
+ int yyparse (YYPARSE_PARAM)
+   void *YYPARSE_PARAM;
+ # endif
+ #else /* ! YYPARSE_PARAM */
+ #if defined (__STDC__) || defined (__cplusplus)
+ int
+ yyparse (void)
  #else
- int yyparse (void);
+ int
+ yyparse ()
  #endif
  #endif
- int
- yyparse(YYPARSE_PARAM_ARG)
-      YYPARSE_PARAM_DECL
  {
+   /* The lookahead symbol.  */
+ int yychar;
+ /* The semantic value of the lookahead symbol.  */
+ YYSTYPE yylval;
+ /* Number of syntax errors so far.  */
+ int yynerrs;
    register int yystate;
    register int yyn;
-   register short *yyssp;
+   int yyresult;
+   /* Number of tokens to shift before error messages enabled.  */
+   int yyerrstatus;
+   /* Lookahead token as an internal (translated) token number.  */
+   int yytoken = 0;
+   /* Three stacks and their tools:
+      `yyss': related to states,
+      `yyvs': related to semantic values,
+      `yyls': related to locations.
+      Refer to the stacks thru separate pointers, to allow yyoverflow
+      to reallocate them elsewhere.  */
+   /* The state stack.  */
+   short int yyssa[YYINITDEPTH];
+   short int *yyss = yyssa;
+   register short int *yyssp;
+   /* The semantic value stack.  */
+   YYSTYPE yyvsa[YYINITDEPTH];
+   YYSTYPE *yyvs = yyvsa;
    register YYSTYPE *yyvsp;
-   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
-   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
-   short yyssa[YYINITDEPTH];     /*  the state stack                     */
-   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
-   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
-   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
-   YYLTYPE *yyls = yylsa;
-   YYLTYPE *yylsp;
- #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
- #else
  #define YYPOPSTACK   (yyvsp--, yyssp--)
- #endif
-   int yystacksize = YYINITDEPTH;
+   YYSIZE_T yystacksize = YYINITDEPTH;
-   int yyfree_stacks = 0;
- #ifdef YYPURE
+   /* The variables used to return semantic value and location from the
-   int yychar;
+      action routines.  */
-   YYSTYPE yylval=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 799  yyparse(YYPARSE_PARAM_ARG)
+ Line 1240  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 911  yynewstate:
+ Line 1339  yynewstate:
    /* First try to decide what to do without reference to lookahead token.  */
    yyn = yypact[yystate];
-   if (yyn == YYFLAG)
+   if (yyn == YYPACT_NINF)
      goto yydefault;
    /* Not known => get a lookahead token if don't already have one.  */
-   /* yychar is either YYEMPTY or YYEOF
+   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-      or a valid token in external form.  */
    if (yychar == YYEMPTY)
      {
- #if YYDEBUG != 0
+       YYDPRINTF ((stderr, "Reading a token: "));
-       if (yydebug)
-         fprintf(stderr, "Reading a token: ");
- #endif
        yychar = YYLEX;
      }
-   /* Convert token to internal form (in yychar1) for indexing tables with */
+   if (yychar <= YYEOF)
-   if (yychar <= 0)              /* This means end of input. */
      {
-       yychar1 = 0;
+       yychar = yytoken = YYEOF;
-       yychar = YYEOF;           /* Don't call YYLEX any more */
+       YYDPRINTF ((stderr, "Now at end of input.\n"));
- #if YYDEBUG != 0
-       if (yydebug)
-         fprintf(stderr, "Now at end of input.\n");
- #endif
      }
    else
      {
-       yychar1 = YYTRANSLATE(yychar);
+       yytoken = YYTRANSLATE (yychar);
+       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
- #if YYDEBUG != 0
-       if (yydebug)
-         {
-           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-           /* Give the individual parser a way to print the precise meaning
-              of a token, for further debugging info.  */
- #ifdef YYPRINT
-           YYPRINT (stderr, yychar, yylval);
- #endif
-           fprintf (stderr, ")\n");
-         }
- #endif
      }
-   yyn += yychar1;
+   /* If the proper action on seeing token YYTOKEN is to reduce or to
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+      detect an error, take that action.  */
+   yyn += yytoken;
+   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
      goto yydefault;
    yyn = yytable[yyn];
+   if (yyn <= 0)
-   /* yyn is what to do for this token type in this state.
-      Negative => reduce, -yyn is rule number.
-      Positive => shift, yyn is new state.
-        New state is final state => don't bother to shift,
-        just return success.
-, or most negative number => error.  */
-   if (yyn < 0)
      {
-       if (yyn == YYFLAG)
+       if (yyn == 0 || yyn == YYTABLE_NINF)
          goto yyerrlab;
        yyn = -yyn;
        goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrlab;
    if (yyn == YYFINAL)
      YYACCEPT;
    /* Shift the lookahead token.  */
+   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
- #if YYDEBUG != 0
-   if (yydebug)
-     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
- #endif
    /* Discard the token being shifted unless it is eof.  */
    if (yychar != YYEOF)
      yychar = YYEMPTY;
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
-   /* count tokens shifted since error; after three, turn off error status.  */
-   if (yyerrstatus) yyerrstatus--;
+   /* Count tokens shifted since error; after three, turn off error
+      status.  */
+   if (yyerrstatus)
+     yyerrstatus--;
    yystate = yyn;
    goto yynewstate;
- /* Do the default action for the current state.  */
- yydefault:
+ /*-----------------------------------------------------------.
+ | yydefault -- do the default action for the current state.  |
+ `-----------------------------------------------------------*/
+ yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
      goto yyerrlab;
+   goto yyreduce;
- /* Do a reduction.  yyn is the number of a rule to reduce with.  */
+ /*-----------------------------.
+ | yyreduce -- Do a reduction.  |
+ `-----------------------------*/
  yyreduce:
+   /* yyn is the number of a rule to reduce with.  */
    yylen = yyr2[yyn];
-   if (yylen > 0)
-     yyval = yyvsp[1-yylen]; /* implement default value of the action */
- #if YYDEBUG != 0
-   if (yydebug)
-     {
-       int i;
-       fprintf (stderr, "Reducing via rule %d (line %d), ",
-                yyn, yyrline[yyn]);
-       /* Print the symbols being reduced, and their result.  */
+   /* If YYLEN is nonzero, implement the default value of the action:
-       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+      `$$ = $1'.
-         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-     }
- #endif
+      Otherwise, the following line sets YYVAL to garbage.
+      This behavior is undocumented and Bison
+      users should not rely upon it.  Assigning to YYVAL
+      unconditionally makes the parser a bit smaller, and it avoids a
+      GCC warning that YYVAL may be used uninitialized.  */
+   yyval = yyvsp[1-yylen];
-   switch (yyn) {
- case 1:
+   YY_REDUCE_PRINT (yyn);
- #line 122 "compile.y"
+   switch (yyn)
- {
+     {
+         case 2:
+ #line 128 "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 137 "compile.y"
+   case 9:
- {
+ #line 143 "compile.y"
+     {
          const String& command=*LA2S(*yyvsp[-2]);
          YYSTYPE strings_code=yyvsp[0];
          if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
- Line 1119  case 8:
+ Line 1512  case 8:
                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
                  YYERROR;
          }
- ;
+ ;}
-     break;}
+     break;
- case 12:
- #line 209 "compile.y"
+   case 13:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 215 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 16:
+     break;
- #line 214 "compile.y"
- {
+   case 17:
+ #line 219 "compile.y"
+     {
+         PC.explicit_result=false;
          const String& name=*LA2S(*yyvsp[-5]);
          YYSTYPE params_names_code=yyvsp[-4];
- Line 1142  case 16:
+ Line 1538  case 16:
          ArrayString* locals_names=0;
          if(int size=locals_names_code->count()) {
                  locals_names=new ArrayString;
-                 for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE)
+                 for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE) {
-                         *locals_names+=LA2S(*locals_names_code, i);
+                         const String* local_name=LA2S(*locals_names_code, i);
+                         if(*local_name==RESULT_VAR_NAME)
+                                 PC.explicit_result=true;
+                         else
+                                 *locals_names+=local_name;
+                 }
          }
-         Method& method=*new Method(
+         Method* method=new Method(
                  //name,
                  Method::CT_ANY,
 , 0/*min,max numbered_params_count*/,
                  params_names, locals_names,
                  yyvsp[0], 0);
-         PC.cclass->add_method(PC.alias_method(name), method);
- ;
+         PC.cclass->add_method(PC.alias_method(name), *method);
-     break;}
+         *reinterpret_cast<Method**>(&yyval)=method;
- case 19:
- #line 243 "compile.y"
+         // todo: check [][;result;]
- {yyval=yyvsp[-1];
+ ;}
-     break;}
+     break;
- case 23:
- #line 245 "compile.y"
+   case 20:
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+ #line 258 "compile.y"
-     break;}
+     {yyval=yyvsp[-1];}
- case 29:
+     break;
- #line 253 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 24:
-     break;}
+ #line 260 "compile.y"
- case 35:
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
- #line 259 "compile.y"
+     break;
- {
+   case 30:
+ #line 268 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 36:
+ #line 274 "compile.y"
+     {
          yyval=yyvsp[0]; /* stack: resulting value */
          changetail_or_append(*yyval,
                  OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
                  /*or */OP_WRITE_VALUE
                  ); /* value=pop; wcontext.write(value) */
- ;
+ ;}
-     break;}
+     break;
- case 36:
- #line 266 "compile.y"
+   case 37:
- { yyval=yyvsp[0] ;
+ #line 281 "compile.y"
-     break;}
+     { yyval=yyvsp[0] ;}
- case 39:
+     break;
- #line 268 "compile.y"
- { yyval=yyvsp[-1] ;
+   case 40:
-     break;}
+ #line 283 "compile.y"
- case 42:
+     { yyval=yyvsp[-1] ;}
- #line 272 "compile.y"
+     break;
- {
+   case 43:
+ #line 287 "compile.y"
+     {
          yyval=N();
          ArrayOperation* diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
- Line 1208  case 42:
+ Line 1620  case 42:
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 43:
- #line 294 "compile.y"
+   case 44:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 309 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 45:
+     break;
- #line 295 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 46:
-     break;}
+ #line 310 "compile.y"
- case 46:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 299 "compile.y"
+     break;
- {
+   case 47:
+ #line 314 "compile.y"
+     {
          yyval=yyvsp[-1]; /* stack: context,name */
          P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
- ;
+ ;}
-     break;}
+     break;
- case 50:
- #line 307 "compile.y"
+   case 51:
- {
+ #line 322 "compile.y"
+     {
          yyval=N();
          ArrayOperation* diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
- Line 1243  case 50:
+ Line 1659  case 50:
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 51:
- #line 324 "compile.y"
+   case 52:
- {
+ #line 339 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_WRITE); /* stack: starting context */
          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
- ;
+ ;}
-     break;}
+     break;
- case 52:
- #line 329 "compile.y"
+   case 53:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 344 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 56:
+     break;
- #line 336 "compile.y"
- {
+   case 57:
+ #line 351 "compile.y"
+     {
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 58:
+ #line 354 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 59:
+ #line 356 "compile.y"
+     {
          // stack: context, name
-         yyval=yyvsp[-1]; // stack: context, name, value
+         yyval=yyvsp[-2]; // stack: context, name, value
          O(*yyval, OP_CONSTRUCT_VALUE); /* value=pop; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 57:
- #line 342 "compile.y"
+   case 60:
- {
+ #line 362 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_PREPARE_TO_EXPRESSION);
          // stack: context, name
          P(*yyval, *yyvsp[-1]); // stack: context, name, value
          O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 58:
- #line 350 "compile.y"
+   case 61:
- {
+ #line 370 "compile.y"
+     {
          // stack: context, name
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
- ;
+ ;}
-     break;}
+     break;
- case 62:
- #line 361 "compile.y"
+   case 65:
- {
+ #line 381 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ ;}
-     break;}
+     break;
- case 65:
- #line 368 "compile.y"
+   case 68:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 388 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 66:
+     break;
- #line 372 "compile.y"
- {
+   case 69:
+ #line 392 "compile.y"
+     {
          yyval=yyvsp[0]; /* stack: value */
          changetail_or_append(*yyval,
                  OP_CALL, true,  /*->*/ OP_CALL__WRITE,
                  /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
- ;
+ ;}
-     break;}
+     break;
- case 67:
- #line 378 "compile.y"
+   case 70:
- {
+ #line 398 "compile.y"
+     {
                                          PC.in_call_value=true;
-                         ;
+                         ;}
-     break;}
+     break;
- case 68:
- #line 381 "compile.y"
+   case 71:
- {
+ #line 401 "compile.y"
+     {
                                  PC.in_call_value=false;
-                         ;
+                         ;}
-     break;}
+     break;
- case 69:
- #line 384 "compile.y"
+   case 72:
- { /* ^field.$method{vasya} */
+ #line 404 "compile.y"
+     { /* ^field.$method{vasya} */
          yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
          YYSTYPE params_code=yyvsp[-1];
          if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM]
                  if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
-                         if(!value->is_defined()) // value is VVoid?
+                         if(value->is_void()) // value is VVoid?
                                  params_code=0; // ^zzz[] case. don't append lone empty param.
          }
          /* stack: context, method_junction */
          OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
- ;
+ ;}
-     break;}
+     break;
- case 72:
- #line 399 "compile.y"
+   case 75:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 419 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 76:
+     break;
- #line 405 "compile.y"
- {yyval=yyvsp[-1];
+   case 79:
-     break;}
+ #line 425 "compile.y"
- case 77:
+     {
- #line 406 "compile.y"
+         // allow ^call[ letters here any time ]
- {yyval=yyvsp[-1];
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
-     break;}
+ ;}
- case 78:
+     break;
- #line 407 "compile.y"
- {yyval=yyvsp[-1];
+   case 80:
-     break;}
+ #line 428 "compile.y"
- case 80:
+     {
- #line 410 "compile.y"
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+ ;}
-     break;}
+     break;
- case 82:
- #line 414 "compile.y"
+   case 81:
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+ #line 430 "compile.y"
-     break;}
+     {yyval=yyvsp[-2];}
- case 84:
+     break;
- #line 418 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
+   case 82:
-     break;}
+ #line 431 "compile.y"
- case 85:
+     {yyval=yyvsp[-1];}
- #line 420 "compile.y"
+     break;
- {
+   case 83:
+ #line 432 "compile.y"
+     {yyval=yyvsp[-1];}
+     break;
+   case 85:
+ #line 435 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 87:
+ #line 439 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 89:
+ #line 443 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 90:
+ #line 445 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_STORE_PARAM);
- ;
+ ;}
-     break;}
+     break;
- case 86:
- #line 424 "compile.y"
+   case 91:
- {
+ #line 449 "compile.y"
-         yyval=N();
+     {
-         OA(*yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]);
+         YYSTYPE expr_code=yyvsp[0];
- ;
+         if(expr_code->count()==3
-     break;}
+                 && (*expr_code)[0].code==OP_VALUE) { // optimizing (double/bool/incidently 'string' too) case. [OP_VALUE+origin+Double]
- case 87:
+                 yyval=expr_code;
- #line 428 "compile.y"
+                 O(*yyval, OP_STORE_PARAM); // no evaluating
- {
+         } else {
+                 ArrayOperation* code=N();
+                 O(*code, OP_PREPARE_TO_EXPRESSION);
+                 P(*code, *expr_code);
+                 O(*code, OP_WRITE_EXPR_RESULT);
+                 yyval=N();
+                 OA(*yyval, OP_EXPR_CODE__STORE_PARAM, code);
+         }
+ ;}
+     break;
+   case 92:
+ #line 464 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
- ;
+ ;}
-     break;}
+     break;
- case 91:
- #line 437 "compile.y"
+   case 97:
- {
+ #line 476 "compile.y"
-         yyval=N();
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
-         O(*yyval, OP_PREPARE_TO_EXPRESSION);
+     break;
-         P(*yyval, *yyvsp[0]);
-         O(*yyval, OP_WRITE_EXPR_RESULT);
+   case 99:
- ;
+ #line 478 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 93:
+     break;
- #line 446 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 101:
-     break;}
+ #line 480 "compile.y"
- case 95:
+     {
- #line 448 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 97:
- #line 450 "compile.y"
- {
          // we know that name_advance1 not called from ^xxx context
          // so we'll not check for operator call possibility as we do in name_advance2
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 98:
- #line 458 "compile.y"
+   case 102:
- {
+ #line 488 "compile.y"
+     {
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 104:
- #line 471 "compile.y"
+   case 108:
- {
+ #line 501 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT);
- ;
+ ;}
-     break;}
+     break;
- case 105:
- #line 475 "compile.y"
+   case 109:
- {
+ #line 505 "compile.y"
+     {
          ArrayOperation* code;
          {
                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
- Line 1434  case 105:
+ Line 1909  case 105:
          }
          yyval=N();
          OA(*yyval, OP_STRING_POOL, code);
- ;
+ ;}
-     break;}
+     break;
- case 106:
- #line 484 "compile.y"
+   case 110:
- {
+ #line 514 "compile.y"
+     {
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 111:
+ #line 517 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 112:
+ #line 519 "compile.y"
+     {
          yyval=N();
-         OA(*yyval, OP_OBJECT_POOL, yyvsp[-1]); /* stack: empty write context */
+         OA(*yyval, OP_OBJECT_POOL, yyvsp[-2]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ ;}
-     break;}
+     break;
- case 107:
- #line 490 "compile.y"
+   case 113:
- {
+ #line 525 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_READ);
          P(*yyval, *yyvsp[0]);
- ;
+ ;}
-     break;}
+     break;
- case 109:
- #line 495 "compile.y"
+   case 115:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 530 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 110:
+     break;
- #line 496 "compile.y"
- {
+   case 116:
+ #line 531 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT__WRITE);
- ;
+ ;}
-     break;}
+     break;
- case 113:
- #line 505 "compile.y"
+   case 119:
- {
+ #line 540 "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 1477  case 113:
+ Line 1972  case 113:
                  }
          }
          O(*yyval, OP_GET_CLASS);
- ;
+ ;}
-     break;}
+     break;
- case 114:
- #line 517 "compile.y"
+   case 120:
- {
+ #line 552 "compile.y"
+     {
          yyval=yyvsp[-1];
          if(!PC.in_call_value) {
                  strcpy(PC.error, ":: not allowed here");
                  YYERROR;
          }
          O(*yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);
- ;
+ ;}
-     break;}
+     break;
- case 115:
- #line 529 "compile.y"
+   case 127:
- {
-         // see OP_PREPARE_TO_EXPRESSION!!
-         if((yyval=yyvsp[0])->count()==2) // only one string literal in there?
-                 change_string_literal_to_double_literal(*yyval); // make that string literal Double
- ;
-     break;}
- case 119:
- #line 538 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 120:
- #line 539 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 121:
- #line 540 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 122:
- #line 542 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;
-     break;}
- case 123:
- #line 543 "compile.y"
- { yyval=yyvsp[0] ;
-     break;}
- case 124:
- #line 544 "compile.y"
- { yyval=yyvsp[0];        O(*yyval, OP_INV) ;
-     break;}
- case 125:
- #line 545 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;
-     break;}
- case 126:
- #line 546 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;
-     break;}
- case 127:
- #line 547 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_IN) ;
-     break;}
- case 128:
- #line 548 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;
-     break;}
- case 129:
- #line 549 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;
-     break;}
- case 130:
- #line 551 "compile.y"
- {       yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;
-     break;}
- case 131:
- #line 552 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;
-     break;}
- case 132:
- #line 553 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;
-     break;}
- case 133:
- #line 554 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;
-     break;}
- case 134:
- #line 555 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;
-     break;}
- case 135:
- #line 556 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;
-     break;}
- case 136:
- #line 557 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;
-     break;}
- case 137:
- #line 558 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;
-     break;}
- case 138:
- #line 559 "compile.y"
- { yyval=yyvsp[-2];      P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;
-     break;}
- case 139:
- #line 560 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;
-     break;}
- case 140:
- #line 561 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;
-     break;}
- case 141:
- #line 562 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;
-     break;}
- case 142:
- #line 563 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;
-     break;}
- case 143:
- #line 564 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;
-     break;}
- case 144:
- #line 565 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;
-     break;}
- case 145:
- #line 566 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;
-     break;}
- case 146:
- #line 567 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;
-     break;}
- case 147:
- #line 568 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;
-     break;}
- case 148:
- #line 569 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;
-     break;}
- case 149:
- #line 570 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;
-     break;}
- case 150:
  #line 571 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;
+     { yyval = yyvsp[-1] ;}
-     break;}
+     break;
- case 151:
+   case 128:
  #line 572 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;
+     { yyval = yyvsp[-1] ;}
-     break;}
+     break;
- case 152:
+   case 129:
  #line 573 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;
+     { yyval = yyvsp[-1]; ;}
-     break;}
+     break;
- case 153:
- #line 574 "compile.y"
+   case 130:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;
-     break;}
- case 154:
  #line 575 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;}
-     break;}
+     break;
- case 155:
+   case 131:
  #line 576 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;
+     { yyval=yyvsp[0] ;}
-     break;}
+     break;
- case 156:
+   case 132:
  #line 577 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;
+     { yyval=yyvsp[0];    O(*yyval, OP_INV) ;}
-     break;}
+     break;
- case 157:
+   case 133:
+ #line 578 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;}
+     break;
+   case 134:
+ #line 579 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;}
+     break;
+   case 135:
  #line 580 "compile.y"
- {
+     { yyval=yyvsp[0];  O(*yyval, OP_IN) ;}
+     break;
+   case 136:
+ #line 581 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;}
+     break;
+   case 137:
+ #line 582 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;}
+     break;
+   case 138:
+ #line 584 "compile.y"
+     {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;}
+     break;
+   case 139:
+ #line 585 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;}
+     break;
+   case 140:
+ #line 586 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;}
+     break;
+   case 141:
+ #line 587 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;}
+     break;
+   case 142:
+ #line 588 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;}
+     break;
+   case 143:
+ #line 589 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;}
+     break;
+   case 144:
+ #line 590 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;}
+     break;
+   case 145:
+ #line 591 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;}
+     break;
+   case 146:
+ #line 592 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;}
+     break;
+   case 147:
+ #line 593 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;}
+     break;
+   case 148:
+ #line 594 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;}
+     break;
+   case 149:
+ #line 595 "compile.y"
+     { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;}
+     break;
+   case 150:
+ #line 596 "compile.y"
+     { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;}
+     break;
+   case 151:
+ #line 597 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;}
+     break;
+   case 152:
+ #line 598 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;}
+     break;
+   case 153:
+ #line 599 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;}
+     break;
+   case 154:
+ #line 600 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;}
+     break;
+   case 155:
+ #line 601 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;}
+     break;
+   case 156:
+ #line 602 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;}
+     break;
+   case 157:
+ #line 603 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;}
+     break;
+   case 158:
+ #line 604 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;}
+     break;
+   case 159:
+ #line 605 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;}
+     break;
+   case 160:
+ #line 606 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;}
+     break;
+   case 161:
+ #line 607 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;}
+     break;
+   case 162:
+ #line 608 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;}
+     break;
+   case 163:
+ #line 609 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;}
+     break;
+   case 164:
+ #line 610 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;}
+     break;
+   case 165:
+ #line 613 "compile.y"
+     {
+         // optimized from OP_STRING->OP_VALUE for doubles
+         maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
+ ;}
+     break;
+   case 166:
+ #line 618 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.get_string() */
- ;
+ ;}
-     break;}
+     break;
- case 158:
- #line 589 "compile.y"
+   case 167:
- {
+ #line 627 "compile.y"
+     {
          // optimized from OP_STRING+OP_WRITE_VALUE to OP_STRING__WRITE
          change_string_literal_to_write_string_literal(*(yyval=yyvsp[0]))
- ;
+ ;}
-     break;}
+     break;
- case 159:
- #line 594 "compile.y"
+   case 168:
- { yyval=VL(new VVoid(), 0, 0, 0) ;
+ #line 632 "compile.y"
-     break;}
+     { yyval=VL(/*we know that we will not change it*/const_cast<VVoid*>(&vvoid), 0, 0, 0) ;}
- case 160:
+     break;
- #line 595 "compile.y"
- { yyval=N() ;
+   case 169:
-     break;}
+ #line 633 "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 170:
+ #line 634 "compile.y"
+     { yyval = VL(/*we know that we will not change it*/const_cast<VBool*>(&vfalse), 0, 0, 0) ;}
+     break;
+   case 171:
+ #line 636 "compile.y"
+     { yyval=N() ;}
+     break;
+     }
+ /* Line 1010 of yacc.c.  */
+ #line 2231 "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;
+   yystate = *yyssp;
+   goto yyerrlab1;
-   if (yyssp == yyss) YYABORT;
-   yyvsp--;
-   yystate = *--yyssp;
- #ifdef YYLSP_NEEDED
-   yylsp--;
- #endif
- #if YYDEBUG != 0
+ /*-------------------------------------------------------------.
-   if (yydebug)
+ | yyerrlab1 -- common code for both syntax error and YYERROR.  |
-     {
+ `-------------------------------------------------------------*/
-       short *ssp1 = yyss - 1;
+ yyerrlab1:
-       fprintf (stderr, "Error: state stack now");
+   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
-       while (ssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
-       fprintf (stderr, "\n");
-     }
- #endif
- yyerrhandle:
+   for (;;)
+     {
-   yyn = yypact[yystate];
+       yyn = yypact[yystate];
-   if (yyn == YYFLAG)
+       if (yyn != YYPACT_NINF)
-     goto yyerrdefault;
+         {
+           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 597 "compile.y"
+ #line 638 "compile.y"
  #endif
- Line 1947  static int yylex(YYSTYPE *lvalp, void *a
+ Line 2503  static int yylex(YYSTYPE *lvalp, void *a
                  c=*(end=(pc.source++));
  //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp);
-                 if(c=='\n') {
+                 if(c=='\n')
                          pc.pos_next_line();
-                 } else
+                 else
                          pc.pos_next_c(c);
+ //              fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col);
-                 if(c=='@' && pc.pos.col==0+1) {
+                 if(pc.pos.col==0+1 && c=='@') {
                          if(pc.ls==LS_DEF_SPECIAL_BODY) {
                                  // @SPECIAL
                                  // ...
- Line 1965  static int yylex(YYSTYPE *lvalp, void *a
+ Line 2522  static int yylex(YYSTYPE *lvalp, void *a
                          } else // @ in first column inside some code [when could that be?]
                                  result=BAD_METHOD_DECL_START;
                          goto break2;
-                 } else if(c=='^') {
+                 }
+                 if(c=='^') {
                          if(pc.ls==LS_METHOD_AFTER) {
                                  // handle after-method situation
                                  pop_LS(pc);
- Line 2016  default:
+ Line 2574  default:
                                  }
                                  // #HH ?
                                  if(pc.source[0]=='#' && pc.source[1] && 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 2084  default:
+ Line 2642  default:
                                          lexical_brackets_nestage++;
                                  break;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  // #COMMENT
- Line 2326  default:
+ Line 2894  default:
                                                  goto break2;
                                          }
                                  break;
+                         case 't':
+                                 if(end==begin) // right after whitespace
+                                         if(pc.source[0]=='r' && pc.source[1]=='u' && pc.source[2]=='e') { // def
+                                                 skip_analized=3;
+                                                 result=LITERAL_TRUE;
+                                                 goto break2;
+                                         }
+                                 break;
+                         case 'f':
+                                 if(end==begin) // right after whitespace
+                                         if(pc.source[0]=='a' && pc.source[1]=='l' && pc.source[2]=='s' && pc.source[3]=='e') { // def
+                                                 skip_analized=4;
+                                                 result=LITERAL_FALSE;
+                                                 goto break2;
+                                         }
+                                 break;
                          case ' ': case '\t': case '\n':
                                  if(end!=begin) { // there were a string after previous operator?
                                          result=0; // return that string
- Line 2402  default:
+ Line 2986  default:
                          case '=': case '!':
                          // common delimiters
                          case ',': case '?': case '#':
+                         // mysql column separators
+                         case '`':
                          // before call
                          case '^':
                                  pop_LS(pc);
- Line 2537  default:
+ Line 3123  default:
                          case ':': // ':name' or 'class:name'
                          case '^': // ^abc^xxx wrong. bailing out
                          case ']': case '}': case ')': // ^abc]}) wrong. bailing out
+                         case ' ': // ^if ( wrong. bailing out
                                  RC;
                          }
                          break;
- Line 2583  default:
+ Line 3170  default:
                                  lexical_brackets_nestage++;
                                  break;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  case LS_METHOD_AFTER:
- Line 2653  static void yyprint(FILE *file, int type
+ Line 3250  static void yyprint(FILE *file, int type
          if(type==STRING)
                  fprintf(file, " \"%s\"", LA2S(*value)->cstr());
  }

E-mail:

Removed from v.1.88.2.1
changed lines
	Added in v.1.114