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

Return to compile.tab.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/compile.tab.C between versions 1.81.2.13.2.19 and 1.105

-version 1.81.2.13.2.19, 2003/04/01 07:59:08
+version 1.105, 2005/11/03 10:17:22
  Line 1
+ /* A Bison parser, made by GNU Bison 1.875.  */
+ /* Skeleton parser for Yacc-like parsing with Bison,
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.  */
+ /* As a special exception, when this file is copied by Bison into a
+    Bison output file, you may use that output file without restriction.
+    This special exception was added by the Free Software Foundation
+    in version 1.24 of Bison.  */
+ /* Written by Richard Stallman by simplifying the original so called
+    ``semantic'' parser.  */
+ /* All symbols defined below should begin with yy or YY, to avoid
+    infringing on user name space.  This should be done even for local
+    variables, as they might otherwise be expanded by user macros.
+    There are some unavoidable exceptions within include files to
+    define necessary library symbols; they are noted "INFRINGES ON
+    USER NAME SPACE" below.  */
+ /* Identify Bison output.  */
+ #define YYBISON 1
+ /* Skeleton name.  */
+ #define YYSKELETON_NAME "yacc.c"
+ /* Pure parsers.  */
+ #define YYPURE 1
+ /* Using locations.  */
+ #define YYLSP_NEEDED 0
- /*  A Bison parser, made from compile.y
-     by GNU Bison version 1.28  */
- #define YYBISON 1  /* Identify Bison output.  */
- #define EON     257
+ /* Tokens.  */
- #define STRING  258
+ #ifndef YYTOKENTYPE
- #define BOGUS   259
+ # define YYTOKENTYPE
- #define BAD_STRING_COMPARISON_OPERATOR  260
+    /* Put the tokens into the symbol table, so that GDB and other debuggers
- #define BAD_HEX_LITERAL 261
+       know about them.  */
- #define BAD_METHOD_DECL_START   262
+    enum yytokentype {
- #define BAD_METHOD_PARAMETER_NAME_CHARACTER     263
+      EON = 258,
- #define BAD_MATH_OPERATOR_CHARACTER     264
+      STRING = 259,
- #define LAND    265
+      BOGUS = 260,
- #define LOR     266
+      BAD_STRING_COMPARISON_OPERATOR = 261,
- #define LXOR    267
+      BAD_HEX_LITERAL = 262,
- #define NXOR    268
+      BAD_METHOD_DECL_START = 263,
- #define NLE     269
+      BAD_METHOD_PARAMETER_NAME_CHARACTER = 264,
- #define NGE     270
+      BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE = 265,
- #define NEQ     271
+      LAND = 266,
- #define NNE     272
+      LOR = 267,
- #define NSL     273
+      LXOR = 268,
- #define NSR     274
+      NXOR = 269,
- #define SLT     275
+      NLE = 270,
- #define SGT     276
+      NGE = 271,
- #define SLE     277
+      NEQ = 272,
- #define SGE     278
+      NNE = 273,
- #define SEQ     279
+      NSL = 274,
- #define SNE     280
+      NSR = 275,
- #define DEF     281
+      SLT = 276,
- #define IN      282
+      SGT = 277,
- #define FEXISTS 283
+      SLE = 278,
- #define DEXISTS 284
+      SGE = 279,
- #define IS      285
+      SEQ = 280,
- #define NUNARY  286
+      SNE = 281,
+      DEF = 282,
+      IN = 283,
+      FEXISTS = 284,
+      DEXISTS = 285,
+      IS = 286,
+      NUNARY = 287
+    };
+ #endif
+ #define EON 258
+ #define STRING 259
+ #define BOGUS 260
+ #define BAD_STRING_COMPARISON_OPERATOR 261
+ #define BAD_HEX_LITERAL 262
+ #define BAD_METHOD_DECL_START 263
+ #define BAD_METHOD_PARAMETER_NAME_CHARACTER 264
+ #define BAD_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 NUNARY 287
+ /* Copy the first part of user declarations.  */
  #line 1 "compile.y"
  /** @file
- Line 62
+ Line 147
  #define YYLEX_PARAM  pc
  #define YYDEBUG  1
  #define YYERROR_VERBOSE 1
- #define yyerror(msg)  real_yyerror((parse_control *)pc, msg)
+ #define yyerror(msg)  real_yyerror((Parse_control *)pc, msg)
  #define YYPRINT(file, type, value)  yyprint(file, type, value)
+ // includes
  #include "compile_tools.h"
  #include "pa_value.h"
  #include "pa_request.h"
- Line 74
+ Line 161
  #include "pa_vvoid.h"
  #include "pa_vmethod_frame.h"
+ // defines
  #define USE_CONTROL_METHOD_NAME "USE"
- static int real_yyerror(parse_control *pc, char *s);
+ // forwards
- static void yyprint(FILE *file, int type, YYSTYPE value);
- static int yylex(YYSTYPE *lvalp, void *pc);
+ static int real_yyerror(Parse_control* pc, char* s);
+ static void yyprint(FILE* file, int type, YYSTYPE value);
+ static int yylex(YYSTYPE* lvalp, void* pc);
  // local convinient inplace typecast & var
  #undef PC
- #define PC  (*(parse_control *)pc)
+ #define PC  (*(Parse_control *)pc)
  #undef POOL
  #define POOL  (*PC.pool)
  #ifndef DOXYGEN
- #ifndef YYSTYPE
- #define YYSTYPE int
- #endif
- #include <stdio.h>
- #ifndef __cplusplus
- #ifndef __STDC__
+ /* Enabling traces.  */
- #define const
+ #ifndef YYDEBUG
+ # define YYDEBUG 0
  #endif
+ /* Enabling verbose error messages.  */
+ #ifdef YYERROR_VERBOSE
+ # undef YYERROR_VERBOSE
+ # define YYERROR_VERBOSE 1
+ #else
+ # define YYERROR_VERBOSE 0
  #endif
+ #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 208 "compile.tab.C"
+ #if ! defined (yyoverflow) || YYERROR_VERBOSE
+ /* The parser invokes alloca or malloc; define the necessary symbols.  */
+ # if YYSTACK_USE_ALLOCA
+ #  define YYSTACK_ALLOC alloca
+ # else
+ #  ifndef YYSTACK_USE_ALLOCA
+ #   if defined (alloca) || defined (_ALLOCA_H)
+ #    define YYSTACK_ALLOC alloca
+ #   else
+ #    ifdef __GNUC__
+ #     define YYSTACK_ALLOC __builtin_alloca
+ #    endif
+ #   endif
+ #  endif
+ # endif
+ # ifdef YYSTACK_ALLOC
+    /* Pacify GCC's `empty if-body' warning. */
+ #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+ # else
+ #  if defined (__STDC__) || defined (__cplusplus)
+ #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ #   define YYSIZE_T size_t
+ #  endif
+ #  define YYSTACK_ALLOC malloc
+ #  define YYSTACK_FREE free
+ # endif
+ #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+ #if (! defined (yyoverflow) \
+      && (! defined (__cplusplus) \
+          || (YYSTYPE_IS_TRIVIAL)))
+ /* A type that is properly aligned for any stack member.  */
+ union yyalloc
+ {
+   short yyss;
+   YYSTYPE yyvs;
+   };
+ /* The size of the maximum gap between one aligned stack and the next.  */
+ # define YYSTACK_GAP_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) + sizeof (YYSTYPE))                         \
+       + YYSTACK_GAP_MAXIMUM)
+ /* Copy COUNT objects from FROM to TO.  The source and destination do
+    not overlap.  */
+ # ifndef YYCOPY
+ #  if 1 < __GNUC__
+ #   define YYCOPY(To, From, Count) \
+       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+ #  else
+ #   define YYCOPY(To, From, Count)              \
+       do                                        \
+         {                                       \
+           register YYSIZE_T yyi;                \
+           for (yyi = 0; yyi < (Count); yyi++)   \
+             (To)[yyi] = (From)[yyi];            \
+         }                                       \
+       while (0)
+ #  endif
+ # endif
+ /* Relocate STACK from its old location to the new one.  The
+    local variables YYSIZE and YYSTACKSIZE give the old and new number of
+    elements in the stack, and YYPTR gives the new location of the
+    stack.  Advance YYPTR to a properly aligned location for the next
+    stack.  */
+ # define YYSTACK_RELOCATE(Stack)                                        \
+     do                                                                  \
+       {                                                                 \
+         YYSIZE_T yynewbytes;                                            \
+         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
+         Stack = &yyptr->Stack;                                          \
+         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_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 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   479
-,    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  60
-,   128,   131,   133,   135,   137,   141,   145,   149,   151,
+ /* YYNNTS -- Number of nonterminals. */
-,   155,   157,   159,   161,   164,   166,   167,   168,   175,
+ #define YYNNTS  87
-,   179,   182,   184,   186,   188,   192,   196,   200,   202,
+ /* YYNRULES -- Number of rules. */
-,   208,   212,   214,   218,   220,   222,   224,   226,   228,
+ #define YYNRULES  168
-,   232,   234,   237,   239,   242,   245,   247,   249,   252,
+ /* YYNRULES -- Number of states. */
-,   256,   258,   260,   263,   266,   270,   272,   274,   277,
+ #define YYNSTATES  259
-,   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   287
-,   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,    44,    58,     2,    50,    41,    35,    59,
+,    55,    38,    36,     2,    37,    53,    39,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,    57,    49,
+,     2,    33,     2,    45,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+,    47,    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,     2,     3,     4,
+,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    26,    27,    28,    29,    30,    31,    42
  };
- 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 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,    40,    49,
-,   138,     0,     4,     0,   138,     0,    76,     0,    77,
+,    53,    57,    59,    61,    63,    67,    69,    71,    73,
-,    76,    77,     0,   136,     0,    78,     0,    79,     0,
+,    77,    80,    82,    84,    86,    88,    90,    92,    95,
-,     0,   100,     0,    80,     0,    50,    81,     0,    83,
+,   100,   104,   106,   108,   110,   113,   115,   118,   122,
-,     0,    82,     0,    51,    83,    52,     0,    84,     0,
+,   126,   128,   130,   133,   136,   138,   140,   142,   143,
-,     0,    86,     0,   130,    86,     0,   122,     0,   119,
+,   150,   154,   158,   160,   162,   164,   166,   168,   170,
-,     0,    50,    88,    92,     0,    89,     0,    90,     0,
+,   175,   176,   177,   184,   186,   188,   191,   193,   195,
-,     0,   118,     0,    53,   118,     0,   130,   118,     0,
+,   198,   199,   205,   209,   213,   215,   219,   221,   225,
-,     0,    94,     0,    95,     0,    47,    96,    48,     0,
+,   231,   233,   235,   237,   239,   241,   243,   245,   248,
-,   133,    55,     0,    51,    75,    52,     0,   137,     0,
+,   253,   256,   258,   260,   263,   265,   267,   269,   271,
-,     0,    97,     0,    98,     0,    99,     0,    78,     0,
+,   277,   278,   279,   285,   287,   289,   292,   295,   297,
-,    76,     0,   101,     0,     0,     0,    56,   102,   104,
+,   302,   305,   307,   309,   311,   313,   317,   321,   325,
-,   105,     3,     0,    83,     0,   106,     0,   105,   106,
+,   331,   334,   337,   340,   343,   346,   349,   353,   357,
-,   107,     0,   108,     0,   109,     0,    47,   110,    48,
+,   365,   369,   373,   377,   381,   385,   389,   393,   397,
-,    54,   111,    55,     0,    51,   112,    52,     0,   113,
+,   405,   409,   413,   417,   421,   425,   429,   433,   437,
-,   110,    49,   113,     0,   114,     0,   111,    49,   114,
+,   445,   449,   453,   457,   459,   461,   463,   464
-,   115,     0,   112,    49,   115,     0,   116,     0,   117,
-,    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 yyrhs[] =
+ {
+,     0,    -1,    63,    -1,    62,    -1,    64,    -1,    62,
+,    -1,    77,    -1,    65,    -1,    70,    -1,    45,     4,
+,    66,    -1,   146,    -1,    67,    -1,    68,    -1,    67,
+,    -1,    69,    46,    -1,   146,    -1,     4,    -1,    -1,
+,     4,    73,    72,    76,    46,    71,    77,    -1,   146,
+       -1,    73,    -1,    47,    74,    48,    -1,   146,    -1,    75,
+       -1,     4,    -1,    75,    49,     4,    -1,   146,    -1,     4,
+       -1,   146,    -1,    78,    -1,    79,    -1,    78,    79,    -1,
+,    -1,    80,    -1,    81,    -1,    89,    -1,   104,    -1,
+,    -1,    50,    83,    -1,    85,     3,    -1,    84,    -1,
+,    85,    52,    -1,    86,    -1,    87,    -1,    88,    -1,
+,    88,    -1,   127,    -1,   124,   127,    -1,    50,    90,
+,    -1,    91,    -1,    92,    -1,    93,    -1,   123,    -1,
+,   123,    -1,   137,   123,    -1,    95,    -1,    98,    -1,
+,    -1,    -1,    -1,    47,    96,   100,    97,    48,    -1,
+,   140,    55,    -1,    51,    77,    52,    -1,   145,    -1,
+,    -1,   101,    -1,   102,    -1,   103,    -1,    80,    -1,
+,    78,    -1,   105,    -1,    -1,    -1,    56,   106,   108,
+,   109,     3,    -1,    85,    -1,   110,    -1,   109,   110,
+       -1,   111,    -1,   114,    -1,   115,    -1,    -1,    -1,    47,
+,   116,   113,    48,    -1,    54,   117,    55,    -1,    51,
+,    52,    -1,   119,    -1,   116,    49,   119,    -1,   120,
+       -1,   117,    49,   120,    -1,   121,    -1,   118,    49,   121,
+       -1,   122,    -1,   140,    -1,    77,    -1,   145,    -1,     4,
+       -1,   101,    -1,   128,    -1,   124,   128,    -1,   125,    -1,
+,   125,    -1,   126,    53,    -1,   128,    -1,   128,    -1,
+,     5,    -1,     4,    -1,   129,    -1,   130,    -1,   131,
+       -1,    50,   134,    -1,     4,   135,    -1,    -1,    -1,    47,
+,    78,   133,    48,    -1,     4,    -1,   136,    -1,   135,
+,    -1,    50,   134,    -1,   138,    -1,   139,    -1,     4,
+,    -1,   138,    57,    -1,   141,    -1,   142,    -1,    82,
+       -1,   105,    -1,    58,   143,    58,    -1,    59,   143,    59,
+       -1,    54,   141,    55,    -1,    37,   141,    -1,    36,   141,
+       -1,    43,   141,    -1,    44,   141,    -1,    27,   141,    -1,
+,   141,    -1,    29,   141,    -1,    30,   141,    -1,   141,
+,   141,    -1,   141,    36,   141,    -1,   141,    38,   141,
+       -1,   141,    39,   141,    -1,   141,    41,   141,    -1,   141,
+,   141,    -1,   141,    19,   141,    -1,   141,    20,   141,
+       -1,   141,    35,   141,    -1,   141,    34,   141,    -1,   141,
+,   141,    -1,   141,    11,   141,    -1,   141,    12,   141,
+       -1,   141,    13,   141,    -1,   141,    32,   141,    -1,   141,
+,   141,    -1,   141,    15,   141,    -1,   141,    16,   141,
+       -1,   141,    17,   141,    -1,   141,    18,   141,    -1,   141,
+,   141,    -1,   141,    22,   141,    -1,   141,    23,   141,
+       -1,   141,    24,   141,    -1,   141,    25,   141,    -1,   141,
+,   141,    -1,   141,    31,   141,    -1,     4,    -1,    77,
+       -1,     4,    -1,    -1,    -1
+ };
- #if YYDEBUG != 0
+ /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
- static const short yyrline[] = { 0,
+ static const unsigned short yyrline[] =
-,   123,   125,   125,   126,   128,   128,   130,   202,   202,
+ {
-,   203,   204,   205,   205,   207,   236,   236,   237,   238,
+,   121,   121,   128,   130,   130,   131,   133,   133,   135,
-,   239,   239,   241,   241,   245,   245,   247,   247,   248,
+,   207,   208,   208,   209,   210,   210,   212,   212,   252,
-,   249,   249,   249,   253,   260,   261,   261,   262,   263,
+,   253,   254,   254,   255,   255,   257,   257,   261,   261,
-,   266,   288,   289,   289,   293,   297,   299,   300,   301,
+,   263,   264,   264,   265,   265,   265,   269,   276,   277,
-,   323,   325,   327,   328,   330,   336,   344,   350,   352,
+,   278,   280,   281,   282,   304,   305,   305,   309,   314,
-,   355,   361,   362,   362,   366,   372,   375,   378,   391,
+,   316,   317,   334,   339,   342,   343,   344,   346,   349,
-,   393,   394,   396,   397,   399,   400,   401,   402,   404,
+,   357,   365,   372,   373,   374,   376,   382,   383,   383,
-,   408,   410,   412,   414,   418,   422,   426,   428,   429,
+,   393,   396,   393,   412,   414,   414,   416,   417,   418,
-,   440,   440,   442,   442,   443,   444,   452,   457,   459,
+,   423,   420,   426,   427,   429,   430,   433,   434,   437,
-,   462,   463,   465,   469,   478,   484,   489,   489,   490,
+,   440,   444,   458,   463,   464,   465,   470,   470,   472,
-,   497,   499,   511,   523,   528,   530,   531,   532,   533,
+,   473,   474,   482,   487,   490,   491,   492,   493,   495,
-,   536,   537,   538,   539,   540,   541,   542,   543,   545,
+,   508,   511,   508,   519,   524,   524,   525,   531,   532,
-,   547,   548,   549,   550,   551,   552,   553,   554,   555,
+,   546,   558,   560,   561,   562,   563,   564,   565,   567,
-,   557,   558,   559,   560,   561,   562,   563,   564,   565,
+,   569,   570,   571,   572,   573,   574,   576,   577,   578,
-,   567,   568,   569,   570,   571,   574,   583,   588,   589
+,   580,   581,   582,   583,   584,   585,   586,   587,   588,
+,   590,   591,   592,   593,   594,   595,   596,   597,   598,
+,   600,   601,   602,   605,   610,   619,   624,   625
  };
  #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\"", "'<'",
- "maybe_string","code_method","maybe_bracketed_strings","bracketed_maybe_strings",
+   "'>'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'", "'\\\\'", "'%'",
- "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", "@1",
- "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",
- "name_advance1","name_advance2","name_expr_value","name_expr_subvar_value","name_expr_with_subvar_value",
+   "put", "name_expr_wdive", "name_expr_wdive_root",
- "name_square_code_value","subvar_ref_name_rdive","subvar_get_writes","subvar__get_write",
+   "name_expr_wdive_write", "name_expr_wdive_class", "construct",
- "class_prefix","class_static_prefix","class_constructor_prefix","expr_value",
+   "construct_square", "@2", "@3", "construct_round", "construct_curly",
- "expr","string_inside_quotes_value","write_string","void_value","empty", NULL
+   "any_constructor_code_value", "constructor_code_value",
+   "constructor_code", "codes__excluding_sole_str_literal", "call",
+   "call_value", "@4", "@5", "call_name", "store_params", "store_param",
+   "store_square_param", "@6", "@7", "store_round_param",
+   "store_curly_param", "store_code_param_parts", "store_expr_param_parts",
+   "store_curly_param_parts", "store_code_param_part",
+   "store_expr_param_part", "store_curly_param_part", "code_param_value",
+   "name_expr_dive_code", "name_path", "name_step", "name_advance1",
+   "name_advance2", "name_expr_value", "name_expr_subvar_value",
+   "name_expr_with_subvar_value", "name_square_code_value", "@8", "@9",
+   "subvar_ref_name_rdive", "subvar_get_writes", "subvar__get_write",
+   "class_prefix", "class_static_prefix", "class_constructor_prefix",
+   "expr_value", "expr", "double_or_STRING", "string_inside_quotes_value",
+   "write_string", "void_value", "empty", 0
  };
  #endif
- static const short yyr1[] = {     0,
+ # ifdef YYPRINT
-,    60,    61,    61,    62,    63,    63,    64,    65,    65,
+ /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
-,    66,    67,    68,    68,    69,    70,    70,    71,    72,
+    token YYLEX-NUM.  */
-,    73,    73,    74,    74,    75,    75,    76,    76,    77,
+ static const unsigned short yytoknum[] =
-,    78,    78,    78,    79,    80,    81,    81,    82,    83,
+ {
-,    84,    85,    86,    86,    87,    88,    88,    88,    89,
+,   256,   257,   258,   259,   260,   261,   262,   263,   264,
-,    91,    92,    92,    92,    93,    94,    95,    96,    96,
+,   266,   267,   268,   269,   270,   271,   272,   273,   274,
-,    97,    98,    99,    99,   100,   102,   103,   101,   104,
+,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-,   105,   106,   106,   106,   107,   108,   109,   110,   110,
+,   286,    60,    62,   124,    38,    43,    45,    42,    47,
-,   111,   112,   112,   113,   114,   115,   116,   116,   116,
+,    37,   287,   126,    33,    64,    10,    91,    93,    59,
-,   118,   118,   119,   119,   120,   121,   122,   122,   123,
+,   123,   125,    46,    40,    41,    94,    58,    34,    39
-,   123,   123,   124,   125,   126,   127,   128,   128,   129,
-,   130,   131,   132,   133,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   134,   134,   134,   134,
-,   134,   134,   134,   134,   134,   135,   136,   137,   138
  };
+ # endif
- static const short yyr2[] = {     0,
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-,     1,     1,     2,     1,     1,     1,     4,     1,     1,
+ static const unsigned char yyr1[] =
-,     2,     2,     1,     1,     7,     1,     1,     3,     1,
+ {
-,     1,     3,     1,     1,     1,     1,     1,     2,     1,
+,    60,    61,    61,    62,    62,    63,    64,    64,    65,
-,     1,     1,     1,     1,     2,     2,     1,     3,     1,
+,    66,    67,    67,    68,    69,    69,    71,    70,    72,
-,     1,     2,     1,     2,     3,     1,     1,     1,     1,
+,    73,    74,    74,    75,    75,    76,    76,    77,    77,
-,     2,     1,     1,     1,     3,     3,     3,     1,     1,
+,    78,    79,    79,    80,    80,    80,    81,    82,    83,
-,     1,     1,     1,     2,     1,     0,     0,     6,     1,
+,    84,    85,    85,    86,    87,    88,    88,    89,    90,
-,     2,     1,     1,     1,     3,     3,     3,     1,     3,
+,    90,    91,    92,    93,    94,    94,    94,    96,    97,
-,     3,     1,     3,     1,     1,     1,     1,     1,     1,
+,    98,    99,   100,   100,   100,   101,   102,   103,   103,
-,     1,     2,     1,     2,     2,     1,     1,     2,     1,
+,   106,   107,   105,   108,   109,   109,   110,   110,   110,
-,     1,     1,     2,     2,     3,     1,     1,     2,     2,
+,   113,   111,   114,   115,   116,   116,   117,   117,   118,
-,     1,     2,     2,     1,     1,     1,     1,     3,     3,
+,   119,   120,   121,   122,   122,   122,   123,   123,   124,
-,     2,     2,     2,     2,     2,     2,     2,     2,     3,
+,   125,   126,   127,   127,   128,   128,   128,   128,   129,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   132,   133,   131,   134,   135,   135,   136,   137,   137,
-,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+,   139,   140,   141,   141,   141,   141,   141,   141,   141,
-,     3,     3,     3,     3,     3,     1,     1,     0,     0
+,   141,   141,   141,   141,   141,   141,   141,   141,   141,
+,   141,   141,   141,   141,   141,   141,   141,   141,   141,
+,   141,   141,   141,   141,   141,   141,   141,   141,   141,
+,   141,   141,   141,   142,   143,   144,   145,   146
  };
- 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,     0,     8,     1,
-,    92,   101,   102,   103,     0,   111,   112,     0,     4,
+,     3,     1,     1,     1,     3,     1,     1,     1,     1,
-,   160,   160,   160,    99,     0,   113,   105,   108,     0,
+,     2,     1,     1,     1,     1,     1,     1,     2,     2,
-,   104,     0,     0,    98,     0,   100,    51,     0,    92,
+,     3,     1,     1,     1,     2,     1,     2,     3,     1,
-,   159,   160,     0,    46,    53,    54,    55,   100,    95,
+,     1,     1,     2,     2,     1,     1,     1,     0,     0,
-,    93,    96,    43,    52,   114,    70,    68,    15,     8,
+,     3,     3,     1,     1,     1,     1,     1,     1,     2,
-,    11,     0,     9,    22,     0,    21,    20,   160,    18,
+,     0,     0,     6,     1,     1,     2,     1,     1,     1,
-,   110,   109,   106,    39,    93,   158,     0,    31,     0,
+,     0,     5,     3,     3,     1,     3,     1,     3,     1,
-,    62,    63,    59,     0,   116,     0,     0,     0,     0,
+,     1,     1,     1,     1,     1,     1,     1,     2,     1,
-,     0,     0,     0,     0,     0,   160,   160,   117,   118,
+,     2,     1,     1,     2,     1,     1,     1,     1,     2,
-,   115,     0,    12,    14,    13,    19,     0,    25,     0,
+,     0,     0,     5,     1,     1,     2,     2,     1,     1,
-,    65,    56,    58,   126,   127,   128,   129,   123,   122,
+,     2,     1,     1,     1,     1,     3,     3,     3,     2,
-,   125,     0,   157,     0,     0,    57,     0,     0,     0,
+,     2,     2,     2,     2,     2,     2,     3,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-,     0,     0,     0,   159,   160,     0,     0,    71,    73,
+,     3,     3,     3,     1,     1,     1,     0,     0
-,    75,    23,   160,   121,   119,   120,   141,   142,   143,
-,   146,   147,   148,   149,   136,   137,   150,   151,   152,
-,   154,   155,   156,   144,   145,   139,   138,   131,   130,
-,   133,   135,   134,   158,    90,     0,    79,    85,    88,
-,     0,    83,     0,    81,    86,    91,    69,    72,    16,
-,   159,   160,    78,     0,    77,    80,    84,    82,     0,
-,     0
  };
- static const short yydefgoto[] = {   250,
+ /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-,     6,     7,     8,    90,    91,    92,    93,     9,    99,
+    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
-,    96,    97,   140,   154,    11,    12,    13,    14,   129,
+    means the default is an error.  */
-,    28,    29,    30,    31,    32,    16,    33,    34,    35,
+ static const unsigned char yydefact[] =
-,    75,    76,    77,    78,   110,   226,   112,   113,    17,
+ {
-,    49,   133,    88,   188,   189,   190,   191,   192,   227,
+,   166,     0,     0,    71,     0,     3,     2,     4,     7,
-,   232,   228,   235,   233,   229,   236,    37,    64,    39,
+,     6,    29,    30,    33,    34,    37,    35,    36,    70,
-,    41,    65,    43,    44,    45,    62,    58,    59,    66,
+,    28,     0,   105,   111,     0,     0,     0,    38,    40,
-,    48,   237,   132,   155,    19,   230,    20
+,    42,    43,    44,     0,    49,    50,    51,    52,     0,
+,     0,    46,    97,   106,   107,   108,     0,   118,   119,
+,     1,     5,    31,   168,   168,   168,   104,     0,   120,
+,   115,     0,   114,   109,     0,     0,   103,     0,   105,
+,     0,    97,    39,    58,   168,     0,    48,    55,    56,
+,   105,   100,    47,    98,   101,    45,    54,   121,    74,
+,    16,     9,    11,    12,     0,    10,    24,     0,    23,
+,   168,    20,    19,   117,   116,   112,    41,    98,   167,
+,   164,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,   168,   168,   124,   125,     0,   122,   123,     0,
+,    15,    14,    21,     0,    27,     0,    26,     0,   166,
+,    33,    59,    65,    66,    67,    63,    62,   133,   134,
+,   136,   130,   129,   131,   132,     0,   165,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,    80,   168,
+,     0,    75,    77,    78,    79,    25,    17,   113,    69,
+,   128,   126,   127,   148,   149,   150,   147,   153,   154,
+,   156,   143,   144,   157,   158,   159,   160,   161,   162,
+,   151,   152,   146,   145,   138,   137,   139,   140,   142,
+,   167,    93,     0,    89,     0,    87,    92,    73,    76,
+,    60,   166,    96,    81,    85,    91,    94,   168,    84,
+,    83,    18,   167,     0,    90,    88,    86,    82
  };
- static const short yypact[] = {    13,
+ /* YYDEFGOTO[NTERM-NUM]. */
- -32768,    24,    98,-32768,    36,-32768,-32768,-32768,-32768,-32768,
+ static const short yydefgoto[] =
-,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ {
-    -26,    39,    14,    44,    45,   100,-32768,-32768,    47,-32768,
+       -1,     5,     6,     7,     8,     9,    92,    93,    94,    95,
- -32768,-32768,    52,-32768,-32768,-32768,-32768,   118,-32768,    59,
+,   240,   101,    56,    98,    99,   136,   157,    12,    13,
- -32768,     4,-32768,-32768,-32768,   118,    -3,-32768,    45,-32768,
+,    15,   124,    28,    29,    30,    31,    32,    33,    17,
- -32768,   101,   113,    71,-32768,    44,-32768,    70,-32768,    32,
+,    35,    36,    37,    77,    78,   109,   200,    79,    80,
- -32768,-32768,    73,   118,    83,   118,    70,-32768,   100,    83,
+,   243,   144,   145,    18,   125,    50,   129,    90,   191,
- -32768,    27,    14,    57,-32768,-32768,-32768,-32768,     1,-32768,
+,   193,   231,   254,   194,   195,   244,   235,   233,   245,
- -32768,     4,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+,   234,   246,    38,    66,    40,    41,    42,    67,    44,
-,-32768,    78,    91,-32768,    90,    94,-32768,   135,-32768,
+,    46,    62,   138,    64,    60,    61,    68,    48,    49,
- -32768,-32768,-32768,-32768,-32768,    83,    92,    14,   -22,   106,
+,   127,   128,   158,    20,   247,    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 -106
- -32768,-32768,    -6,-32768,-32768,   -37,-32768,-32768,-32768,-32768,
+ static const short yypact[] =
- -32768,-32768,-32768,-32768,-32768,-32768,   119,-32768,-32768,-32768,
+ {
-,-32768,-32768,-32768,-32768,    -4,-32768,-32768,-32768,-32768,
+,  -106,    15,    39,  -106,    28,   -13,  -106,  -106,  -106,
- -32768,-32768,   -50,   -52,   -48,-32768,-32768,   -16,    95,   -23,
+     -106,  -106,     5,  -106,  -106,  -106,  -106,  -106,  -106,  -106,
- -32768,   -24,     9,-32768,-32768,-32768,   169,-32768,   168,   224,
+     -106,  -106,    51,    16,  -106,    43,    65,    67,  -106,  -106,
- -32768,-32768,   154,    40,   102,-32768,   157,   -20
+,  -106,  -106,  -106,   -29,  -106,  -106,  -106,  -106,    89,
+     -106,    34,  -106,    17,  -106,  -106,  -106,    89,    25,  -106,
+,  -106,  -106,  -106,    97,   106,    69,  -106,    43,  -106,
+,  -106,     5,  -106,  -106,    82,    89,    85,    89,    63,
+     -106,    67,    85,  -106,  -106,     5,     9,  -106,  -106,  -106,
+     -106,     6,  -106,  -106,    17,  -106,  -106,  -106,  -106,  -106,
+     -106,  -106,  -106,    12,  -106,    98,    99,  -106,    87,    94,
+     -106,   142,  -106,  -106,  -106,  -106,     5,  -106,    85,    22,
+,  -106,     9,     9,     9,     9,     9,     9,     9,     9,
+,     9,     5,     5,  -106,  -106,    92,   272,  -106,    -3,
+     -106,  -106,  -106,  -106,   164,  -106,   148,  -106,   140,   147,
+,    70,  -106,  -106,  -106,  -106,  -106,  -106,   431,   431,
+,   431,  -106,  -106,  -106,  -106,   138,  -106,   139,   137,
+     -106,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+,     9,     9,     9,     9,     9,     9,     9,  -106,     5,
+,    37,  -106,  -106,  -106,  -106,  -106,  -106,  -106,     5,
+,  -106,  -106,  -106,   362,   334,   303,   146,   390,   390,
+,   403,   189,   189,   390,   390,   390,   390,   403,   403,
+,   390,   390,   438,   198,    90,    90,  -106,  -106,  -106,
+     -106,    29,  -106,   -25,  -106,   -26,  -106,  -106,  -106,  -106,
+,  -106,    72,  -106,   151,  -106,  -106,  -106,     5,  -106,
+,  -106,  -106,    29,   154,  -106,  -106,  -106,  -106
  };
+ /* YYPGOTO[NTERM-NUM].  */
- #define YYLAST          494
+ static const short yypgoto[] =
+ {
+     -106,  -106,  -106,  -106,   197,  -106,  -106,  -106,   111,  -106,
- static const short yytable[] = {    15,
+     -106,  -106,  -106,   149,  -106,  -106,  -106,     1,   -59,    -7,
-,    18,    10,    51,    60,    55,   -98,   238,    84,    68,
+     -105,  -106,     0,  -106,  -106,    -9,  -106,  -106,   -37,  -106,
-,    42,    18,    81,    80,   245,     1,     1,    63,    52,
+     -106,  -106,  -106,  -106,  -106,  -106,  -106,  -106,  -106,  -106,
-,   246,    15,    89,    18,   -64,   -64,    21,    84,    85,
+     -106,   110,  -106,  -106,  -106,     2,  -106,  -106,  -106,  -106,
-,    94,    98,   101,    70,     1,   -89,   -89,   243,    81,
+,  -106,  -106,  -106,  -106,  -106,  -106,  -106,  -106,   -47,
-,   244,    87,    55,   225,    80,    82,    61,    22,    71,
+      -30,   -27,  -106,   -12,    80,    66,  -106,   -32,     3,  -106,
-,   185,    51,    86,    42,   186,   -97,     2,   187,    15,
+     -106,  -106,  -106,  -106,   165,  -106,   162,   229,  -106,  -106,
-,    18,     3,     3,   108,  -160,   241,   242,     4,     4,
+,    95,  -106,   121,  -106,   136,    40
-,    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 -169
-,    52,    49,     5,     4,    69,    38,     4,     4,     3,
+ static const short yytable[] =
-,    47,    60,    57,    46,    51,    53,    45,    54,    60,
+ {
-,    60,    50,    50,    72,    46,    48,    49,    56,    56,
+,    11,    19,   106,   141,    53,    43,    83,     1,     1,
-,    72,    73,    72,    73,    73,    50,    69,    99,    48,
+,    57,    16,   111,    19,    70,    91,    65,    74,    22,
-,    50,    56,    27,    28,    29,    30,    56,    50,   108,
+     -103,    57,    75,   250,   248,    76,   139,   249,    51,   251,
-,    47,    36,    37,    50,    57,    56,     3,    47,    43,
+,    86,     2,   242,    83,    87,   112,   113,   114,   115,
-,     4,    51,     4,     4,    54,    50,   108,     4,   108,
+,    89,    84,    23,   188,   116,   117,    63,   189,     2,
-,    53,    56,   185,    58,    59,     4,    47,    47,    50,
+,   190,   118,   119,     3,     3,    58,    23,  -168,   120,
-,     4,    51,    46,    52,    54,   127,   128,   127,   128,
+,     4,    16,   121,    19,     4,    58,   122,   123,    23,
-,    39,    40,    41,   142,    53,    46,    48,     4,    48,
+     -102,    69,     3,    59,   108,    16,   110,    19,     4,     3,
-,   142,    49,   142,    47,     4,    47,    50,    51,    50,
+,   199,    88,    39,   188,     4,    24,    85,   189,    25,
-,    47,    46,    48,    50,    51,   117,   118,   119,   120,
+,   190,    27,    81,    96,   100,   103,    54,    55,    53,
-,   122,   123,   124,    47,   126,    52,    50,    55,    58,
+,    91,   140,    25,    26,    82,    16,    71,    19,    16,
-,    36,    37,    38,    39,    40,    41,   185,    59,     0,
+,    19,    24,    58,    24,    25,    55,    25,   -68,   -68,
-,     5,    54,   188,   185,   186,   185,   186,   186,    91,
+      -95,   -95,    16,    16,    19,    19,   141,    39,   184,   185,
-,   242,   245,   194,   243,   194,   194,   158,   159,   160,
+,   187,    82,   131,   107,   133,    24,    82,  -102,    25,
-,   162,   163,   164,   165,   166,   167,   168,   169,   170,
+,   137,    19,   134,   132,   -15,   135,   160,   141,   161,
-,   172,   173,   174,   175,   176,   177,   178,   179,   180,
+,   163,   164,   165,   166,   167,   168,   169,   170,   171,
-,   182,   183,   184,    56,    58,     3,    74,    72,   128,
+,   173,   174,   175,   176,   169,   170,   147,   196,   177,
-     -1,    -1,    -1,    -1,   242,    -1,    -1,    -1,    -1,    -1,
+,   179,   180,   181,   182,   183,   184,   185,   186,   187,
-     -1,   242,   243,   242,   243,   243,    11,    12,    13,    14,
+,   181,   182,   183,   184,   185,   186,   187,   198,    16,
-,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+,    19,    53,   201,   197,   -64,   203,   202,   241,    16,
-,    26,    19,    20,    -1,    -1,    31,    32,    33,    34,
+,    19,   258,    52,   130,   102,   257,   148,   149,   150,
-,    36,    37,    38,    39,    40,    41,    34,    35,    36,
+,   152,   153,   154,   155,   239,   156,   169,   170,   143,
-,    38,    39,    40,    41,    -1,    -1,    -1,    -1,    -1,
+,   255,   105,   104,   140,   182,   183,   184,   185,   186,
-,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+,    16,    47,    19,   182,   183,   184,   185,   186,   187,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,   252,    19,   126,   159,   146,   140,     0,    16,   232,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,     0,     0,    16,     0,    19,   204,   205,   206,   207,
-,    41,    11,    12,    -1,    14,    15,    16,    17,    18,
+,   209,   210,   211,   212,   213,   214,   215,   216,   217,
-,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
+,   219,   220,   221,   222,   223,   224,   225,   226,   227,
-     -1,    -1,    31,    32,    33,    34,    35,    36,    37,    38,
+,   229,   230,   161,   162,   163,   164,   165,   166,   167,
-,    40,    41,    11,    -1,    -1,    14,    15,    16,    17,
+,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+,     0,     0,   177,   178,   179,   180,   181,   182,   183,
-     -1,    -1,    -1,    31,    32,    33,    34,    35,    36,    37,
+,   185,   186,   187,   161,   162,     0,   164,   165,   166,
-,    39,    40,    41,    14,    15,    16,    17,    18,    19,
+,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
+,     0,     0,     0,   177,   178,   179,   180,   181,   182,
-     -1,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+,   184,   185,   186,   187,   161,     0,     0,   164,   165,
-,    41,    14,    -1,    -1,    17,    18,    19,    20,    -1,
+,   167,   168,   169,   170,   171,   172,   173,   174,   175,
-     -1,    -1,    -1,    25,    26,    14,    -1,    -1,    -1,    31,
+,     0,     0,     0,     0,   177,   178,   179,   180,   181,
-,    20,    34,    35,    36,    37,    38,    39,    40,    41,
+,   183,   184,   185,   186,   187,   164,   165,   166,   167,
-     -1,    -1,    31,    -1,    -1,    34,    35,    36,    37,    38,
+,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-,    40,    41,    14,    -1,    -1,    -1,    -1,    19,    20,
+,     0,     0,   177,   178,   179,   180,   181,   182,   183,
-     -1,    -1,    -1,    -1,    -1,    19,    20,    -1,    -1,    -1,
+,   185,   186,   187,   164,     0,     0,   167,   168,   169,
-     -1,    19,    20,    34,    35,    36,    37,    38,    39,    40,
+,     0,     0,     0,     0,   175,   176,   164,     0,     0,
-,    35,    36,    37,    38,    39,    40,    41,    36,    37,
+,   177,   169,   170,   180,   181,   182,   183,   184,   185,
-,    39,    40,    41
+,   187,     0,     0,   177,     0,     0,   180,   181,   182,
+,   184,   185,   186,   187,   164,     0,     0,     0,     0,
+,   170,     0,     0,     0,     0,     0,   169,   170,     0,
+,     0,     0,     0,     0,   180,   181,   182,   183,   184,
+,   186,   187,   181,   182,   183,   184,   185,   186,   187
  };
- #define YYPURE 1
- /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+ static const short yycheck[] =
- #line 3 "/usr/share/bison.simple"
+ {
- /* This file comes from bison-1.28.  */
+,     0,     0,    62,   109,    12,     3,    39,     4,     4,
+,     5,    12,     4,    12,    27,     4,    26,    47,     4,
- /* Skeleton output parser for bison,
+,     5,    51,    49,    49,    54,     4,    52,     0,    55,
-    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+,    68,    45,     4,    66,    47,    27,    28,    29,    30,
+,    50,    39,     4,    47,    36,    37,     4,    51,    45,
-    This program is free software; you can redistribute it and/or modify
+,    54,    43,    44,    50,    50,    50,     4,    46,    50,
-    it under the terms of the GNU General Public License as published by
+,    56,    62,    54,    62,    56,    50,    58,    59,     4,
-    the Free Software Foundation; either version 2, or (at your option)
+,     4,    50,    57,    71,    75,    75,    75,    56,    50,
-    any later version.
+,   140,    57,     3,    47,    56,    47,    53,    51,    50,
+,    54,    53,     4,    54,    55,    56,    46,    47,   106,
-    This program is distributed in the hope that it will be useful,
+,     4,   109,    50,    51,    39,   106,    27,   106,   109,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+,   109,    47,    50,    47,    50,    47,    50,    48,    49,
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+,    49,   122,   123,   122,   123,   231,    47,    38,    39,
-    GNU General Public License for more details.
+,    41,    66,    93,    52,    48,    47,    71,    53,    50,
+,   101,   140,    49,    46,    46,     4,    55,   253,    11,
-    You should have received a copy of the GNU General Public License
+,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-    along with this program; if not, write to the Free Software
+,    23,    24,    25,    26,    19,    20,    52,     4,    31,
-    Foundation, Inc., 59 Temple Place - Suite 330,
+,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-    Boston, MA 02111-1307, USA.  */
+,    35,    36,    37,    38,    39,    40,    41,    48,   189,
+,   189,   199,    55,    46,    48,    59,    58,    48,   199,
- /* As a special exception, when this file is copied by Bison into a
+,   199,    48,     6,    93,    56,   253,   112,   113,   114,
-    Bison output file, you may use that output file without restriction.
+,   116,   117,   118,   119,   191,   121,    19,    20,   109,
-    This special exception was added by the Free Software Foundation
+,   248,    60,    58,   231,    36,    37,    38,    39,    40,
-    in version 1.24 of Bison.  */
+,   231,     3,   231,    36,    37,    38,    39,    40,    41,
+,   240,   240,    76,   123,   109,   253,    -1,   248,   248,
+,    -1,    -1,   253,    -1,   253,   161,   162,   163,   164,
+,   166,   167,   168,   169,   170,   171,   172,   173,   174,
+,   176,   177,   178,   179,   180,   181,   182,   183,   184,
+,   186,   187,    11,    12,    13,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+       -1,    -1,    -1,    31,    32,    33,    34,    35,    36,    37,
+,    39,    40,    41,    11,    12,    -1,    14,    15,    16,
+,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+       -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,    36,
+,    38,    39,    40,    41,    11,    -1,    -1,    14,    15,
+,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+,    -1,    -1,    -1,    -1,    31,    32,    33,    34,    35,
+,    37,    38,    39,    40,    41,    14,    15,    16,    17,
+,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
+       -1,    -1,    -1,    31,    32,    33,    34,    35,    36,    37,
+,    39,    40,    41,    14,    -1,    -1,    17,    18,    19,
+,    -1,    -1,    -1,    -1,    25,    26,    14,    -1,    -1,
+       -1,    31,    19,    20,    34,    35,    36,    37,    38,    39,
+,    41,    -1,    -1,    31,    -1,    -1,    34,    35,    36,
+,    38,    39,    40,    41,    14,    -1,    -1,    -1,    -1,
+,    20,    -1,    -1,    -1,    -1,    -1,    19,    20,    -1,
+       -1,    -1,    -1,    -1,    -1,    34,    35,    36,    37,    38,
+,    40,    41,    35,    36,    37,    38,    39,    40,    41
+ };
- /* This is the parser code that is written into each bison parser
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
-   when the %semantic_parser declaration is not specified in the grammar.
+    symbol of state STATE-NUM.  */
-   It was written by Richard Stallman by simplifying the hairy parser
+ static const unsigned char yystos[] =
-   used when %semantic_parser is specified.  */
+ {
+,     4,    45,    50,    56,    61,    62,    63,    64,    65,
- #ifndef YYSTACK_USE_ALLOCA
+,    77,    78,    79,    80,    81,    82,    89,   104,   105,
- #ifdef alloca
+,   146,     4,     4,    47,    50,    51,    53,    83,    84,
- #define YYSTACK_USE_ALLOCA
+,    86,    87,    88,    90,    91,    92,    93,   123,   124,
- #else /* alloca not defined */
+,   126,   127,   128,   129,   130,   131,   137,   138,   139,
- #ifdef __GNUC__
+,     0,    64,    79,    46,    47,    73,     5,    50,    57,
- #define YYSTACK_USE_ALLOCA
+,   136,   132,     4,   134,    85,   124,   128,   137,     4,
- #define alloca __builtin_alloca
+,   124,   128,     3,    47,    51,    54,    94,    95,    98,
- #else /* not GNU C.  */
+,     4,   125,   127,   128,    53,    88,   123,    57,    85,
- #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+,     4,    66,    67,    68,    69,   146,     4,    74,    75,
- #define YYSTACK_USE_ALLOCA
+,    72,    73,   146,   134,   136,    78,    52,   128,    96,
- #include <alloca.h>
+,     4,    27,    28,    29,    30,    36,    37,    43,    44,
- #else /* not sparc */
+,    54,    58,    59,    82,   105,   140,   141,   142,   107,
- /* We think this test detects Watcom and Microsoft C.  */
+,   146,    46,    48,    49,     4,    76,   146,   133,     4,
- /* This used to test MSDOS, but that is a bad idea
+,    80,   100,   101,   102,   103,   145,    52,   141,   141,
-    since that symbol is in the user namespace.  */
+,   141,   141,   141,   141,   141,   141,    77,   143,   143,
- #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+,    11,    12,    13,    14,    15,    16,    17,    18,    19,
- #if 0 /* No need for malloc.h, which pollutes the namespace;
+,    21,    22,    23,    24,    25,    26,    31,    32,    33,
-          instead, just don't use alloca.  */
+,    35,    36,    37,    38,    39,    40,    41,    47,    51,
- #include <malloc.h>
+,   109,   110,   111,   114,   115,     4,    46,    48,    78,
- #endif
+,    55,    58,    59,   141,   141,   141,   141,   141,   141,
- #else /* not MSDOS, or __TURBOC__ */
+,   141,   141,   141,   141,   141,   141,   141,   141,   141,
- #if defined(_AIX)
+,   141,   141,   141,   141,   141,   141,   141,   141,   141,
- /* I don't know what this was needed for, but it pollutes the namespace.
+,   112,    77,   118,   121,   117,   120,   140,     3,   110,
-    So I turned it off.   rms, 2 May 1997.  */
+,    48,     4,   101,   116,   119,   122,   145,    49,    52,
- /* #include <malloc.h>  */
+,    55,    77,    49,   113,   121,   120,   119,    48
-  #pragma alloca
+ };
- #define YYSTACK_USE_ALLOCA
- #else /* not MSDOS, or __TURBOC__, or _AIX */
- #if 0
- #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
-                  and on HPUX 10.  Eventually we can turn this on.  */
- #define YYSTACK_USE_ALLOCA
- #define alloca __builtin_alloca
- #endif /* __hpux */
- #endif
- #endif /* not _AIX */
- #endif /* not MSDOS, or __TURBOC__ */
- #endif /* not sparc */
- #endif /* not GNU C */
- #endif /* alloca not defined */
- #endif /* YYSTACK_USE_ALLOCA not defined */
- #ifdef YYSTACK_USE_ALLOCA
+ #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
- #define YYSTACK_ALLOC alloca
+ # define YYSIZE_T __SIZE_TYPE__
- #else
+ #endif
- #define YYSTACK_ALLOC malloc
+ #if ! defined (YYSIZE_T) && defined (size_t)
+ # define YYSIZE_T size_t
+ #endif
+ #if ! defined (YYSIZE_T)
+ # if defined (__STDC__) || defined (__cplusplus)
+ #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+ #  define YYSIZE_T size_t
+ # endif
+ #endif
+ #if ! defined (YYSIZE_T)
+ # define YYSIZE_T unsigned int
  #endif
- /* Note: there must be only one dollar sign in this file.
-    It is replaced by the list of actions, each action
-    as one case of the switch.  */
  #define yyerrok         (yyerrstatus = 0)
  #define yyclearin       (yychar = YYEMPTY)
- #define YYEMPTY         -2
+ #define YYEMPTY         (-2)
  #define YYEOF           0
  #define YYACCEPT        goto yyacceptlab
  #define YYABORT         goto yyabortlab
  #define YYERROR         goto yyerrlab1
- /* Like YYERROR except do call yyerror.
-    This remains here temporarily to ease the
+ /* Like YYERROR except do call yyerror.  This remains here temporarily
-    transition to the new meaning of YYERROR, for GCC.
+    to ease the transition to the new meaning of YYERROR, for GCC.
     Once GCC version 2 has supplanted version 1, this can go.  */
  #define YYFAIL          goto yyerrlab
  #define YYRECOVERING()  (!!yyerrstatus)
- #define YYBACKUP(token, value) \
+ #define YYBACKUP(Token, Value)                                  \
  do                                                              \
    if (yychar == YYEMPTY && yylen == 1)                          \
-     { yychar = (token), yylval = (value);                       \
+     {                                                           \
-       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 (cinluded).                                                   |
+ `------------------------------------------------------------------*/
- #ifdef YYLSP_NEEDED
+ #if defined (__STDC__) || defined (__cplusplus)
- YYLTYPE yylloc;                 /*  location data for the lookahead     */
+ static void
-                                 /*  symbol                              */
+ yy_stack_print (short *bottom, short *top)
+ #else
+ static void
+ yy_stack_print (bottom, top)
+     short *bottom;
+     short *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 */
+ | Report that the YYRULE is going to be reduced.  |
+ `------------------------------------------------*/
- #if YYDEBUG != 0
+ #if defined (__STDC__) || defined (__cplusplus)
- int yydebug;                    /*  nonzero means print parse trace     */
+ static void
- /* Since this is uninitialized, it does not stop multiple parsers
+ yy_reduce_print (int yyrule)
-    from coexisting.  */
+ #else
+ static void
+ yy_reduce_print (yyrule)
+     int yyrule;
  #endif
+ {
+   int yyi;
+   unsigned int yylineno = yyrline[yyrule];
+   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+              yyrule - 1, yylineno);
+   /* 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).
+    Do not make this value too large; the results are undefined if
+    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+    evaluated with infinite-precision integer arithmetic.  */
  #if YYMAXDEPTH == 0
- #undef YYMAXDEPTH
+ # undef YYMAXDEPTH
  #endif
  #ifndef YYMAXDEPTH
- #define YYMAXDEPTH 10000
+ # define YYMAXDEPTH 10000
  #endif
- /* Define __yy_memcpy.  Note that the size argument
-    should be passed with type unsigned int, because that is what the non-GCC
-    definitions require.  With GCC, __builtin_memcpy takes an arg
-    of type size_t, but it can handle unsigned int.  */
- #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
- #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
- #else                           /* not GNU C or C++ */
- #ifndef __cplusplus
- /* This is the most reliable way to avoid incompatibilities
+ #if YYERROR_VERBOSE
-    in available built-in functions on various systems.  */
- static void
+ # ifndef yystrlen
- __yy_memcpy (to, from, count)
+ #  if defined (__GLIBC__) && defined (_STRING_H)
-      char *to;
+ #   define yystrlen strlen
-      char *from;
+ #  else
-      unsigned int count;
+ /* Return the length of YYSTR.  */
- {
+ static YYSIZE_T
-   register char *f = from;
+ #   if defined (__STDC__) || defined (__cplusplus)
-   register char *t = to;
+ yystrlen (const char *yystr)
-   register int i = count;
+ #   else
+ yystrlen (yystr)
+      const char *yystr;
+ #   endif
+ {
+   register const char *yys = yystr;
+   while (*yys++ != '\0')
+     continue;
+   return yys - yystr - 1;
+ }
+ #  endif
+ # endif
-   while (i-- > 0)
+ # ifndef yystpcpy
-     *t++ = *f++;
+ #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+ #   define yystpcpy stpcpy
+ #  else
+ /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+    YYDEST.  */
+ static char *
+ #   if defined (__STDC__) || defined (__cplusplus)
+ yystpcpy (char *yydest, const char *yysrc)
+ #   else
+ yystpcpy (yydest, yysrc)
+      char *yydest;
+      const char *yysrc;
+ #   endif
+ {
+   register char *yyd = yydest;
+   register const char *yys = yysrc;
+   while ((*yyd++ = *yys++) != '\0')
+     continue;
+   return yyd - 1;
  }
+ #  endif
+ # endif
- #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
+ yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+ #else
  static void
- __yy_memcpy (char *to, char *from, unsigned int count)
+ yysymprint (yyoutput, yytype, yyvaluep)
+     FILE *yyoutput;
+     int yytype;
+     YYSTYPE *yyvaluep;
+ #endif
  {
-   register char *t = to;
+   /* Pacify ``unused variable'' warnings.  */
-   register char *f = from;
+   (void) yyvaluep;
-   register int i = count;
-   while (i-- > 0)
+   if (yytype < YYNTOKENS)
-     *t++ = *f++;
+     {
+       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+ # ifdef YYPRINT
+       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+ # endif
+     }
+   else
+     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+   YYFPRINTF (yyoutput, ")");
  }
+ #endif /* ! YYDEBUG */
+ /*-----------------------------------------------.
+ | Release the memory associated to this symbol.  |
+ `-----------------------------------------------*/
+ #if defined (__STDC__) || defined (__cplusplus)
+ static void
+ yydestruct (int yytype, YYSTYPE *yyvaluep)
+ #else
+ static void
+ yydestruct (yytype, yyvaluep)
+     int yytype;
+     YYSTYPE *yyvaluep;
  #endif
- #endif
+ {
+   /* Pacify ``unused variable'' warnings.  */
+   (void) yyvaluep;
+   switch (yytype)
+     {
+       default:
+         break;
+     }
+ }
- #line 217 "/usr/share/bison.simple"
- /* The user can define YYPARSE_PARAM as the name of an argument to be passed
+ /* Prevent warnings from -Wmissing-prototypes.  */
-    into yyparse.  The argument should have type void *.
-    It should actually point to an object.
-    Grammar actions can access the variable by casting it
-    to the proper pointer type.  */
  #ifdef YYPARSE_PARAM
- #ifdef __cplusplus
+ # if defined (__STDC__) || defined (__cplusplus)
- #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+ int yyparse (void *YYPARSE_PARAM);
- #define YYPARSE_PARAM_DECL
+ # else
- #else /* not __cplusplus */
+ int yyparse ();
- #define YYPARSE_PARAM_ARG YYPARSE_PARAM
+ # endif
- #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+ #else /* ! YYPARSE_PARAM */
- #endif /* not __cplusplus */
+ #if defined (__STDC__) || defined (__cplusplus)
- #else /* not YYPARSE_PARAM */
+ int yyparse (void);
- #define YYPARSE_PARAM_ARG
+ #else
- #define YYPARSE_PARAM_DECL
+ int yyparse ();
- #endif /* not YYPARSE_PARAM */
+ #endif
+ #endif /* ! YYPARSE_PARAM */
+ /*----------.
+ | yyparse.  |
+ `----------*/
- /* Prevent warning if -Wstrict-prototypes.  */
- #ifdef __GNUC__
  #ifdef YYPARSE_PARAM
- int yyparse (void *);
+ # if defined (__STDC__) || defined (__cplusplus)
+ int yyparse (void *YYPARSE_PARAM)
+ # else
+ int yyparse (YYPARSE_PARAM)
+   void *YYPARSE_PARAM;
+ # endif
+ #else /* ! YYPARSE_PARAM */
+ #if defined (__STDC__) || defined (__cplusplus)
+ int
+ yyparse (void)
  #else
- int yyparse (void);
+ int
+ yyparse ()
  #endif
  #endif
- int
- yyparse(YYPARSE_PARAM_ARG)
-      YYPARSE_PARAM_DECL
  {
+   /* The lookahead symbol.  */
+ int yychar;
+ /* The semantic value of the lookahead symbol.  */
+ YYSTYPE yylval;
+ /* Number of syntax errors so far.  */
+ int yynerrs;
    register int yystate;
    register int yyn;
+   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 yyssa[YYINITDEPTH];
+   short *yyss = yyssa;
    register short *yyssp;
-   register YYSTYPE *yyvsp;
-   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
-   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
-   short yyssa[YYINITDEPTH];     /*  the state stack                     */
+   /* The semantic value stack.  */
-   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
+   YYSTYPE yyvsa[YYINITDEPTH];
+   YYSTYPE *yyvs = yyvsa;
+   register YYSTYPE *yyvsp;
-   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
-   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
-   YYLTYPE *yyls = yylsa;
-   YYLTYPE *yylsp;
- #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
- #else
  #define YYPOPSTACK   (yyvsp--, yyssp--)
- #endif
-   int yystacksize = YYINITDEPTH;
+   YYSIZE_T yystacksize = YYINITDEPTH;
-   int yyfree_stacks = 0;
- #ifdef YYPURE
+   /* The variables used to return semantic value and location from the
-   int yychar;
+      action routines.  */
-   YYSTYPE yylval;
+   YYSTYPE yyval;
-   int yynerrs;
- #ifdef YYLSP_NEEDED
-   YYLTYPE yylloc;
- #endif
- #endif
-   YYSTYPE yyval;                /*  the variable used to return         */
-                                 /*  semantic values from the action     */
-                                 /*  routines                            */
+   /* When reducing, the number of symbols on the RHS of the reduced
+      rule.  */
    int yylen;
- #if YYDEBUG != 0
+   YYDPRINTF ((stderr, "Starting parse\n"));
-   if (yydebug)
-     fprintf(stderr, "Starting parse\n");
- #endif
    yystate = 0;
    yyerrstatus = 0;
- Line 793  yyparse(YYPARSE_PARAM_ARG)
+ Line 1209  yyparse(YYPARSE_PARAM_ARG)
       so that they stay on the same level as the state stack.
       The wasted elements are never initialized.  */
-   yyssp = yyss - 1;
+   yyssp = yyss;
    yyvsp = yyvs;
- #ifdef YYLSP_NEEDED
-   yylsp = yyls;
- #endif
- /* Push a new state, which is found in  yystate  .  */
+   goto yysetstate;
- /* In all cases, when you get here, the value and location stacks
-    have just been pushed. so pushing a state here evens the stacks.  */
- yynewstate:
-   *++yyssp = yystate;
+ /*------------------------------------------------------------.
+ | yynewstate -- Push a new state, which is found in yystate.  |
+ `------------------------------------------------------------*/
+  yynewstate:
+   /* In all cases, when you get here, the value and location stacks
+      have just been pushed. so pushing a state here evens the stacks.
+      */
+   yyssp++;
-   if (yyssp >= yyss + yystacksize - 1)
+  yysetstate:
-     {
+   *yyssp = 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. */
-       YYSTYPE *yyvs1 = yyvs;
-       short *yyss1 = yyss;
- #ifdef YYLSP_NEEDED
-       YYLTYPE *yyls1 = yyls;
- #endif
+   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 *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 *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 905  yynewstate:
+ Line 1307  yynewstate:
    /* First try to decide what to do without reference to lookahead token.  */
    yyn = yypact[yystate];
-   if (yyn == YYFLAG)
+   if (yyn == YYPACT_NINF)
      goto yydefault;
    /* Not known => get a lookahead token if don't already have one.  */
-   /* yychar is either YYEMPTY or YYEOF
+   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
-      or a valid token in external form.  */
    if (yychar == YYEMPTY)
      {
- #if YYDEBUG != 0
+       YYDPRINTF ((stderr, "Reading a token: "));
-       if (yydebug)
-         fprintf(stderr, "Reading a token: ");
- #endif
        yychar = YYLEX;
      }
-   /* Convert token to internal form (in yychar1) for indexing tables with */
+   if (yychar <= YYEOF)
-   if (yychar <= 0)              /* This means end of input. */
      {
-       yychar1 = 0;
+       yychar = yytoken = YYEOF;
-       yychar = YYEOF;           /* Don't call YYLEX any more */
+       YYDPRINTF ((stderr, "Now at end of input.\n"));
- #if YYDEBUG != 0
-       if (yydebug)
-         fprintf(stderr, "Now at end of input.\n");
- #endif
      }
    else
      {
-       yychar1 = YYTRANSLATE(yychar);
+       yytoken = YYTRANSLATE (yychar);
+       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
- #if YYDEBUG != 0
-       if (yydebug)
-         {
-           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-           /* Give the individual parser a way to print the precise meaning
-              of a token, for further debugging info.  */
- #ifdef YYPRINT
-           YYPRINT (stderr, yychar, yylval);
- #endif
-           fprintf (stderr, ")\n");
-         }
- #endif
      }
-   yyn += yychar1;
+   /* If the proper action on seeing token YYTOKEN is to reduce or to
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+      detect an error, take that action.  */
+   yyn += yytoken;
+   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
      goto yydefault;
    yyn = yytable[yyn];
+   if (yyn <= 0)
-   /* yyn is what to do for this token type in this state.
-      Negative => reduce, -yyn is rule number.
-      Positive => shift, yyn is new state.
-        New state is final state => don't bother to shift,
-        just return success.
-, or most negative number => error.  */
-   if (yyn < 0)
      {
-       if (yyn == YYFLAG)
+       if (yyn == 0 || yyn == YYTABLE_NINF)
          goto yyerrlab;
        yyn = -yyn;
        goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrlab;
    if (yyn == YYFINAL)
      YYACCEPT;
    /* Shift the lookahead token.  */
+   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
- #if YYDEBUG != 0
-   if (yydebug)
-     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
- #endif
    /* Discard the token being shifted unless it is eof.  */
    if (yychar != YYEOF)
      yychar = YYEMPTY;
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
-   /* count tokens shifted since error; after three, turn off error status.  */
-   if (yyerrstatus) yyerrstatus--;
+   /* Count tokens shifted since error; after three, turn off error
+      status.  */
+   if (yyerrstatus)
+     yyerrstatus--;
    yystate = yyn;
    goto yynewstate;
- /* Do the default action for the current state.  */
- yydefault:
+ /*-----------------------------------------------------------.
+ | yydefault -- do the default action for the current state.  |
+ `-----------------------------------------------------------*/
+ yydefault:
    yyn = yydefact[yystate];
    if (yyn == 0)
      goto yyerrlab;
+   goto yyreduce;
- /* Do a reduction.  yyn is the number of a rule to reduce with.  */
+ /*-----------------------------.
+ | yyreduce -- Do a reduction.  |
+ `-----------------------------*/
  yyreduce:
+   /* yyn is the number of a rule to reduce with.  */
    yylen = yyr2[yyn];
-   if (yylen > 0)
-     yyval = yyvsp[1-yylen]; /* implement default value of the action */
- #if YYDEBUG != 0
-   if (yydebug)
-     {
-       int i;
-       fprintf (stderr, "Reducing via rule %d (line %d), ",
+   /* If YYLEN is nonzero, implement the default value of the action:
-                yyn, yyrline[yyn]);
+      `$$ = $1'.
-       /* Print the symbols being reduced, and their result.  */
-       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-         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 116 "compile.y"
+   switch (yyn)
- {
+     {
-         Method& method=*new Method(/*main_method_name, */Method::CT_ANY,
+         case 2:
+ #line 121 "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(main_method_name, method);
+         PC.cclass->add_method(PC.alias_method(main_method_name), method);
- ;
+ ;}
-     break;}
+     break;
- case 8:
- #line 131 "compile.y"
+   case 9:
- {
+ #line 136 "compile.y"
+     {
          const String& command=*LA2S(*yyvsp[-2]);
          YYSTYPE strings_code=yyvsp[0];
-         if(strings_code->count()<1*2) {
+         if(strings_code->count()<1*OPERATIONS_PER_OPVALUE) {
                  strcpy(PC.error, "@");
                  strcat(PC.error, command.cstr());
                  strcat(PC.error, " is empty");
- Line 1059  case 8:
+ Line 1426  case 8:
                          strcat(PC.error, "'");
                          YYERROR;
                  }
-                 if(strings_code->count()==1*2) {
+                 if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                          // new class' name
                          const String& name=*LA2S(*strings_code);
                          // creating the class
- Line 1069  case 8:
+ Line 1436  case 8:
                          // append to request's classes
                          PC.request.classes().put(name, cclass);
                  } else {
-                         strcpy(PC.error, "@"CLASS_NAME" must contain sole name");
+                         strcpy(PC.error, "@"CLASS_NAME" must contain only one line with class name (contains more then one)");
                          YYERROR;
                  }
          } else if(command==USE_CONTROL_METHOD_NAME) {
-                 for(size_t i=0; i<strings_code->count(); i+=2)
+                 for(size_t i=0; i<strings_code->count(); i+=OPERATIONS_PER_OPVALUE)
                          PC.request.use_file(PC.request.main_class, *LA2S(*strings_code, i));
          } else if(command==BASE_NAME) {
                  if(PC.cclass->base_class()) { // already changed from default?
- Line 1082  case 8:
+ Line 1449  case 8:
                          strcat(PC.error, "'");
                          YYERROR;
                  }
-                 if(strings_code->count()==1*2) {
+                 if(strings_code->count()==1*OPERATIONS_PER_OPVALUE) {
                          const String& base_name=*LA2S(*strings_code);
                          if(Value* base_class_value=PC.request.classes().get(base_name)) {
                                  // @CLASS == @BASE sanity check
- Line 1113  case 8:
+ Line 1480  case 8:
                          "'"CLASS_NAME"', '"USE_CONTROL_METHOD_NAME"' and '"BASE_NAME"'");
                  YYERROR;
          }
- ;
+ ;}
-     break;}
+     break;
- case 12:
- #line 203 "compile.y"
+   case 13:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 16:
  #line 208 "compile.y"
- {
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
-         const String& name=*LA2S(*yyvsp[-5]);
+     break;
-         YYSTYPE params_names_code=yyvsp[-4];
+   case 17:
+ #line 212 "compile.y"
+     {
+         PC.explicit_result=false;
+         const String& name=*LA2S(*yyvsp[-4]);
+         YYSTYPE params_names_code=yyvsp[-3];
          ArrayString* params_names=0;
          if(int size=params_names_code->count()) {
                  params_names=new ArrayString;
-                 for(int i=0; i<size; i+=2)
+                 for(int i=0; i<size; i+=OPERATIONS_PER_OPVALUE)
                          *params_names+=LA2S(*params_names_code, i);
          }
-         YYSTYPE locals_names_code=yyvsp[-3];
+         YYSTYPE locals_names_code=yyvsp[-2];
          ArrayString* locals_names=0;
          if(int size=locals_names_code->count()) {
                  locals_names=new ArrayString;
-                 for(int i=0; i<size; i+=2)
+                 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);
+/*to be filled later in next {} */, 0);
-         PC.cclass->add_method(name, method);
+         PC.cclass->add_method(PC.alias_method(name), *method);
- ;
+         *reinterpret_cast<Method**>(&yyval)=method;
-     break;}
- case 19:
+         // todo: check [][;result;]
- #line 237 "compile.y"
+ ;}
- {yyval=yyvsp[-1];
+     break;
-     break;}
- case 23:
+   case 18:
- #line 239 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 29:
  #line 247 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+     {
-     break;}
+         // fill in the code
- case 35:
+         reinterpret_cast<Method*>(yyvsp[-1])->parser_code=yyvsp[0];
+ ;}
+     break;
+   case 21:
  #line 253 "compile.y"
- {
+     {yyval=yyvsp[-1];}
+     break;
+   case 25:
+ #line 255 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 31:
+ #line 263 "compile.y"
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 37:
+ #line 269 "compile.y"
+     {
          yyval=yyvsp[0]; /* stack: resulting value */
          changetail_or_append(*yyval,
                  OP_GET_ELEMENT, false,  /*->*/OP_GET_ELEMENT__WRITE,
                  /*or */OP_WRITE_VALUE
                  ); /* value=pop; wcontext.write(value) */
- ;
+ ;}
-     break;}
+     break;
- case 36:
- #line 260 "compile.y"
+   case 38:
- { yyval=yyvsp[0] ;
+ #line 276 "compile.y"
-     break;}
+     { yyval=yyvsp[0] ;}
- case 39:
+     break;
- #line 262 "compile.y"
- { yyval=yyvsp[-1] ;
+   case 41:
-     break;}
+ #line 278 "compile.y"
- case 42:
+     { yyval=yyvsp[-1] ;}
- #line 266 "compile.y"
+     break;
- {
+   case 44:
+ #line 282 "compile.y"
+     {
          yyval=N();
          ArrayOperation* diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
          // self.xxx... -> xxx...
-         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
+         // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
                  O(*yyval, OP_WITH_SELF); /* stack: starting context */
                  P(*yyval, *diving_code,
                          /* skip over... */
-                         diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
+                         diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
          } else {
                  O(*yyval, OP_WITH_READ); /* stack: starting context */
                  // ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
-                 // OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
+                 // OP_VALUE+origin+string+OP_GET_ELEMENT. -> OP_VALUE+origin+string+OP_GET_ELEMENT_OR_OPERATOR.
-                 if(PC.in_call_value && diving_code->count()==3)
+                 if(PC.in_call_value && diving_code->count()==4)
-                         diving_code->put(2, OP_GET_ELEMENT_OR_OPERATOR);
+                         diving_code->put(4-1, OP_GET_ELEMENT_OR_OPERATOR);
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 43:
- #line 288 "compile.y"
+   case 45:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 304 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 45:
+     break;
- #line 289 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 47:
-     break;}
+ #line 305 "compile.y"
- case 46:
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- #line 293 "compile.y"
+     break;
- {
+   case 48:
+ #line 309 "compile.y"
+     {
          yyval=yyvsp[-1]; /* stack: context,name */
          P(*yyval, *yyvsp[0]); /* stack: context,name,constructor_value */
- ;
+ ;}
-     break;}
+     break;
- case 50:
- #line 301 "compile.y"
+   case 52:
- {
+ #line 317 "compile.y"
+     {
          yyval=N();
          ArrayOperation* diving_code=yyvsp[0];
          const String* first_name=LA2S(*diving_code);
          // $self.xxx... -> $xxx...
-         // OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
+         // OP_VALUE+origin+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
          if(first_name && *first_name==SELF_ELEMENT_NAME) {
                  O(*yyval, OP_WITH_SELF); /* stack: starting context */
                  P(*yyval, *diving_code,
                          /* skip over... */
-                         diving_code->count()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
+                         diving_code->count()>=4?4/*OP_VALUE+origin+string+OP_GET_ELEMENTx*/:3/*OP_+origin+string*/);
          } else {
                  O(*yyval, OP_WITH_ROOT); /* stack: starting context */
                  P(*yyval, *diving_code);
          }
          /* diving code; stack: current context */
- ;
+ ;}
-     break;}
+     break;
- case 51:
- #line 318 "compile.y"
+   case 53:
- {
+ #line 334 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_WRITE); /* stack: starting context */
          P(*yyval, *yyvsp[0]); /* diving code; stack: context,name */
- ;
+ ;}
-     break;}
+     break;
- case 52:
- #line 323 "compile.y"
+   case 54:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 339 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 56:
+     break;
- #line 330 "compile.y"
- {
+   case 58:
+ #line 346 "compile.y"
+     {
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 59:
+ #line 349 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 60:
+ #line 351 "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 336 "compile.y"
+   case 61:
- {
+ #line 357 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_PREPARE_TO_EXPRESSION);
          // stack: context, name
          P(*yyval, *yyvsp[-1]); // stack: context, name, value
          O(*yyval, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
- ;
+ ;}
-     break;}
+     break;
- case 58:
- #line 344 "compile.y"
+   case 62:
- {
+ #line 365 "compile.y"
+     {
          // stack: context, name
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__CONSTRUCT, yyvsp[-1]); /* code=pop; name=pop; context=pop; construct(context,name,junction(code)) */
- ;
+ ;}
-     break;}
+     break;
- case 62:
- #line 355 "compile.y"
+   case 66:
- {
+ #line 376 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_OBJECT_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.value() */
- ;
+ ;}
-     break;}
+     break;
- case 65:
- #line 362 "compile.y"
+   case 69:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 383 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 66:
+     break;
- #line 366 "compile.y"
- {
+   case 70:
+ #line 387 "compile.y"
+     {
          yyval=yyvsp[0]; /* stack: value */
          changetail_or_append(*yyval,
                  OP_CALL, true,  /*->*/ OP_CALL__WRITE,
                  /*or */OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
- ;
+ ;}
-     break;}
+     break;
- case 67:
- #line 372 "compile.y"
+   case 71:
- {
+ #line 393 "compile.y"
+     {
                                          PC.in_call_value=true;
-                         ;
+                         ;}
-     break;}
+     break;
- case 68:
- #line 375 "compile.y"
+   case 72:
- {
+ #line 396 "compile.y"
+     {
                                  PC.in_call_value=false;
-                         ;
+                         ;}
-     break;}
+     break;
- case 69:
- #line 378 "compile.y"
+   case 73:
- { /* ^field.$method{vasya} */
+ #line 399 "compile.y"
+     { /* ^field.$method{vasya} */
          yyval=yyvsp[-3]; /* with_xxx,diving code; stack: context,method_junction */
          YYSTYPE params_code=yyvsp[-1];
-         if(params_code->count()==3) { // probably [] case. [OP_VALUE + Void + STORE_PARAM]
+         if(params_code->count()==4) { // probably [] case. [OP_VALUE+origin+Void+STORE_PARAM]
-                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE + value?
+                 if(Value* value=LA2V(*params_code)) // it is OP_VALUE+origin+value?
                          if(!value->is_defined()) // value is VVoid?
                                  params_code=0; // ^zzz[] case. don't append lone empty param.
          }
          /* stack: context, method_junction */
          OA(*yyval, OP_CALL, params_code); // method_frame=make frame(pop junction); ncontext=pop; call(ncontext,method_frame) stack: value
- ;
+ ;}
-     break;}
+     break;
- case 72:
- #line 393 "compile.y"
+   case 76:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 76:
- #line 399 "compile.y"
- {yyval=yyvsp[-1];
-     break;}
- case 77:
- #line 400 "compile.y"
- {yyval=yyvsp[-1];
-     break;}
- case 78:
- #line 401 "compile.y"
- {yyval=yyvsp[-1];
-     break;}
- case 80:
- #line 404 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 82:
- #line 408 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 84:
- #line 412 "compile.y"
- { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 85:
  #line 414 "compile.y"
- {
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 80:
+ #line 420 "compile.y"
+     {
+         // allow ^call[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 81:
+ #line 423 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 82:
+ #line 425 "compile.y"
+     {yyval=yyvsp[-2];}
+     break;
+   case 83:
+ #line 426 "compile.y"
+     {yyval=yyvsp[-1];}
+     break;
+   case 84:
+ #line 427 "compile.y"
+     {yyval=yyvsp[-1];}
+     break;
+   case 86:
+ #line 430 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 88:
+ #line 434 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 90:
+ #line 438 "compile.y"
+     { yyval=yyvsp[-2]; P(*yyval, *yyvsp[0]) ;}
+     break;
+   case 91:
+ #line 440 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_STORE_PARAM);
- ;
+ ;}
-     break;}
+     break;
- case 86:
- #line 418 "compile.y"
+   case 92:
- {
+ #line 444 "compile.y"
-         yyval=N();
+     {
-         OA(*yyval, OP_EXPR_CODE__STORE_PARAM, yyvsp[0]);
+         YYSTYPE expr_code=yyvsp[0];
- ;
+         if(expr_code->count()==3) { // optimizing (double) case. [OP_VALUE+origin+Double]
-     break;}
+                 yyval=expr_code;
- case 87:
+                 O(*yyval, OP_STORE_PARAM); // no evaluating
- #line 422 "compile.y"
+         } else {
- {
+                 ArrayOperation* code=N();
+                 O(*code, OP_PREPARE_TO_EXPRESSION);
+                 P(*code, *expr_code);
+                 O(*code, OP_WRITE_EXPR_RESULT);
+                 yyval=N();
+                 OA(*yyval, OP_EXPR_CODE__STORE_PARAM, code);
+         }
+ ;}
+     break;
+   case 93:
+ #line 458 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_CURLY_CODE__STORE_PARAM, yyvsp[0]);
- ;
+ ;}
-     break;}
+     break;
- case 91:
- #line 431 "compile.y"
+   case 98:
- {
+ #line 470 "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 100:
- ;
+ #line 472 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 93:
+     break;
- #line 440 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+   case 102:
-     break;}
+ #line 474 "compile.y"
- case 95:
+     {
- #line 442 "compile.y"
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
-     break;}
- case 97:
- #line 444 "compile.y"
- {
          // we know that name_advance1 not called from ^xxx context
          // so we'll not check for operator call possibility as we do in name_advance2
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 98:
- #line 452 "compile.y"
+   case 103:
- {
+ #line 482 "compile.y"
+     {
          /* stack: context */
          yyval=yyvsp[0]; /* stack: context,name */
          O(*yyval, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
- ;
+ ;}
-     break;}
+     break;
- case 104:
- #line 465 "compile.y"
+   case 109:
- {
+ #line 495 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT);
- ;
+ ;}
-     break;}
+     break;
- case 105:
- #line 469 "compile.y"
+   case 110:
- {
+ #line 499 "compile.y"
+     {
          ArrayOperation* code;
          {
                  change_string_literal_to_write_string_literal(*(code=yyvsp[-1]));
- Line 1428  case 105:
+ Line 1883  case 105:
          }
          yyval=N();
          OA(*yyval, OP_STRING_POOL, code);
- ;
+ ;}
-     break;}
+     break;
- case 106:
- #line 478 "compile.y"
+   case 111:
- {
+ #line 508 "compile.y"
+     {
+         // allow $result_or_other_variable[ letters here any time ]
+         *reinterpret_cast<bool*>(&yyval)=PC.explicit_result; PC.explicit_result=false;
+ ;}
+     break;
+   case 112:
+ #line 511 "compile.y"
+     {
+         PC.explicit_result=*reinterpret_cast<bool*>(&yyvsp[-1]);
+ ;}
+     break;
+   case 113:
+ #line 513 "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 484 "compile.y"
+   case 114:
- {
+ #line 519 "compile.y"
+     {
          yyval=N();
          O(*yyval, OP_WITH_READ);
          P(*yyval, *yyvsp[0]);
- ;
+ ;}
-     break;}
+     break;
- case 109:
- #line 489 "compile.y"
+   case 116:
- { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;
+ #line 524 "compile.y"
-     break;}
+     { yyval=yyvsp[-1]; P(*yyval, *yyvsp[0]) ;}
- case 110:
+     break;
- #line 490 "compile.y"
- {
+   case 117:
+ #line 525 "compile.y"
+     {
          yyval=yyvsp[0];
          O(*yyval, OP_GET_ELEMENT__WRITE);
- ;
+ ;}
-     break;}
+     break;
- case 113:
- #line 499 "compile.y"
+   case 120:
- {
+ #line 534 "compile.y"
+     {
          yyval=yyvsp[-1]; // stack: class name string
-         if(*LA2S(*yyval) == BASE_NAME) { // pseude BASE class
+         if(*LA2S(*yyval) == BASE_NAME) { // pseudo BASE class
                  if(VStateless_class* base=PC.cclass->base_class()) {
                          change_string_literal_value(*yyval, base->name());
                  } else {
- Line 1471  case 113:
+ Line 1946  case 113:
                  }
          }
          O(*yyval, OP_GET_CLASS);
- ;
+ ;}
-     break;}
+     break;
- case 114:
- #line 511 "compile.y"
+   case 121:
- {
+ #line 546 "compile.y"
+     {
          yyval=yyvsp[-1];
          if(!PC.in_call_value) {
                  strcpy(PC.error, ":: not allowed here");
                  YYERROR;
          }
          O(*yyval, OP_PREPARE_TO_CONSTRUCT_OBJECT);
- ;
+ ;}
-     break;}
+     break;
- case 115:
- #line 523 "compile.y"
+   case 126:
- {
-         // 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 532 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 120:
- #line 533 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 121:
- #line 534 "compile.y"
- { yyval = yyvsp[-1]; ;
-     break;}
- case 122:
- #line 536 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;
-     break;}
- case 123:
- #line 537 "compile.y"
- { yyval=yyvsp[0] ;
-     break;}
- case 124:
- #line 538 "compile.y"
- { yyval=yyvsp[0];        O(*yyval, OP_INV) ;
-     break;}
- case 125:
- #line 539 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;
-     break;}
- case 126:
- #line 540 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;
-     break;}
- case 127:
- #line 541 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_IN) ;
-     break;}
- case 128:
- #line 542 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;
-     break;}
- case 129:
- #line 543 "compile.y"
- { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;
-     break;}
- case 130:
- #line 545 "compile.y"
- {       yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;
-     break;}
- case 131:
- #line 546 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;
-     break;}
- case 132:
- #line 547 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;
-     break;}
- case 133:
- #line 548 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;
-     break;}
- case 134:
- #line 549 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;
-     break;}
- case 135:
- #line 550 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;
-     break;}
- case 136:
- #line 551 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;
-     break;}
- case 137:
- #line 552 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;
-     break;}
- case 138:
- #line 553 "compile.y"
- { yyval=yyvsp[-2];      P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;
-     break;}
- case 139:
- #line 554 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;
-     break;}
- case 140:
- #line 555 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;
-     break;}
- case 141:
- #line 556 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;
-     break;}
- case 142:
- #line 557 "compile.y"
- { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;
-     break;}
- case 143:
- #line 558 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;
-     break;}
- case 144:
- #line 559 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;
-     break;}
- case 145:
- #line 560 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;
-     break;}
- case 146:
- #line 561 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;
-     break;}
- case 147:
- #line 562 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;
-     break;}
- case 148:
  #line 563 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;
+     { yyval = yyvsp[-1]; ;}
-     break;}
+     break;
- case 149:
+   case 127:
  #line 564 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;
+     { yyval = yyvsp[-1]; ;}
-     break;}
+     break;
- case 150:
+   case 128:
  #line 565 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;
+     { yyval = yyvsp[-1]; ;}
-     break;}
+     break;
- case 151:
- #line 566 "compile.y"
+   case 129:
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;
-     break;}
- case 152:
  #line 567 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_NEG) ;}
-     break;}
+     break;
- case 153:
+   case 130:
  #line 568 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;
+     { yyval=yyvsp[0] ;}
-     break;}
+     break;
- case 154:
+   case 131:
  #line 569 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;
+     { yyval=yyvsp[0];    O(*yyval, OP_INV) ;}
-     break;}
+     break;
- case 155:
+   case 132:
  #line 570 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_NOT) ;}
-     break;}
+     break;
- case 156:
+   case 133:
  #line 571 "compile.y"
- { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;
+     { yyval=yyvsp[0];  O(*yyval, OP_DEF) ;}
-     break;}
+     break;
- case 157:
+   case 134:
+ #line 572 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_IN) ;}
+     break;
+   case 135:
+ #line 573 "compile.y"
+     { yyval=yyvsp[0];  O(*yyval, OP_FEXISTS) ;}
+     break;
+   case 136:
  #line 574 "compile.y"
- {
+     { yyval=yyvsp[0];  O(*yyval, OP_DEXISTS) ;}
+     break;
+   case 137:
+ #line 576 "compile.y"
+     {   yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_SUB) ;}
+     break;
+   case 138:
+ #line 577 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_ADD) ;}
+     break;
+   case 139:
+ #line 578 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MUL) ;}
+     break;
+   case 140:
+ #line 579 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_DIV) ;}
+     break;
+   case 141:
+ #line 580 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_MOD) ;}
+     break;
+   case 142:
+ #line 581 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_INTDIV) ;}
+     break;
+   case 143:
+ #line 582 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SL) ;}
+     break;
+   case 144:
+ #line 583 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_SR) ;}
+     break;
+   case 145:
+ #line 584 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_AND) ;}
+     break;
+   case 146:
+ #line 585 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_OR) ;}
+     break;
+   case 147:
+ #line 586 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_BIN_XOR) ;}
+     break;
+   case 148:
+ #line 587 "compile.y"
+     { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_AND) ;}
+     break;
+   case 149:
+ #line 588 "compile.y"
+     { yyval=yyvsp[-2];  OA(*yyval, OP_NESTED_CODE, yyvsp[0]);  O(*yyval, OP_LOG_OR) ;}
+     break;
+   case 150:
+ #line 589 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_LOG_XOR) ;}
+     break;
+   case 151:
+ #line 590 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LT) ;}
+     break;
+   case 152:
+ #line 591 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GT) ;}
+     break;
+   case 153:
+ #line 592 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_LE) ;}
+     break;
+   case 154:
+ #line 593 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_GE) ;}
+     break;
+   case 155:
+ #line 594 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_EQ) ;}
+     break;
+   case 156:
+ #line 595 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_NUM_NE) ;}
+     break;
+   case 157:
+ #line 596 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LT) ;}
+     break;
+   case 158:
+ #line 597 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GT) ;}
+     break;
+   case 159:
+ #line 598 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_LE) ;}
+     break;
+   case 160:
+ #line 599 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_GE) ;}
+     break;
+   case 161:
+ #line 600 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_EQ) ;}
+     break;
+   case 162:
+ #line 601 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_STR_NE) ;}
+     break;
+   case 163:
+ #line 602 "compile.y"
+     { yyval=yyvsp[-2];  P(*yyval, *yyvsp[0]);  O(*yyval, OP_IS) ;}
+     break;
+   case 164:
+ #line 605 "compile.y"
+     {
+         // optimized from OP_STRING->OP_VALUE for doubles
+         maybe_change_string_literal_to_double_literal(*(yyval=yyvsp[0]));
+ ;}
+     break;
+   case 165:
+ #line 610 "compile.y"
+     {
          yyval=N();
          OA(*yyval, OP_STRING_POOL, yyvsp[0]); /* stack: empty write context */
          /* some code that writes to that context */
          /* context=pop; stack: context.get_string() */
- ;
+ ;}
-     break;}
+     break;
- case 158:
- #line 583 "compile.y"
+   case 166:
- {
+ #line 619 "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 588 "compile.y"
+   case 167:
- { yyval=VL(new VVoid()) ;
+ #line 624 "compile.y"
-     break;}
+     { yyval=VL(new VVoid(), 0, 0, 0) ;}
- case 160:
+     break;
- #line 589 "compile.y"
- { yyval=N() ;
+   case 168:
-     break;}
+ #line 625 "compile.y"
- }
+     { yyval=N() ;}
-    /* the action file gets copied in in place of this dollarsign */
+     break;
- #line 543 "/usr/share/bison.simple"
+     }
+ /* Line 991 of yacc.c.  */
+ #line 2194 "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;
+           char *yymsg;
+           int yyx, yycount;
-           count = 0;
-           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+           yycount = 0;
-           for (x = (yyn < 0 ? -yyn : 0);
+           /* Start YYX at -YYN if negative to avoid negative indexes in
-                x < (sizeof(yytname) / sizeof(char *)); x++)
+              YYCHECK.  */
-             if (yycheck[x + yyn] == x)
+           for (yyx = yyn < 0 ? -yyn : 0;
-               size += strlen(yytname[x]) + 15, count++;
+                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
-           msg = (char *) malloc(size + 15);
+             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-           if (msg != 0)
+               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+           yysize += yystrlen ("syntax error, unexpected ") + 1;
+           yysize += 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;
+                   yycount = 0;
-                   for (x = (yyn < 0 ? -yyn : 0);
+                   for (yyx = yyn < 0 ? -yyn : 0;
-                        x < (sizeof(yytname) / sizeof(char *)); x++)
+                        yyx < (int) (sizeof (yytname) / sizeof (char *));
-                     if (yycheck[x + yyn] == x)
+                        yyx++)
+                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                        {
-                         strcat(msg, count == 0 ? ", expecting `" : " or `");
+                         const char *yyq = ! yycount ? ", expecting " : " or ";
-                         strcat(msg, yytname[x]);
+                         yyp = yystpcpy (yyp, yyq);
-                         strcat(msg, "'");
+                         yyp = yystpcpy (yyp, yytname[yyx]);
-                         count++;
+                         yycount++;
                        }
                  }
-               yyerror(msg);
+               yyerror (yymsg);
-               free(msg);
+               YYSTACK_FREE (yymsg);
              }
            else
-             yyerror ("parse error; also virtual memory exceeded");
+             yyerror ("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 */
+       /* Return failure if at end of input.  */
        if (yychar == YYEOF)
-         YYABORT;
+         {
+           /* Pop the error token.  */
- #if YYDEBUG != 0
+           YYPOPSTACK;
-       if (yydebug)
+           /* Pop the rest of the stack.  */
-         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+           while (yyss < yyssp)
- #endif
+             {
+               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+               yydestruct (yystos[*yyssp], yyvsp);
+               YYPOPSTACK;
+             }
+           YYABORT;
+         }
+       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
+       yydestruct (yytoken, &yylval);
        yychar = YYEMPTY;
-     }
-   /* Else will try to reuse lookahead token
+     }
-      after shifting the error token.  */
-   yyerrstatus = 3;              /* Each real token shifted decrements this */
+   /* Else will try to reuse lookahead token after shifting the error
+      token.  */
+   goto yyerrlab2;
-   goto yyerrhandle;
- yyerrdefault:  /* current state does not do anything special for the error token. */
+ /*----------------------------------------------------.
+ | yyerrlab1 -- error raised explicitly by an action.  |
+ `----------------------------------------------------*/
+ yyerrlab1:
- #if 0
+   /* Suppress GCC warning that yyerrlab1 is unused when no action
-   /* This is wrong; only states that explicitly want error tokens
+      invokes YYERROR.  */
-      should shift them.  */
+ #if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)
-   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+   __attribute__ ((__unused__))
-   if (yyn) goto yydefault;
  #endif
- yyerrpop:   /* pop the current state because it cannot handle the error token */
-   if (yyssp == yyss) YYABORT;
+   goto yyerrlab2;
-   yyvsp--;
-   yystate = *--yyssp;
- #ifdef YYLSP_NEEDED
-   yylsp--;
- #endif
- #if YYDEBUG != 0
-   if (yydebug)
-     {
-       short *ssp1 = yyss - 1;
-       fprintf (stderr, "Error: state stack now");
-       while (ssp1 != yyssp)
-         fprintf (stderr, " %d", *++ssp1);
-       fprintf (stderr, "\n");
-     }
- #endif
- yyerrhandle:
+ /*---------------------------------------------------------------.
+ | yyerrlab2 -- pop states until the error token can be shifted.  |
+ `---------------------------------------------------------------*/
+ yyerrlab2:
+   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
-   yyn = yypact[yystate];
+   for (;;)
-   if (yyn == YYFLAG)
+     {
-     goto yyerrdefault;
+       yyn = yypact[yystate];
+       if (yyn != YYPACT_NINF)
+         {
+           yyn += YYTERROR;
+           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+             {
+               yyn = yytable[yyn];
+               if (0 < yyn)
+                 break;
+             }
+         }
-   yyn += YYTERROR;
+       /* Pop the current state because it cannot handle the error token.  */
-   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+       if (yyssp == yyss)
-     goto yyerrdefault;
+         YYABORT;
-   yyn = yytable[yyn];
+       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-   if (yyn < 0)
+       yydestruct (yystos[yystate], yyvsp);
-     {
+       yyvsp--;
-       if (yyn == YYFLAG)
+       yystate = *--yyssp;
-         goto yyerrpop;
-       yyn = -yyn;
+       YY_STACK_PRINT (yyss, yyssp);
-       goto yyreduce;
      }
-   else if (yyn == 0)
-     goto yyerrpop;
    if (yyn == YYFINAL)
      YYACCEPT;
- #if YYDEBUG != 0
+   YYDPRINTF ((stderr, "Shifting error token, "));
-   if (yydebug)
-     fprintf(stderr, "Shifting error token, ");
- #endif
    *++yyvsp = yylval;
- #ifdef YYLSP_NEEDED
-   *++yylsp = yylloc;
- #endif
    yystate = yyn;
    goto yynewstate;
-  yyacceptlab:
-   /* YYACCEPT comes here.  */
-   if (yyfree_stacks)
-     {
-       free (yyss);
-       free (yyvs);
- #ifdef YYLSP_NEEDED
-       free (yyls);
- #endif
-     }
-   return 0;
-  yyabortlab:
+ /*-------------------------------------.
-   /* YYABORT comes here.  */
+ | yyacceptlab -- YYACCEPT comes here.  |
-   if (yyfree_stacks)
+ `-------------------------------------*/
-     {
+ yyacceptlab:
-       free (yyss);
+   yyresult = 0;
-       free (yyvs);
+   goto yyreturn;
- #ifdef YYLSP_NEEDED
-       free (yyls);
+ /*-----------------------------------.
+ | yyabortlab -- YYABORT comes here.  |
+ `-----------------------------------*/
+ yyabortlab:
+   yyresult = 1;
+   goto yyreturn;
+ #ifndef yyoverflow
+ /*----------------------------------------------.
+ | yyoverflowlab -- parser overflow comes here.  |
+ `----------------------------------------------*/
+ yyoverflowlab:
+   yyerror ("parser stack overflow");
+   yyresult = 2;
+   /* Fall through.  */
+ #endif
+ yyreturn:
+ #ifndef yyoverflow
+   if (yyss != yyssa)
+     YYSTACK_FREE (yyss);
  #endif
-     }
+   return yyresult;
-   return 1;
  }
- #line 591 "compile.y"
+ #line 627 "compile.y"
  #endif
- Line 1910  yyerrhandle:
+ Line 2420  yyerrhandle:
 :[^({]=pop
  */
- static int yylex(YYSTYPE *lvalp, void *pc) {
+ inline void ungetc(Parse_control& pc, uint last_line_end_col) {
-         #define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp]
+         pc.source--;
+         if(pc.pos.col==0) {
+                 --pc.pos.line; pc.pos.col=last_line_end_col;
+         } else
+                 --pc.pos.col;
+ }
+ static int yylex(YYSTYPE *lvalp, void *apc) {
+         register Parse_control& pc=*static_cast<Parse_control*>(apc);
+         #define lexical_brackets_nestage pc.brackets_nestages[pc.ls_sp]
          #define RC {result=c; goto break2; }
-     register int c;
+         register int c;
-     int result;
+         int result;
-         if(PC.pending_state) {
+         if(pc.pending_state) {
-                 result=PC.pending_state;
+                 result=pc.pending_state;
-                 PC.pending_state=0;
+                 pc.pending_state=0;
                  return result;
          }
-         const char *begin=PC.source;
+         const char *begin=pc.source;
+         Pos begin_pos=pc.pos;
          const char *end;
-         int begin_line=PC.line;
          int skip_analized=0;
          while(true) {
-                 c=*(end=(PC.source++));
+                 c=*(end=(pc.source++));
- //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, PC.sp);
+ //              fprintf(stderr, "\nchar: %c %02X; nestage: %d, sp=%d", c, c, lexical_brackets_nestage, pc.sp);
-                 if(c=='\n') {
+                 if(c=='\n')
-                         PC.line++;
+                         pc.pos_next_line();
-                         PC.col=0;
+                 else
-                 } else
+                         pc.pos_next_c(c);
-                         PC.col++;
+ //              fprintf(stderr, "\nchar: %c file(%d:%d)", c, pc.pos.line, pc.pos.col);
-                 if(c=='@' && PC.col==0+1) {
+                 if(pc.pos.col==0+1 && c=='@') {
-                         if(PC.ls==LS_DEF_SPECIAL_BODY) {
+                         if(pc.ls==LS_DEF_SPECIAL_BODY) {
                                  // @SPECIAL
                                  // ...
                                  // @<here =
-                                 pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state
+                                 pop_LS(pc); // exiting from LS_DEF_SPECIAL_BODY state
                          } // continuing checks
-                         if(PC.ls==LS_USER) {
+                         if(pc.ls==LS_USER) {
-                                 push_LS(PC, LS_DEF_NAME);
+                                 push_LS(pc, LS_DEF_NAME);
                                  RC;
                          } else // @ in first column inside some code [when could that be?]
                                  result=BAD_METHOD_DECL_START;
                          goto break2;
-                 } else if(c=='^') {
+                 }
-                         if(PC.ls==LS_METHOD_AFTER) {
+                 if(c=='^') {
+                         if(pc.ls==LS_METHOD_AFTER) {
                                  // handle after-method situation
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  result=EON;
                                  skip_analized=-1; // return to punctuation afterwards to assure it's literality
                                  goto break2;
                          }
-                         switch(PC.ls) {
+                         switch(pc.ls) {
  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
  case LS_VAR_NAME_SIMPLE_WITH_COLON:
- Line 1970  case LS_DEF_COMMENT:
+ Line 2491  case LS_DEF_COMMENT:
          // no literals in names, please
          break;
  default:
-                         switch(*PC.source) {
+                         switch(*pc.source) {
                          // ^escaping some punctuators
                          case '^': case '$': case ';':
                          case '(': case ')':
- Line 1978  default:
+ Line 2499  default:
                          case '{': case '}':
                          case '"':  case ':':
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till ^
-                                         PC.string.append_strdup(begin, end-begin);
+                                         pc.string.append_strdup_know_length(begin, end-begin);
                                  }
                                  // reset piece 'begin' position & line
-                                 begin=PC.source; // ->punctuation
+                                 begin=pc.source; // ->punctuation
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
                                  // skip over _ after ^
-                                 PC.source++;  PC.col++;
+                                 pc.source++;  pc.pos.col++;
                                  // skip analysis = forced literal
                                  continue;
                          // converting ^#HH into char(hex(HH))
                          case '#':
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till ^
-                                         PC.string.append_strdup(begin, end-begin);
+                                         pc.string.append_strdup_know_length(begin, end-begin);
                                  }
                                  // #HH ?
-                                 if(PC.source[0]=='#' && PC.source[1] && PC.source[2]) {
+                                 if(pc.source[0]=='#' && pc.source[1] && pc.source[2]) {
                                          char c=
-                                                 hex_value[(unsigned char)PC.source[1]]*0x10+
+                                                 hex_value[(unsigned char)pc.source[1]]*0x10+
-                                                 hex_value[(unsigned char)PC.source[2]];
+                                                 hex_value[(unsigned char)pc.source[2]];
                                          if(c==0) {
                                                  result=BAD_HEX_LITERAL;
                                                  goto break2; // wrong hex value[no ^#00 chars allowed]: bail out
                                          }
                                          // append char(hex(HH))
-                                         PC.string.append(c);
+                                         pc.string.append(c);
                                          // skip over ^#HH
-                                         PC.source+=3;
+                                         pc.source+=3;
-                                         PC.col+=3;
+                                         pc.pos.col+=3;
                                          // reset piece 'begin' position & line
-                                         begin=PC.source; // ->after ^#HH
+                                         begin=pc.source; // ->after ^#HH
-                                         begin_line=PC.line;
+                                         begin_pos=pc.pos;
                                          // skip analysis = forced literal
                                          continue;
                                  }
- Line 2021  default:
+ Line 2546  default:
                          }
                  }
                  // #comment  start skipping
-                 if(c=='#' && PC.col==1) {
+                 if(c=='#' && pc.pos.col==1) {
                          if(end!=begin) {
+                                 if(!pc.string_start)
+                                         pc.string_start=begin_pos;
                                  // append piece till #
-                                 PC.string.append_strdup(begin, end-begin);
+                                 pc.string.append_strdup_know_length(begin, end-begin);
                          }
                          // fall into COMMENT lexical state [wait for \n]
-                         push_LS(PC, LS_USER_COMMENT);
+                         push_LS(pc, LS_USER_COMMENT);
                          continue;
                  }
-                 switch(PC.ls) {
+                 switch(pc.ls) {
                  // USER'S = NOT OURS
                  case LS_USER:
-         case LS_NAME_SQUARE_PART: // name.[here].xxx
+                 case LS_NAME_SQUARE_PART: // name.[here].xxx
-                         if(PC.trim_bof)
+                         if(pc.trim_bof)
                                  switch(c) {
                                  case '\n': case ' ': case '\t':
-                                         begin=PC.source;
+                                         begin=pc.source;
-                                         begin_line=PC.line;
+                                         begin_pos=pc.pos;
                                          continue; // skip it
                                  default:
-                                         PC.trim_bof=false;
+                                         pc.trim_bof=false;
                                  }
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ']':
-                                 if(PC.ls==LS_NAME_SQUARE_PART)
+                                 if(pc.ls==LS_NAME_SQUARE_PART)
                                          if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
-                                                 pop_LS(PC); // $name.[co<]>de<]!>
+                                                 pop_LS(pc); // $name.[co<]>de<]!>
                                                  RC;
                                          }
                                  break;
                          case '[': // $name.[co<[>de]
-                                 if(PC.ls==LS_NAME_SQUARE_PART)
+                                 if(pc.ls==LS_NAME_SQUARE_PART)
                                          lexical_brackets_nestage++;
                                  break;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  // #COMMENT
                  case LS_USER_COMMENT:
                          if(c=='\n') {
                                  // skip comment
-                                 begin=PC.source;
+                                 begin=pc.source;
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  continue;
                          }
                          break;
- Line 2084  default:
+ Line 2621  default:
                          case '"':
                          case '\'':
                                  if(
-                                         PC.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' ||
+                                         pc.ls == LS_EXPRESSION_STRING_QUOTED && c=='"' ||
-                                         PC.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {
+                                         pc.ls == LS_EXPRESSION_STRING_APOSTROFED && c=='\'') {
-                                         pop_LS(PC); //"abc". | 'abc'.
+                                         pop_LS(pc); //"abc". | 'abc'.
                                          RC;
                                  }
                                  break;
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          }
                          break;
- Line 2103  default:
+ Line 2640  default:
                  case LS_DEF_NAME:
                          switch(c) {
                          case '[':
-                                 PC.ls=LS_DEF_PARAMS;
+                                 pc.ls=LS_DEF_PARAMS;
                                  RC;
                          case '\n':
-                                 PC.ls=LS_DEF_SPECIAL_BODY;
+                                 pc.ls=LS_DEF_SPECIAL_BODY;
                                  RC;
                          }
                          break;
- Line 2119  default:
+ Line 2656  default:
                          case ';':
                                  RC;
                          case ']':
-                                 PC.ls=*PC.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
+                                 pc.ls=*pc.source=='['?LS_DEF_LOCALS:LS_DEF_COMMENT;
                                  RC;
                          case '\n': // wrong. bailing out
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
- Line 2133  default:
+ Line 2670  default:
                          case ';':
                                  RC;
                          case ']':
-                                 PC.ls=LS_DEF_COMMENT;
+                                 pc.ls=LS_DEF_COMMENT;
                                  RC;
                          case '\n': // wrong. bailing out
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
                  case LS_DEF_COMMENT:
                          if(c=='\n') {
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          }
                          break;
- Line 2159  default:
+ Line 2696  default:
                          switch(c) {
                          case ')':
                                  if(--lexical_brackets_nestage==0)
-                                         if(PC.ls==LS_METHOD_ROUND) // method round param ended
+                                         if(pc.ls==LS_METHOD_ROUND) // method round param ended
-                                                 PC.ls=LS_METHOD_AFTER; // look for method end
+                                                 pc.ls=LS_METHOD_AFTER; // look for method end
-                                         else // PC.ls==LS_VAR_ROUND // variable constructor ended
+                                         else // pc.ls==LS_VAR_ROUND // variable constructor ended
-                                                 pop_LS(PC); // return to normal life
+                                                 pop_LS(pc); // return to normal life
                                  RC;
                          case '#': // comment start skipping
                                  if(end!=begin) {
+                                         if(!pc.string_start)
+                                                 pc.string_start=begin_pos;
                                          // append piece till #
-                                         PC.string.append_strdup(begin, end-begin);
+                                         pc.string.append_strdup_know_length(begin, end-begin);
                                  }
                                  // fall into COMMENT lexical state [wait for \n]
-                                 push_LS(PC, LS_EXPRESSION_COMMENT);
+                                 push_LS(pc, LS_EXPRESSION_COMMENT);
                                  lexical_brackets_nestage=1;
                                  continue;
                          case '$':
-                                 push_LS(PC, LS_EXPRESSION_VAR_NAME_WITH_COLON);
+                                 push_LS(pc, LS_EXPRESSION_VAR_NAME_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case '(':
                                  lexical_brackets_nestage++;
                                  RC;
                          case '-':
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case 'f': // -f
                                          skip_analized=1;
                                          result=FEXISTS;
- Line 2202  default:
+ Line 2741  default:
                          case ';':
                                  RC;
                          case '&': case '|':
-                                 if(*PC.source==c) { // && ||
+                                 if(*pc.source==c) { // && ||
                                          result=c=='&'?LAND:LOR;
                                          skip_analized=1;
                                  } else
                                          result=c;
                                  goto break2;
                          case '!':
-                                 switch(PC.source[0]) {
+                                 switch(pc.source[0]) {
                                  case '|': // !| !||
                                          skip_analized=1;
-                                         if(PC.source[1]=='|') {
+                                         if(pc.source[1]=='|') {
                                                  skip_analized++;
                                                  result=LXOR;
                                          } else
- Line 2226  default:
+ Line 2765  default:
                                  RC;
                          case '<': // <<, <=, <
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '<': // <[<]
                                          skip_analized=1; result=NSL; break;
                                  case '=': // <[=]
- Line 2236  default:
+ Line 2775  default:
                                  }
                                  goto break2;
                          case '>': // >>, >=, >
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '>': // >[>]
                                          skip_analized=1; result=NSR; break;
                                  case '=': // >[=]
- Line 2246  default:
+ Line 2785  default:
                                  }
                                  goto break2;
                          case '=': // ==
-                                 switch(*PC.source) {
+                                 switch(*pc.source) {
                                  case '=': // =[=]
                                          skip_analized=1; result=NEQ; break;
                                  default: // =[]
- Line 2255  default:
+ Line 2794  default:
                                  goto break2;
                          case '"':
-                                 push_LS(PC, LS_EXPRESSION_STRING_QUOTED);
+                                 push_LS(pc, LS_EXPRESSION_STRING_QUOTED);
                                  RC;
                          case '\'':
-                                 push_LS(PC, LS_EXPRESSION_STRING_APOSTROFED);
+                                 push_LS(pc, LS_EXPRESSION_STRING_APOSTROFED);
                                  RC;
                          case 'l': case 'g': case 'e': case 'n':
                                  if(end==begin) // right after whitespace
-                                         if(isspace(PC.source[1])) {
+                                         if(isspace(pc.source[1])) {
-                                                 switch(*PC.source) {
+                                                 switch(*pc.source) {
                                                          //                                      case '?': // ok [and bad cases, yacc would bark at them]
                                                  case 't': // lt gt [et nt]
                                                          result=c=='l'?SLT:c=='g'?SGT:BAD_STRING_COMPARISON_OPERATOR;
- Line 2282  default:
+ Line 2821  default:
                                  break;
                          case 'i':
                                  if(end==begin) // right after whitespace
-                                         if(isspace(PC.source[1])) {
+                                         if(isspace(pc.source[1])) {
-                                                 switch(PC.source[0]) {
+                                                 switch(pc.source[0]) {
                                                  case 'n': // in
                                                          skip_analized=1;
                                                          result=IN;
- Line 2297  default:
+ Line 2836  default:
                                  break;
                          case 'd':
                                  if(end==begin) // right after whitespace
-                                         if(PC.source[0]=='e' && PC.source[1]=='f') { // def
+                                         if(pc.source[0]=='e' && pc.source[1]=='f') { // def
                                                  skip_analized=2;
                                                  result=DEF;
                                                  goto break2;
- Line 2311  default:
+ Line 2850  default:
                                  // that's a leading|traling space or after-operator-space
                                  // ignoring it
                                  // reset piece 'begin' position & line
-                                 begin=PC.source; // after whitespace char
+                                 begin=pc.source; // after whitespace char
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
                                  continue;
                          }
                          break;
- Line 2320  default:
+ Line 2859  default:
                          if(c=='(')
                                  lexical_brackets_nestage++;
-                         switch(*PC.source) {
+                         switch(*pc.source) {
                          case '\n': case ')':
-                                 if(*PC.source==')')
+                                 if(*pc.source==')')
                                          if(--lexical_brackets_nestage!=0)
                                                  continue;
                                  // skip comment
-                                 begin=PC.source;
+                                 begin=pc.source;
-                                 begin_line=PC.line;
+                                 begin_pos=pc.pos;
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  continue;
                          }
                          break;
- Line 2341  default:
+ Line 2880  default:
                  case LS_EXPRESSION_VAR_NAME_WITH_COLON:
                  case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
                          if(
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                  // name in expr ends also before
                                  switch(c) {
                                  // expression minus
                                  case '-':
                                  // expression integer division
                                  case '\\':
-                                         pop_LS(PC);
+                                         pop_LS(pc);
-                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                         pc.ungetc();
                                          result=EON;
                                          goto break2;
                                  }
                          }
                          if(
-                                 PC.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||
+                                 pc.ls==LS_VAR_NAME_SIMPLE_WITHOUT_COLON ||
-                                 PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
+                                 pc.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
                                  // name already has ':', stop before next
                                  switch(c) {
                                  case ':':
-                                         pop_LS(PC);
+                                         pop_LS(pc);
-                                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                         pc.ungetc();
                                          result=EON;
                                          goto break2;
                                  }
- Line 2381  default:
+ Line 2920  default:
                          case ',': case '?': case '#':
                          // before call
                          case '^':
-                                 pop_LS(PC);
+                                 pop_LS(pc);
-                                 PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                                 pc.ungetc();
                                  result=EON;
                                  goto break2;
                          case '[':
                                  // $name.<[>code]
-                                 if(PC.col>1/*not first column*/ && (
+                                 if(pc.pos.col>1/*not first column*/ && (
                                          end[-1]=='$'/*was start of get*/ ||
                                          end[-1]==':'/*was class name delim */ ||
                                          end[-1]=='.'/*was name delim */
                                          )) {
-                                         push_LS(PC, LS_NAME_SQUARE_PART);
+                                         push_LS(pc, LS_NAME_SQUARE_PART);
                                          lexical_brackets_nestage=1;
                                          RC;
                                  }
-                                 PC.ls=LS_VAR_SQUARE;
+                                 pc.ls=LS_VAR_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '{':
                                  if(begin==end) { // ${name}, no need of EON, switching LS
-                                         PC.ls=LS_VAR_NAME_CURLY;
+                                         pc.ls=LS_VAR_NAME_CURLY;
                                  } else {
-                                         PC.ls=LS_VAR_CURLY;
+                                         pc.ls=LS_VAR_CURLY;
                                          lexical_brackets_nestage=1;
                                  }
                                  RC;
                          case '(':
-                                 PC.ls=LS_VAR_ROUND;
+                                 pc.ls=LS_VAR_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '.': // name part delim
                          case '$': // name part subvar
                          case ':': // class<:>name
                                  // go to _WITHOUT_COLON state variant...
-                                 if(PC.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
+                                 if(pc.ls==LS_VAR_NAME_SIMPLE_WITH_COLON)
-                                         PC.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
+                                         pc.ls=LS_VAR_NAME_SIMPLE_WITHOUT_COLON;
-                                 else if(PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
+                                 else if(pc.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON)
-                                         PC.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
+                                         pc.ls=LS_EXPRESSION_VAR_NAME_WITHOUT_COLON;
                                  // ...stop before next ':'
                                  RC;
                          }
- Line 2429  default:
+ Line 2968  default:
                          switch(c) {
                          case '[':
                                  // ${name.<[>code]}
-                                 push_LS(PC, LS_NAME_SQUARE_PART);
+                                 push_LS(pc, LS_NAME_SQUARE_PART);
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '}': // ${name} finished, restoring LS
-                                 pop_LS(PC);
+                                 pop_LS(pc);
                                  RC;
                          case '.': // name part delim
                          case '$': // name part subvar
- Line 2445  default:
+ Line 2984  default:
                  case LS_VAR_SQUARE:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ']':
                                  if(--lexical_brackets_nestage==0) {
-                                         pop_LS(PC);
+                                         pop_LS(pc);
                                          RC;
                                  }
                                  break;
- Line 2467  default:
+ Line 3006  default:
                  case LS_VAR_CURLY:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case '}':
                                  if(--lexical_brackets_nestage==0) {
-                                         pop_LS(PC);
+                                         pop_LS(pc);
                                          RC;
                                  }
                                  break;
- Line 2489  default:
+ Line 3028  default:
                          switch(c) {
                          case '[':
                                  // ^name.<[>code].xxx
-                                 if(PC.col>1/*not first column*/ && (
+                                 if(pc.pos.col>1/*not first column*/ && (
                                          end[-1]=='^'/*was start of call*/ || // never, ^[ is literal...
                                          end[-1]==':'/*was class name delim */ ||
                                          end[-1]=='.'/*was name delim */
                                          )) {
-                                         push_LS(PC, LS_NAME_SQUARE_PART);
+                                         push_LS(pc, LS_NAME_SQUARE_PART);
                                          lexical_brackets_nestage=1;
                                          RC;
                                  }
-                                 PC.ls=LS_METHOD_SQUARE;
+                                 pc.ls=LS_METHOD_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '{':
-                                 PC.ls=LS_METHOD_CURLY;
+                                 pc.ls=LS_METHOD_CURLY;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '(':
-                                 PC.ls=LS_METHOD_ROUND;
+                                 pc.ls=LS_METHOD_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          case '.': // name part delim
- Line 2514  default:
+ Line 3053  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 2521  default:
+ Line 3061  default:
                  case LS_METHOD_SQUARE:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ';': // param delim
                                  RC;
                          case ']':
                                  if(--lexical_brackets_nestage==0) {
-                                         PC.ls=LS_METHOD_AFTER;
+                                         pc.ls=LS_METHOD_AFTER;
                                          RC;
                                  }
                                  break;
- Line 2543  default:
+ Line 3083  default:
                  case LS_METHOD_CURLY:
                          switch(c) {
                          case '$':
-                                 push_LS(PC, LS_VAR_NAME_SIMPLE_WITH_COLON);
+                                 push_LS(pc, LS_VAR_NAME_SIMPLE_WITH_COLON);
                                  RC;
                          case '^':
-                                 push_LS(PC, LS_METHOD_NAME);
+                                 push_LS(pc, LS_METHOD_NAME);
                                  RC;
                          case ';': // param delim
                                  RC;
                          case '}':
                                  if(--lexical_brackets_nestage==0) {
-                                         PC.ls=LS_METHOD_AFTER;
+                                         pc.ls=LS_METHOD_AFTER;
                                          RC;
                                  }
                                  break;
- Line 2560  default:
+ Line 3100  default:
                                  lexical_brackets_nestage++;
                                  break;
                          }
+                         if(pc.explicit_result && c)
+                                 switch(c) {
+                                 case '\n': case ' ': case '\t':
+                                         begin=pc.source;
+                                         begin_pos=pc.pos;
+                                         continue; // skip it
+                                 default:
+                                         result=BAD_NONWHITESPACE_CHARACTER_IN_EXPLICIT_RESULT_MODE;
+                                         goto break2;
+                                 }
                          break;
                  case LS_METHOD_AFTER:
                          if(c=='[') {/* ][ }[ )[ */
-                                 PC.ls=LS_METHOD_SQUARE;
+                                 pc.ls=LS_METHOD_SQUARE;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='{') {/* ]{ }{ ){ */
-                                 PC.ls=LS_METHOD_CURLY;
+                                 pc.ls=LS_METHOD_CURLY;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
                          if(c=='(') {/* ]( }( )( */
-                                 PC.ls=LS_METHOD_ROUND;
+                                 pc.ls=LS_METHOD_ROUND;
                                  lexical_brackets_nestage=1;
                                  RC;
                          }
-                         pop_LS(PC);
+                         pop_LS(pc);
-                         PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
+                         pc.ungetc();
                          result=EON;
                          goto break2;
                  }
- Line 2597  break2:
+ Line 3147  break2:
                          if(end!=begin && end[-1]=='\n') // allow one empty line before LS_DEF_NAME
                                  end--;
                  }
-                 if(end!=begin && PC.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
+                 if(end!=begin && pc.ls!=LS_USER_COMMENT) { // last piece still alive and not comment?
+                         if(!pc.string_start)
+                                 pc.string_start=begin_pos;
                          // append it
-                         PC.string.append_strdup(begin, end-begin);
+                         pc.string.append_strdup_know_length(begin, end-begin);
                  }
          }
-         if(!PC.string.is_empty()) { // something accumulated?
+         if(!pc.string.is_empty()) { // something accumulated?
-                 // create STRING value: array of OP_VALUE+vstring
+                 // create STRING value: array of OP_VALUE+origin+vstring
-                 *lvalp=VL(new VString(*new String(PC.string, String::L_CLEAN)));
+                 *lvalp=VL(
+                         new VString(*new String(pc.string, String::L_CLEAN)),
+                         pc.file_no, pc.string_start.line, pc.string_start.col);
                  // new pieces storage
-                 PC.string.clear();
+                 pc.string.clear();
+                 pc.string_start.clear();
                  // make current result be pending for next call, return STRING for now
-                 PC.pending_state=result;  result=STRING;
+                 pc.pending_state=result;  result=STRING;
          }
          if(skip_analized) {
-                 PC.source+=skip_analized;  PC.col+=skip_analized;
+                 pc.source+=skip_analized;  pc.pos.col+=skip_analized;
          }
          return result;
  }
- static int real_yyerror(parse_control *pc, char *s) {  // Called by yyparse on error
+ static int real_yyerror(Parse_control *pc, char *s) {  // Called by yyparse on error
             strncpy(PC.error, s, MAX_STRING);
             return 1;
  }
- Line 2625  static void yyprint(FILE *file, int type
+ Line 3180  static void yyprint(FILE *file, int type
          if(type==STRING)
                  fprintf(file, " \"%s\"", LA2S(*value)->cstr());
  }

E-mail:

Removed from v.1.81.2.13.2.19
changed lines
	Added in v.1.105