"Fossies" - the Fresh Open Source Software Archive

Member "bc-1.06.95/bc/bc.c" (5 Sep 2006, 78198 Bytes) of package /linux/misc/old/bc-1.06.95.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "bc.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.06.95_vs_1.07.

    1 /* A Bison parser, made by GNU Bison 2.1.  */
    2 
    3 /* Skeleton parser for Yacc-like parsing with Bison,
    4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    5 
    6    This program is free software; you can redistribute it and/or modify
    7    it under the terms of the GNU General Public License as published by
    8    the Free Software Foundation; either version 2, or (at your option)
    9    any later version.
   10 
   11    This program is distributed in the hope that it will be useful,
   12    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14    GNU General Public License for more details.
   15 
   16    You should have received a copy of the GNU General Public License
   17    along with this program; if not, write to the Free Software
   18    Foundation, Inc., 51 Franklin Street, Fifth Floor,
   19    Boston, MA 02110-1301, USA.  */
   20 
   21 /* As a special exception, when this file is copied by Bison into a
   22    Bison output file, you may use that output file without restriction.
   23    This special exception was added by the Free Software Foundation
   24    in version 1.24 of Bison.  */
   25 
   26 /* Written by Richard Stallman by simplifying the original so called
   27    ``semantic'' parser.  */
   28 
   29 /* All symbols defined below should begin with yy or YY, to avoid
   30    infringing on user name space.  This should be done even for local
   31    variables, as they might otherwise be expanded by user macros.
   32    There are some unavoidable exceptions within include files to
   33    define necessary library symbols; they are noted "INFRINGES ON
   34    USER NAME SPACE" below.  */
   35 
   36 /* Identify Bison output.  */
   37 #define YYBISON 1
   38 
   39 /* Bison version.  */
   40 #define YYBISON_VERSION "2.1"
   41 
   42 /* Skeleton name.  */
   43 #define YYSKELETON_NAME "yacc.c"
   44 
   45 /* Pure parsers.  */
   46 #define YYPURE 0
   47 
   48 /* Using locations.  */
   49 #define YYLSP_NEEDED 0
   50 
   51 
   52 
   53 /* Tokens.  */
   54 #ifndef YYTOKENTYPE
   55 # define YYTOKENTYPE
   56    /* Put the tokens into the symbol table, so that GDB and other debuggers
   57       know about them.  */
   58    enum yytokentype {
   59      ENDOFLINE = 258,
   60      AND = 259,
   61      OR = 260,
   62      NOT = 261,
   63      STRING = 262,
   64      NAME = 263,
   65      NUMBER = 264,
   66      ASSIGN_OP = 265,
   67      REL_OP = 266,
   68      INCR_DECR = 267,
   69      Define = 268,
   70      Break = 269,
   71      Quit = 270,
   72      Length = 271,
   73      Return = 272,
   74      For = 273,
   75      If = 274,
   76      While = 275,
   77      Sqrt = 276,
   78      Else = 277,
   79      Scale = 278,
   80      Ibase = 279,
   81      Obase = 280,
   82      Auto = 281,
   83      Read = 282,
   84      Random = 283,
   85      Warranty = 284,
   86      Halt = 285,
   87      Last = 286,
   88      Continue = 287,
   89      Print = 288,
   90      Limits = 289,
   91      UNARY_MINUS = 290,
   92      HistoryVar = 291,
   93      Void = 292
   94    };
   95 #endif
   96 /* Tokens.  */
   97 #define ENDOFLINE 258
   98 #define AND 259
   99 #define OR 260
  100 #define NOT 261
  101 #define STRING 262
  102 #define NAME 263
  103 #define NUMBER 264
  104 #define ASSIGN_OP 265
  105 #define REL_OP 266
  106 #define INCR_DECR 267
  107 #define Define 268
  108 #define Break 269
  109 #define Quit 270
  110 #define Length 271
  111 #define Return 272
  112 #define For 273
  113 #define If 274
  114 #define While 275
  115 #define Sqrt 276
  116 #define Else 277
  117 #define Scale 278
  118 #define Ibase 279
  119 #define Obase 280
  120 #define Auto 281
  121 #define Read 282
  122 #define Random 283
  123 #define Warranty 284
  124 #define Halt 285
  125 #define Last 286
  126 #define Continue 287
  127 #define Print 288
  128 #define Limits 289
  129 #define UNARY_MINUS 290
  130 #define HistoryVar 291
  131 #define Void 292
  132 
  133 
  134 
  135 
  136 /* Copy the first part of user declarations.  */
  137 #line 33 "bc.y"
  138 
  139 
  140 #include "bcdefs.h"
  141 #include "global.h"
  142 #include "proto.h"
  143 
  144 /* current function number. */
  145 int cur_func = -1;
  146 
  147 /* Expression encoded information -- See comment at expression rules. */
  148 #define EX_ASSGN 0 
  149 #define EX_REG   1
  150 #define EX_COMP  2
  151 #define EX_PAREN 4
  152 #define EX_VOID  8 
  153 #define EX_EMPTY 16
  154 
  155 
  156 
  157 /* Enabling traces.  */
  158 #ifndef YYDEBUG
  159 # define YYDEBUG 0
  160 #endif
  161 
  162 /* Enabling verbose error messages.  */
  163 #ifdef YYERROR_VERBOSE
  164 # undef YYERROR_VERBOSE
  165 # define YYERROR_VERBOSE 1
  166 #else
  167 # define YYERROR_VERBOSE 0
  168 #endif
  169 
  170 /* Enabling the token table.  */
  171 #ifndef YYTOKEN_TABLE
  172 # define YYTOKEN_TABLE 0
  173 #endif
  174 
  175 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
  176 #line 54 "bc.y"
  177 typedef union YYSTYPE {
  178     char     *s_value;
  179     char      c_value;
  180     int   i_value;
  181     arg_list *a_value;
  182        } YYSTYPE;
  183 /* Line 196 of yacc.c.  */
  184 #line 185 "bc.c"
  185 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
  186 # define YYSTYPE_IS_DECLARED 1
  187 # define YYSTYPE_IS_TRIVIAL 1
  188 #endif
  189 
  190 
  191 
  192 /* Copy the second part of user declarations.  */
  193 
  194 
  195 /* Line 219 of yacc.c.  */
  196 #line 197 "bc.c"
  197 
  198 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
  199 # define YYSIZE_T __SIZE_TYPE__
  200 #endif
  201 #if ! defined (YYSIZE_T) && defined (size_t)
  202 # define YYSIZE_T size_t
  203 #endif
  204 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
  205 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
  206 # define YYSIZE_T size_t
  207 #endif
  208 #if ! defined (YYSIZE_T)
  209 # define YYSIZE_T unsigned int
  210 #endif
  211 
  212 #ifndef YY_
  213 # if YYENABLE_NLS
  214 #  if ENABLE_NLS
  215 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
  216 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
  217 #  endif
  218 # endif
  219 # ifndef YY_
  220 #  define YY_(msgid) msgid
  221 # endif
  222 #endif
  223 
  224 #if ! defined (yyoverflow) || YYERROR_VERBOSE
  225 
  226 /* The parser invokes alloca or malloc; define the necessary symbols.  */
  227 
  228 # ifdef YYSTACK_USE_ALLOCA
  229 #  if YYSTACK_USE_ALLOCA
  230 #   ifdef __GNUC__
  231 #    define YYSTACK_ALLOC __builtin_alloca
  232 #   else
  233 #    define YYSTACK_ALLOC alloca
  234 #    if defined (__STDC__) || defined (__cplusplus)
  235 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  236 #     define YYINCLUDED_STDLIB_H
  237 #    endif
  238 #   endif
  239 #  endif
  240 # endif
  241 
  242 # ifdef YYSTACK_ALLOC
  243    /* Pacify GCC's `empty if-body' warning. */
  244 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  245 #  ifndef YYSTACK_ALLOC_MAXIMUM
  246     /* The OS might guarantee only one guard page at the bottom of the stack,
  247        and a page size can be as small as 4096 bytes.  So we cannot safely
  248        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
  249        to allow for a few compiler-allocated temporary stack slots.  */
  250 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
  251 #  endif
  252 # else
  253 #  define YYSTACK_ALLOC YYMALLOC
  254 #  define YYSTACK_FREE YYFREE
  255 #  ifndef YYSTACK_ALLOC_MAXIMUM
  256 #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
  257 #  endif
  258 #  ifdef __cplusplus
  259 extern "C" {
  260 #  endif
  261 #  ifndef YYMALLOC
  262 #   define YYMALLOC malloc
  263 #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
  264     && (defined (__STDC__) || defined (__cplusplus)))
  265 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
  266 #   endif
  267 #  endif
  268 #  ifndef YYFREE
  269 #   define YYFREE free
  270 #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
  271     && (defined (__STDC__) || defined (__cplusplus)))
  272 void free (void *); /* INFRINGES ON USER NAME SPACE */
  273 #   endif
  274 #  endif
  275 #  ifdef __cplusplus
  276 }
  277 #  endif
  278 # endif
  279 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
  280 
  281 
  282 #if (! defined (yyoverflow) \
  283      && (! defined (__cplusplus) \
  284      || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
  285 
  286 /* A type that is properly aligned for any stack member.  */
  287 union yyalloc
  288 {
  289   short int yyss;
  290   YYSTYPE yyvs;
  291   };
  292 
  293 /* The size of the maximum gap between one aligned stack and the next.  */
  294 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
  295 
  296 /* The size of an array large to enough to hold all stacks, each with
  297    N elements.  */
  298 # define YYSTACK_BYTES(N) \
  299      ((N) * (sizeof (short int) + sizeof (YYSTYPE))         \
  300       + YYSTACK_GAP_MAXIMUM)
  301 
  302 /* Copy COUNT objects from FROM to TO.  The source and destination do
  303    not overlap.  */
  304 # ifndef YYCOPY
  305 #  if defined (__GNUC__) && 1 < __GNUC__
  306 #   define YYCOPY(To, From, Count) \
  307       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
  308 #  else
  309 #   define YYCOPY(To, From, Count)      \
  310       do                    \
  311     {                   \
  312       YYSIZE_T yyi;             \
  313       for (yyi = 0; yyi < (Count); yyi++)   \
  314         (To)[yyi] = (From)[yyi];        \
  315     }                   \
  316       while (0)
  317 #  endif
  318 # endif
  319 
  320 /* Relocate STACK from its old location to the new one.  The
  321    local variables YYSIZE and YYSTACKSIZE give the old and new number of
  322    elements in the stack, and YYPTR gives the new location of the
  323    stack.  Advance YYPTR to a properly aligned location for the next
  324    stack.  */
  325 # define YYSTACK_RELOCATE(Stack)                    \
  326     do                                  \
  327       {                                 \
  328     YYSIZE_T yynewbytes;                        \
  329     YYCOPY (&yyptr->Stack, Stack, yysize);              \
  330     Stack = &yyptr->Stack;                      \
  331     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
  332     yyptr += yynewbytes / sizeof (*yyptr);              \
  333       }                                 \
  334     while (0)
  335 
  336 #endif
  337 
  338 #if defined (__STDC__) || defined (__cplusplus)
  339    typedef signed char yysigned_char;
  340 #else
  341    typedef short int yysigned_char;
  342 #endif
  343 
  344 /* YYFINAL -- State number of the termination state. */
  345 #define YYFINAL  2
  346 /* YYLAST -- Last index in YYTABLE.  */
  347 #define YYLAST   719
  348 
  349 /* YYNTOKENS -- Number of terminals. */
  350 #define YYNTOKENS  53
  351 /* YYNNTS -- Number of nonterminals. */
  352 #define YYNNTS  36
  353 /* YYNRULES -- Number of rules. */
  354 #define YYNRULES  112
  355 /* YYNRULES -- Number of states. */
  356 #define YYNSTATES  198
  357 
  358 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
  359 #define YYUNDEFTOK  2
  360 #define YYMAXUTOK   292
  361 
  362 #define YYTRANSLATE(YYX)                        \
  363   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
  364 
  365 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
  366 static const unsigned char yytranslate[] =
  367 {
  368        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  369        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  370        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  371        2,     2,     2,     2,     2,     2,     2,    42,    52,     2,
  372       45,    46,    40,    38,    49,    39,     2,    41,     2,     2,
  373        2,     2,     2,     2,     2,     2,     2,     2,     2,    44,
  374        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  375        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  376        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  377        2,    50,     2,    51,    43,     2,     2,     2,     2,     2,
  378        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  379        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  380        2,     2,     2,    47,     2,    48,     2,     2,     2,     2,
  381        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  382        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  383        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  384        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  385        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  386        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  387        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  388        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  389        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  390        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  391        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  392        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  393        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
  394        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
  395       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  396       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  397       35,    36,    37
  398 };
  399 
  400 #if YYDEBUG
  401 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
  402    YYRHS.  */
  403 static const unsigned short int yyprhs[] =
  404 {
  405        0,     0,     3,     4,     7,    10,    12,    15,    16,    18,
  406       19,    21,    25,    28,    29,    31,    34,    38,    41,    45,
  407       47,    50,    52,    54,    56,    58,    60,    62,    64,    66,
  408       69,    70,    71,    72,    73,    88,    89,    98,    99,   100,
  409      109,   113,   114,   118,   120,   124,   126,   128,   129,   130,
  410      135,   136,   150,   151,   153,   154,   156,   157,   161,   165,
  411      167,   171,   176,   181,   185,   191,   198,   205,   206,   208,
  412      210,   214,   218,   224,   225,   227,   228,   230,   231,   236,
  413      237,   242,   243,   248,   251,   255,   259,   263,   267,   271,
  414      275,   279,   282,   284,   286,   290,   295,   298,   301,   306,
  415      311,   316,   320,   324,   326,   331,   333,   335,   337,   339,
  416      341,   342,   344
  417 };
  418 
  419 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
  420 static const yysigned_char yyrhs[] =
  421 {
  422       54,     0,    -1,    -1,    54,    55,    -1,    57,     3,    -1,
  423       73,    -1,     1,     3,    -1,    -1,     3,    -1,    -1,    59,
  424       -1,    57,    44,    59,    -1,    57,    44,    -1,    -1,    59,
  425       -1,    58,     3,    -1,    58,     3,    59,    -1,    58,    44,
  426       -1,    58,    44,    60,    -1,    60,    -1,     1,    60,    -1,
  427       29,    -1,    34,    -1,    83,    -1,     7,    -1,    14,    -1,
  428       32,    -1,    15,    -1,    30,    -1,    17,    82,    -1,    -1,
  429       -1,    -1,    -1,    18,    61,    45,    81,    44,    62,    81,
  430       44,    63,    81,    46,    64,    56,    60,    -1,    -1,    19,
  431       45,    83,    46,    65,    56,    60,    71,    -1,    -1,    -1,
  432       20,    66,    45,    83,    67,    46,    56,    60,    -1,    47,
  433       58,    48,    -1,    -1,    33,    68,    69,    -1,    70,    -1,
  434       70,    49,    69,    -1,     7,    -1,    83,    -1,    -1,    -1,
  435       22,    72,    56,    60,    -1,    -1,    13,    75,     8,    45,
  436       76,    46,    56,    47,    88,    77,    74,    58,    48,    -1,
  437       -1,    37,    -1,    -1,    78,    -1,    -1,    26,    78,     3,
  438       -1,    26,    78,    44,    -1,     8,    -1,     8,    50,    51,
  439       -1,    40,     8,    50,    51,    -1,    52,     8,    50,    51,
  440       -1,    78,    49,     8,    -1,    78,    49,     8,    50,    51,
  441       -1,    78,    49,    40,     8,    50,    51,    -1,    78,    49,
  442       52,     8,    50,    51,    -1,    -1,    80,    -1,    83,    -1,
  443        8,    50,    51,    -1,    80,    49,    83,    -1,    80,    49,
  444        8,    50,    51,    -1,    -1,    83,    -1,    -1,    83,    -1,
  445       -1,    87,    10,    84,    83,    -1,    -1,    83,     4,    85,
  446       83,    -1,    -1,    83,     5,    86,    83,    -1,     6,    83,
  447       -1,    83,    11,    83,    -1,    83,    38,    83,    -1,    83,
  448       39,    83,    -1,    83,    40,    83,    -1,    83,    41,    83,
  449       -1,    83,    42,    83,    -1,    83,    43,    83,    -1,    39,
  450       83,    -1,    87,    -1,     9,    -1,    45,    83,    46,    -1,
  451        8,    45,    79,    46,    -1,    12,    87,    -1,    87,    12,
  452       -1,    16,    45,    83,    46,    -1,    21,    45,    83,    46,
  453       -1,    23,    45,    83,    46,    -1,    27,    45,    46,    -1,
  454       28,    45,    46,    -1,     8,    -1,     8,    50,    83,    51,
  455       -1,    24,    -1,    25,    -1,    23,    -1,    36,    -1,    31,
  456       -1,    -1,     3,    -1,    88,     3,    -1
  457 };
  458 
  459 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
  460 static const unsigned short int yyrline[] =
  461 {
  462        0,   124,   124,   132,   134,   136,   138,   144,   145,   149,
  463      150,   151,   152,   155,   156,   157,   158,   159,   160,   162,
  464      163,   166,   168,   170,   179,   186,   196,   207,   209,   211,
  465      214,   219,   231,   244,   213,   264,   263,   279,   285,   278,
  466      299,   302,   301,   305,   306,   308,   314,   321,   323,   322,
  467      334,   332,   359,   360,   367,   368,   371,   372,   374,   377,
  468      379,   381,   385,   389,   391,   393,   397,   403,   404,   406,
  469      414,   420,   428,   446,   450,   453,   459,   474,   473,   503,
  470      502,   518,   517,   535,   543,   573,   580,   587,   594,   601,
  471      608,   615,   622,   631,   647,   653,   672,   691,   714,   721,
  472      728,   735,   741,   748,   750,   758,   760,   762,   764,   768,
  473      775,   776,   777
  474 };
  475 #endif
  476 
  477 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
  478 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
  479    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
  480 static const char *const yytname[] =
  481 {
  482   "$end", "error", "$undefined", "ENDOFLINE", "AND", "OR", "NOT",
  483   "STRING", "NAME", "NUMBER", "ASSIGN_OP", "REL_OP", "INCR_DECR", "Define",
  484   "Break", "Quit", "Length", "Return", "For", "If", "While", "Sqrt",
  485   "Else", "Scale", "Ibase", "Obase", "Auto", "Read", "Random", "Warranty",
  486   "Halt", "Last", "Continue", "Print", "Limits", "UNARY_MINUS",
  487   "HistoryVar", "Void", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "';'",
  488   "'('", "')'", "'{'", "'}'", "','", "'['", "']'", "'&'", "$accept",
  489   "program", "input_item", "opt_newline", "semicolon_list",
  490   "statement_list", "statement_or_error", "statement", "@1", "@2", "@3",
  491   "@4", "@5", "@6", "@7", "@8", "print_list", "print_element", "opt_else",
  492   "@9", "function", "@10", "opt_void", "opt_parameter_list",
  493   "opt_auto_define_list", "define_list", "opt_argument_list",
  494   "argument_list", "opt_expression", "return_expression", "expression",
  495   "@11", "@12", "@13", "named_expression", "required_eol", 0
  496 };
  497 #endif
  498 
  499 # ifdef YYPRINT
  500 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
  501    token YYLEX-NUM.  */
  502 static const unsigned short int yytoknum[] =
  503 {
  504        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
  505      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
  506      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
  507      285,   286,   287,   288,   289,   290,   291,   292,    43,    45,
  508       42,    47,    37,    94,    59,    40,    41,   123,   125,    44,
  509       91,    93,    38
  510 };
  511 # endif
  512 
  513 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  514 static const unsigned char yyr1[] =
  515 {
  516        0,    53,    54,    54,    55,    55,    55,    56,    56,    57,
  517       57,    57,    57,    58,    58,    58,    58,    58,    58,    59,
  518       59,    60,    60,    60,    60,    60,    60,    60,    60,    60,
  519       61,    62,    63,    64,    60,    65,    60,    66,    67,    60,
  520       60,    68,    60,    69,    69,    70,    70,    71,    72,    71,
  521       74,    73,    75,    75,    76,    76,    77,    77,    77,    78,
  522       78,    78,    78,    78,    78,    78,    78,    79,    79,    80,
  523       80,    80,    80,    81,    81,    82,    82,    84,    83,    85,
  524       83,    86,    83,    83,    83,    83,    83,    83,    83,    83,
  525       83,    83,    83,    83,    83,    83,    83,    83,    83,    83,
  526       83,    83,    83,    87,    87,    87,    87,    87,    87,    87,
  527       88,    88,    88
  528 };
  529 
  530 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
  531 static const unsigned char yyr2[] =
  532 {
  533        0,     2,     0,     2,     2,     1,     2,     0,     1,     0,
  534        1,     3,     2,     0,     1,     2,     3,     2,     3,     1,
  535        2,     1,     1,     1,     1,     1,     1,     1,     1,     2,
  536        0,     0,     0,     0,    14,     0,     8,     0,     0,     8,
  537        3,     0,     3,     1,     3,     1,     1,     0,     0,     4,
  538        0,    13,     0,     1,     0,     1,     0,     3,     3,     1,
  539        3,     4,     4,     3,     5,     6,     6,     0,     1,     1,
  540        3,     3,     5,     0,     1,     0,     1,     0,     4,     0,
  541        4,     0,     4,     2,     3,     3,     3,     3,     3,     3,
  542        3,     2,     1,     1,     3,     4,     2,     2,     4,     4,
  543        4,     3,     3,     1,     4,     1,     1,     1,     1,     1,
  544        0,     1,     2
  545 };
  546 
  547 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
  548    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
  549    means the default is an error.  */
  550 static const unsigned char yydefact[] =
  551 {
  552        2,     0,     1,     0,     0,    24,   103,    93,     0,    52,
  553       25,    27,     0,    75,    30,     0,    37,     0,   107,   105,
  554      106,     0,     0,    21,    28,   109,    26,    41,    22,   108,
  555        0,     0,     0,     3,     0,    10,    19,     5,    23,    92,
  556        6,    20,    83,    67,     0,   103,   107,    96,    53,     0,
  557        0,    29,    76,     0,     0,     0,     0,     0,     0,     0,
  558        0,    91,     0,     0,     0,    14,     4,     0,    79,    81,
  559        0,     0,     0,     0,     0,     0,     0,    77,    97,   103,
  560        0,    68,    69,     0,     0,     0,    73,     0,     0,     0,
  561        0,   101,   102,    45,    42,    43,    46,    94,     0,    17,
  562       40,    11,     0,     0,    84,    85,    86,    87,    88,    89,
  563       90,     0,     0,    95,     0,   104,    54,    98,     0,    74,
  564       35,    38,    99,   100,     0,    16,    18,    80,    82,    78,
  565       70,   103,    71,    59,     0,     0,     0,    55,    31,     7,
  566        0,    44,     0,     0,     0,     0,     7,     0,    73,     8,
  567        0,     7,    72,    60,     0,     0,     0,    63,     0,     0,
  568        0,    47,     0,    61,    62,   110,     0,     0,     0,    32,
  569       48,    36,    39,   111,    56,    64,     0,     0,    73,     7,
  570      112,     0,    50,    65,    66,     0,     0,     0,     0,    33,
  571       49,    57,    58,     0,     7,    51,     0,    34
  572 };
  573 
  574 /* YYDEFGOTO[NTERM-NUM]. */
  575 static const short int yydefgoto[] =
  576 {
  577       -1,     1,    33,   150,    34,    64,    65,    36,    53,   148,
  578      178,   194,   139,    55,   140,    60,    94,    95,   171,   179,
  579       37,   188,    49,   136,   182,   137,    80,    81,   118,    51,
  580       38,   111,   102,   103,    39,   174
  581 };
  582 
  583 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
  584    STATE-NUM.  */
  585 #define YYPACT_NINF -144
  586 static const short int yypact[] =
  587 {
  588     -144,   188,  -144,   392,   595,  -144,   -36,  -144,   484,   -31,
  589     -144,  -144,   -32,   595,  -144,   -11,  -144,   -10,    -7,  -144,
  590     -144,    -6,    -5,  -144,  -144,  -144,  -144,  -144,  -144,  -144,
  591      595,   595,   222,  -144,     2,  -144,  -144,  -144,   676,    14,
  592     -144,  -144,   131,   621,   595,   -27,  -144,  -144,  -144,    54,
  593      595,  -144,   676,    20,   595,    21,   595,   595,    13,    37,
  594      569,  -144,   425,   535,     1,  -144,  -144,   318,  -144,  -144,
  595      595,   595,   595,   595,   595,   595,   595,  -144,  -144,   -23,
  596       41,    36,   676,    39,    43,   436,   595,   445,   595,   485,
  597      494,  -144,  -144,  -144,  -144,    40,   676,  -144,   270,   535,
  598     -144,  -144,   595,   595,   -22,    51,    51,     4,     4,     4,
  599        4,   595,   105,  -144,   647,  -144,    23,  -144,    53,   676,
  600     -144,   676,  -144,  -144,   569,  -144,  -144,   131,   123,   -22,
  601     -144,   -20,   676,    45,    91,    94,    57,    55,  -144,   102,
  602       60,  -144,   352,    56,    58,    65,   102,    24,   595,  -144,
  603      535,   102,  -144,  -144,    67,    68,    69,    70,   115,   116,
  604       81,   109,   535,  -144,  -144,   132,    86,    88,    89,  -144,
  605     -144,  -144,  -144,  -144,     7,  -144,    92,    97,   595,   102,
  606     -144,    23,  -144,  -144,  -144,    99,   535,    12,   222,  -144,
  607     -144,  -144,  -144,     9,   102,  -144,   535,  -144
  608 };
  609 
  610 /* YYPGOTO[NTERM-NUM].  */
  611 static const short int yypgoto[] =
  612 {
  613     -144,  -144,  -144,  -143,  -144,   -39,     0,    -3,  -144,  -144,
  614     -144,  -144,  -144,  -144,  -144,  -144,    27,  -144,  -144,  -144,
  615     -144,  -144,  -144,  -144,  -144,   -29,  -144,  -144,  -141,  -144,
  616       -2,  -144,  -144,  -144,   145,  -144
  617 };
  618 
  619 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
  620    positive, shift that token.  If negative, reduce the rule which
  621    number is the opposite.  If zero, do what YYDEFACT says.
  622    If YYTABLE_NINF, syntax error.  */
  623 #define YYTABLE_NINF -16
  624 static const short int yytable[] =
  625 {
  626       41,    35,    42,   156,    98,    66,    48,   160,   162,    43,
  627      180,    52,    98,    50,    44,   191,    71,    72,    73,    74,
  628       75,    76,    43,    44,    77,    43,    78,   112,    61,    62,
  629      142,   133,   157,   181,    54,    56,   186,   185,    57,    58,
  630       59,    82,    83,    68,    69,    99,    67,    76,    85,   100,
  631       70,   196,    87,    99,    89,    90,   192,   195,    96,    91,
  632       41,   147,    84,   134,   158,    86,    88,   101,   104,   105,
  633      106,   107,   108,   109,   110,   135,   159,    71,    72,    73,
  634       74,    75,    76,    92,   119,   114,   121,   113,   116,   124,
  635      115,    73,    74,    75,    76,   143,   126,   138,   125,   144,
  636      127,   128,   145,   146,   147,   149,   151,   153,   154,   129,
  637       83,     4,   132,     6,     7,   155,   165,     8,   163,   164,
  638      166,    12,    96,   167,   168,   169,    17,    68,    18,    19,
  639       20,   170,    21,    22,    70,   173,    25,   175,   176,   177,
  640       83,    29,    70,   183,    30,   189,   119,   161,   184,   193,
  641       31,   141,   187,    47,     0,     0,   130,     0,     0,   172,
  642        0,    71,    72,    73,    74,    75,    76,     0,     0,    71,
  643       72,    73,    74,    75,    76,     0,   119,     0,     0,     0,
  644        0,     0,     0,   190,     0,     0,     0,     0,     2,     3,
  645        0,    -9,     0,   197,     4,     5,     6,     7,     0,     0,
  646        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
  647        0,    18,    19,    20,     0,    21,    22,    23,    24,    25,
  648       26,    27,    28,    63,    29,   -13,     0,    30,     4,     5,
  649        6,     7,    -9,    31,     8,    32,    10,    11,    12,    13,
  650       14,    15,    16,    17,     0,    18,    19,    20,     0,    21,
  651       22,    23,    24,    25,    26,    27,    28,     0,    29,     0,
  652        0,    30,     0,     0,     0,     0,   -13,    31,     0,    32,
  653      -13,    63,     0,   -15,     0,     0,     4,     5,     6,     7,
  654        0,     0,     8,     0,    10,    11,    12,    13,    14,    15,
  655       16,    17,     0,    18,    19,    20,     0,    21,    22,    23,
  656       24,    25,    26,    27,    28,     0,    29,     0,     0,    30,
  657        0,     0,     0,     0,   -15,    31,     0,    32,   -15,    63,
  658        0,   -12,     0,     0,     4,     5,     6,     7,     0,     0,
  659        8,     0,    10,    11,    12,    13,    14,    15,    16,    17,
  660        0,    18,    19,    20,     0,    21,    22,    23,    24,    25,
  661       26,    27,    28,     0,    29,     0,     0,    30,     4,     0,
  662        6,     7,   -12,    31,     8,    32,     0,     0,    12,     0,
  663        0,     0,     0,    17,     0,    18,    19,    20,     0,    21,
  664       22,     0,     0,    25,     0,     0,     0,     0,    29,     0,
  665        0,    30,     0,     0,     0,    40,     0,    31,     4,     5,
  666        6,     7,     0,   152,     8,     0,    10,    11,    12,    13,
  667       14,    15,    16,    17,     0,    18,    19,    20,     0,    21,
  668       22,    23,    24,    25,    26,    27,    28,     0,    29,    68,
  669       69,    30,     0,     0,     0,     0,    70,    31,     0,    32,
  670       68,    69,     0,     0,     0,     0,     0,    70,     0,    68,
  671       69,     0,     0,     0,     0,     0,    70,     0,     0,     0,
  672        0,     0,     0,    71,    72,    73,    74,    75,    76,     0,
  673        0,    97,     0,     0,    71,    72,    73,    74,    75,    76,
  674        0,     0,   117,    71,    72,    73,    74,    75,    76,    68,
  675       69,   120,    45,     0,     0,     0,    70,     0,    68,    69,
  676        0,     0,     0,     0,     0,    70,     0,    46,    19,    20,
  677        0,     0,     0,     0,     0,    25,     0,     0,     0,     0,
  678       29,     0,     0,    71,    72,    73,    74,    75,    76,     0,
  679        0,   122,    71,    72,    73,    74,    75,    76,     0,     0,
  680      123,     4,     5,     6,     7,     0,     0,     8,     0,    10,
  681       11,    12,    13,    14,    15,    16,    17,     0,    18,    19,
  682       20,     0,    21,    22,    23,    24,    25,    26,    27,    28,
  683        0,    29,     0,     0,    30,     4,    93,     6,     7,     0,
  684       31,     8,    32,     0,     0,    12,     0,     0,     0,     0,
  685       17,     0,    18,    19,    20,     0,    21,    22,     0,     0,
  686       25,     4,     0,     6,     7,    29,     0,     8,    30,     0,
  687        0,    12,     0,     0,    31,     0,    17,     0,    18,    19,
  688       20,     0,    21,    22,     0,     0,    25,     4,     0,    79,
  689        7,    29,     0,     8,    30,     0,     0,    12,     0,     0,
  690       31,     0,    17,     0,    18,    19,    20,     0,    21,    22,
  691        0,     0,    25,     4,     0,   131,     7,    29,     0,     8,
  692       30,     0,     0,    12,     0,     0,    31,     0,    17,     0,
  693       18,    19,    20,     0,    21,    22,     0,     0,    25,     0,
  694       68,    69,     0,    29,     0,     0,    30,    70,     0,     0,
  695        0,     0,    31,     0,     0,     0,     0,     0,     0,     0,
  696        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  697        0,     0,     0,     0,    71,    72,    73,    74,    75,    76
  698 };
  699 
  700 static const short int yycheck[] =
  701 {
  702        3,     1,     4,   146,     3,     3,    37,   148,   151,    45,
  703        3,    13,     3,    45,    50,     3,    38,    39,    40,    41,
  704       42,    43,    45,    50,    10,    45,    12,    50,    30,    31,
  705       50,     8,     8,    26,    45,    45,   179,   178,    45,    45,
  706       45,    43,    44,     4,     5,    44,    44,    43,    50,    48,
  707       11,   194,    54,    44,    56,    57,    44,    48,    60,    46,
  708       63,    49,     8,    40,    40,    45,    45,    67,    70,    71,
  709       72,    73,    74,    75,    76,    52,    52,    38,    39,    40,
  710       41,    42,    43,    46,    86,    49,    88,    46,    45,    49,
  711       51,    40,    41,    42,    43,    50,    99,    44,    98,     8,
  712      102,   103,     8,    46,    49,     3,    46,    51,    50,   111,
  713      112,     6,   114,     8,     9,    50,    47,    12,    51,    51,
  714       50,    16,   124,     8,     8,    44,    21,     4,    23,    24,
  715       25,    22,    27,    28,    11,     3,    31,    51,    50,    50,
  716      142,    36,    11,    51,    39,    46,   148,   150,    51,   188,
  717       45,   124,   181,     8,    -1,    -1,    51,    -1,    -1,   162,
  718       -1,    38,    39,    40,    41,    42,    43,    -1,    -1,    38,
  719       39,    40,    41,    42,    43,    -1,   178,    -1,    -1,    -1,
  720       -1,    -1,    -1,   186,    -1,    -1,    -1,    -1,     0,     1,
  721       -1,     3,    -1,   196,     6,     7,     8,     9,    -1,    -1,
  722       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
  723       -1,    23,    24,    25,    -1,    27,    28,    29,    30,    31,
  724       32,    33,    34,     1,    36,     3,    -1,    39,     6,     7,
  725        8,     9,    44,    45,    12,    47,    14,    15,    16,    17,
  726       18,    19,    20,    21,    -1,    23,    24,    25,    -1,    27,
  727       28,    29,    30,    31,    32,    33,    34,    -1,    36,    -1,
  728       -1,    39,    -1,    -1,    -1,    -1,    44,    45,    -1,    47,
  729       48,     1,    -1,     3,    -1,    -1,     6,     7,     8,     9,
  730       -1,    -1,    12,    -1,    14,    15,    16,    17,    18,    19,
  731       20,    21,    -1,    23,    24,    25,    -1,    27,    28,    29,
  732       30,    31,    32,    33,    34,    -1,    36,    -1,    -1,    39,
  733       -1,    -1,    -1,    -1,    44,    45,    -1,    47,    48,     1,
  734       -1,     3,    -1,    -1,     6,     7,     8,     9,    -1,    -1,
  735       12,    -1,    14,    15,    16,    17,    18,    19,    20,    21,
  736       -1,    23,    24,    25,    -1,    27,    28,    29,    30,    31,
  737       32,    33,    34,    -1,    36,    -1,    -1,    39,     6,    -1,
  738        8,     9,    44,    45,    12,    47,    -1,    -1,    16,    -1,
  739       -1,    -1,    -1,    21,    -1,    23,    24,    25,    -1,    27,
  740       28,    -1,    -1,    31,    -1,    -1,    -1,    -1,    36,    -1,
  741       -1,    39,    -1,    -1,    -1,     3,    -1,    45,     6,     7,
  742        8,     9,    -1,    51,    12,    -1,    14,    15,    16,    17,
  743       18,    19,    20,    21,    -1,    23,    24,    25,    -1,    27,
  744       28,    29,    30,    31,    32,    33,    34,    -1,    36,     4,
  745        5,    39,    -1,    -1,    -1,    -1,    11,    45,    -1,    47,
  746        4,     5,    -1,    -1,    -1,    -1,    -1,    11,    -1,     4,
  747        5,    -1,    -1,    -1,    -1,    -1,    11,    -1,    -1,    -1,
  748       -1,    -1,    -1,    38,    39,    40,    41,    42,    43,    -1,
  749       -1,    46,    -1,    -1,    38,    39,    40,    41,    42,    43,
  750       -1,    -1,    46,    38,    39,    40,    41,    42,    43,     4,
  751        5,    46,     8,    -1,    -1,    -1,    11,    -1,     4,     5,
  752       -1,    -1,    -1,    -1,    -1,    11,    -1,    23,    24,    25,
  753       -1,    -1,    -1,    -1,    -1,    31,    -1,    -1,    -1,    -1,
  754       36,    -1,    -1,    38,    39,    40,    41,    42,    43,    -1,
  755       -1,    46,    38,    39,    40,    41,    42,    43,    -1,    -1,
  756       46,     6,     7,     8,     9,    -1,    -1,    12,    -1,    14,
  757       15,    16,    17,    18,    19,    20,    21,    -1,    23,    24,
  758       25,    -1,    27,    28,    29,    30,    31,    32,    33,    34,
  759       -1,    36,    -1,    -1,    39,     6,     7,     8,     9,    -1,
  760       45,    12,    47,    -1,    -1,    16,    -1,    -1,    -1,    -1,
  761       21,    -1,    23,    24,    25,    -1,    27,    28,    -1,    -1,
  762       31,     6,    -1,     8,     9,    36,    -1,    12,    39,    -1,
  763       -1,    16,    -1,    -1,    45,    -1,    21,    -1,    23,    24,
  764       25,    -1,    27,    28,    -1,    -1,    31,     6,    -1,     8,
  765        9,    36,    -1,    12,    39,    -1,    -1,    16,    -1,    -1,
  766       45,    -1,    21,    -1,    23,    24,    25,    -1,    27,    28,
  767       -1,    -1,    31,     6,    -1,     8,     9,    36,    -1,    12,
  768       39,    -1,    -1,    16,    -1,    -1,    45,    -1,    21,    -1,
  769       23,    24,    25,    -1,    27,    28,    -1,    -1,    31,    -1,
  770        4,     5,    -1,    36,    -1,    -1,    39,    11,    -1,    -1,
  771       -1,    -1,    45,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  772       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  773       -1,    -1,    -1,    -1,    38,    39,    40,    41,    42,    43
  774 };
  775 
  776 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
  777    symbol of state STATE-NUM.  */
  778 static const unsigned char yystos[] =
  779 {
  780        0,    54,     0,     1,     6,     7,     8,     9,    12,    13,
  781       14,    15,    16,    17,    18,    19,    20,    21,    23,    24,
  782       25,    27,    28,    29,    30,    31,    32,    33,    34,    36,
  783       39,    45,    47,    55,    57,    59,    60,    73,    83,    87,
  784        3,    60,    83,    45,    50,     8,    23,    87,    37,    75,
  785       45,    82,    83,    61,    45,    66,    45,    45,    45,    45,
  786       68,    83,    83,     1,    58,    59,     3,    44,     4,     5,
  787       11,    38,    39,    40,    41,    42,    43,    10,    12,     8,
  788       79,    80,    83,    83,     8,    83,    45,    83,    45,    83,
  789       83,    46,    46,     7,    69,    70,    83,    46,     3,    44,
  790       48,    59,    85,    86,    83,    83,    83,    83,    83,    83,
  791       83,    84,    50,    46,    49,    51,    45,    46,    81,    83,
  792       46,    83,    46,    46,    49,    59,    60,    83,    83,    83,
  793       51,     8,    83,     8,    40,    52,    76,    78,    44,    65,
  794       67,    69,    50,    50,     8,     8,    46,    49,    62,     3,
  795       56,    46,    51,    51,    50,    50,    56,     8,    40,    52,
  796       81,    60,    56,    51,    51,    47,    50,     8,     8,    44,
  797       22,    71,    60,     3,    88,    51,    50,    50,    63,    72,
  798        3,    26,    77,    51,    51,    81,    56,    78,    74,    46,
  799       60,     3,    44,    58,    64,    48,    56,    60
  800 };
  801 
  802 #define yyerrok     (yyerrstatus = 0)
  803 #define yyclearin   (yychar = YYEMPTY)
  804 #define YYEMPTY     (-2)
  805 #define YYEOF       0
  806 
  807 #define YYACCEPT    goto yyacceptlab
  808 #define YYABORT     goto yyabortlab
  809 #define YYERROR     goto yyerrorlab
  810 
  811 
  812 /* Like YYERROR except do call yyerror.  This remains here temporarily
  813    to ease the transition to the new meaning of YYERROR, for GCC.
  814    Once GCC version 2 has supplanted version 1, this can go.  */
  815 
  816 #define YYFAIL      goto yyerrlab
  817 
  818 #define YYRECOVERING()  (!!yyerrstatus)
  819 
  820 #define YYBACKUP(Token, Value)                  \
  821 do                              \
  822   if (yychar == YYEMPTY && yylen == 1)              \
  823     {                               \
  824       yychar = (Token);                     \
  825       yylval = (Value);                     \
  826       yytoken = YYTRANSLATE (yychar);               \
  827       YYPOPSTACK;                       \
  828       goto yybackup;                        \
  829     }                               \
  830   else                              \
  831     {                               \
  832       yyerror (YY_("syntax error: cannot back up")); \
  833       YYERROR;                          \
  834     }                               \
  835 while (0)
  836 
  837 
  838 #define YYTERROR    1
  839 #define YYERRCODE   256
  840 
  841 
  842 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
  843    If N is 0, then set CURRENT to the empty location which ends
  844    the previous symbol: RHS[0] (always defined).  */
  845 
  846 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
  847 #ifndef YYLLOC_DEFAULT
  848 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
  849     do                                  \
  850       if (N)                                \
  851     {                               \
  852       (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
  853       (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
  854       (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
  855       (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
  856     }                               \
  857       else                              \
  858     {                               \
  859       (Current).first_line   = (Current).last_line   =      \
  860         YYRHSLOC (Rhs, 0).last_line;                \
  861       (Current).first_column = (Current).last_column =      \
  862         YYRHSLOC (Rhs, 0).last_column;              \
  863     }                               \
  864     while (0)
  865 #endif
  866 
  867 
  868 /* YY_LOCATION_PRINT -- Print the location on the stream.
  869    This macro was not mandated originally: define only if we know
  870    we won't break user code: when these are the locations we know.  */
  871 
  872 #ifndef YY_LOCATION_PRINT
  873 # if YYLTYPE_IS_TRIVIAL
  874 #  define YY_LOCATION_PRINT(File, Loc)          \
  875      fprintf (File, "%d.%d-%d.%d",          \
  876               (Loc).first_line, (Loc).first_column, \
  877               (Loc).last_line,  (Loc).last_column)
  878 # else
  879 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  880 # endif
  881 #endif
  882 
  883 
  884 /* YYLEX -- calling `yylex' with the right arguments.  */
  885 
  886 #ifdef YYLEX_PARAM
  887 # define YYLEX yylex (YYLEX_PARAM)
  888 #else
  889 # define YYLEX yylex ()
  890 #endif
  891 
  892 /* Enable debugging if requested.  */
  893 #if YYDEBUG
  894 
  895 # ifndef YYFPRINTF
  896 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  897 #  define YYFPRINTF fprintf
  898 # endif
  899 
  900 # define YYDPRINTF(Args)            \
  901 do {                        \
  902   if (yydebug)                  \
  903     YYFPRINTF Args;             \
  904 } while (0)
  905 
  906 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)      \
  907 do {                                \
  908   if (yydebug)                          \
  909     {                               \
  910       YYFPRINTF (stderr, "%s ", Title);             \
  911       yysymprint (stderr,                   \
  912                   Type, Value); \
  913       YYFPRINTF (stderr, "\n");                 \
  914     }                               \
  915 } while (0)
  916 
  917 /*------------------------------------------------------------------.
  918 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
  919 | TOP (included).                                                   |
  920 `------------------------------------------------------------------*/
  921 
  922 #if defined (__STDC__) || defined (__cplusplus)
  923 static void
  924 yy_stack_print (short int *bottom, short int *top)
  925 #else
  926 static void
  927 yy_stack_print (bottom, top)
  928     short int *bottom;
  929     short int *top;
  930 #endif
  931 {
  932   YYFPRINTF (stderr, "Stack now");
  933   for (/* Nothing. */; bottom <= top; ++bottom)
  934     YYFPRINTF (stderr, " %d", *bottom);
  935   YYFPRINTF (stderr, "\n");
  936 }
  937 
  938 # define YY_STACK_PRINT(Bottom, Top)                \
  939 do {                                \
  940   if (yydebug)                          \
  941     yy_stack_print ((Bottom), (Top));               \
  942 } while (0)
  943 
  944 
  945 /*------------------------------------------------.
  946 | Report that the YYRULE is going to be reduced.  |
  947 `------------------------------------------------*/
  948 
  949 #if defined (__STDC__) || defined (__cplusplus)
  950 static void
  951 yy_reduce_print (int yyrule)
  952 #else
  953 static void
  954 yy_reduce_print (yyrule)
  955     int yyrule;
  956 #endif
  957 {
  958   int yyi;
  959   unsigned long int yylno = yyrline[yyrule];
  960   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
  961              yyrule - 1, yylno);
  962   /* Print the symbols being reduced, and their result.  */
  963   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
  964     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
  965   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
  966 }
  967 
  968 # define YY_REDUCE_PRINT(Rule)      \
  969 do {                    \
  970   if (yydebug)              \
  971     yy_reduce_print (Rule);     \
  972 } while (0)
  973 
  974 /* Nonzero means print parse trace.  It is left uninitialized so that
  975    multiple parsers can coexist.  */
  976 int yydebug;
  977 #else /* !YYDEBUG */
  978 # define YYDPRINTF(Args)
  979 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  980 # define YY_STACK_PRINT(Bottom, Top)
  981 # define YY_REDUCE_PRINT(Rule)
  982 #endif /* !YYDEBUG */
  983 
  984 
  985 /* YYINITDEPTH -- initial size of the parser's stacks.  */
  986 #ifndef YYINITDEPTH
  987 # define YYINITDEPTH 200
  988 #endif
  989 
  990 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
  991    if the built-in stack extension method is used).
  992 
  993    Do not make this value too large; the results are undefined if
  994    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
  995    evaluated with infinite-precision integer arithmetic.  */
  996 
  997 #ifndef YYMAXDEPTH
  998 # define YYMAXDEPTH 10000
  999 #endif
 1000 
 1001 
 1002 
 1003 #if YYERROR_VERBOSE
 1004 
 1005 # ifndef yystrlen
 1006 #  if defined (__GLIBC__) && defined (_STRING_H)
 1007 #   define yystrlen strlen
 1008 #  else
 1009 /* Return the length of YYSTR.  */
 1010 static YYSIZE_T
 1011 #   if defined (__STDC__) || defined (__cplusplus)
 1012 yystrlen (const char *yystr)
 1013 #   else
 1014 yystrlen (yystr)
 1015      const char *yystr;
 1016 #   endif
 1017 {
 1018   const char *yys = yystr;
 1019 
 1020   while (*yys++ != '\0')
 1021     continue;
 1022 
 1023   return yys - yystr - 1;
 1024 }
 1025 #  endif
 1026 # endif
 1027 
 1028 # ifndef yystpcpy
 1029 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 1030 #   define yystpcpy stpcpy
 1031 #  else
 1032 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 1033    YYDEST.  */
 1034 static char *
 1035 #   if defined (__STDC__) || defined (__cplusplus)
 1036 yystpcpy (char *yydest, const char *yysrc)
 1037 #   else
 1038 yystpcpy (yydest, yysrc)
 1039      char *yydest;
 1040      const char *yysrc;
 1041 #   endif
 1042 {
 1043   char *yyd = yydest;
 1044   const char *yys = yysrc;
 1045 
 1046   while ((*yyd++ = *yys++) != '\0')
 1047     continue;
 1048 
 1049   return yyd - 1;
 1050 }
 1051 #  endif
 1052 # endif
 1053 
 1054 # ifndef yytnamerr
 1055 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 1056    quotes and backslashes, so that it's suitable for yyerror.  The
 1057    heuristic is that double-quoting is unnecessary unless the string
 1058    contains an apostrophe, a comma, or backslash (other than
 1059    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 1060    null, do not copy; instead, return the length of what the result
 1061    would have been.  */
 1062 static YYSIZE_T
 1063 yytnamerr (char *yyres, const char *yystr)
 1064 {
 1065   if (*yystr == '"')
 1066     {
 1067       size_t yyn = 0;
 1068       char const *yyp = yystr;
 1069 
 1070       for (;;)
 1071     switch (*++yyp)
 1072       {
 1073       case '\'':
 1074       case ',':
 1075         goto do_not_strip_quotes;
 1076 
 1077       case '\\':
 1078         if (*++yyp != '\\')
 1079           goto do_not_strip_quotes;
 1080         /* Fall through.  */
 1081       default:
 1082         if (yyres)
 1083           yyres[yyn] = *yyp;
 1084         yyn++;
 1085         break;
 1086 
 1087       case '"':
 1088         if (yyres)
 1089           yyres[yyn] = '\0';
 1090         return yyn;
 1091       }
 1092     do_not_strip_quotes: ;
 1093     }
 1094 
 1095   if (! yyres)
 1096     return yystrlen (yystr);
 1097 
 1098   return yystpcpy (yyres, yystr) - yyres;
 1099 }
 1100 # endif
 1101 
 1102 #endif /* YYERROR_VERBOSE */
 1103 
 1104 
 1105 
 1106 #if YYDEBUG
 1107 /*--------------------------------.
 1108 | Print this symbol on YYOUTPUT.  |
 1109 `--------------------------------*/
 1110 
 1111 #if defined (__STDC__) || defined (__cplusplus)
 1112 static void
 1113 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
 1114 #else
 1115 static void
 1116 yysymprint (yyoutput, yytype, yyvaluep)
 1117     FILE *yyoutput;
 1118     int yytype;
 1119     YYSTYPE *yyvaluep;
 1120 #endif
 1121 {
 1122   /* Pacify ``unused variable'' warnings.  */
 1123   (void) yyvaluep;
 1124 
 1125   if (yytype < YYNTOKENS)
 1126     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 1127   else
 1128     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 1129 
 1130 
 1131 # ifdef YYPRINT
 1132   if (yytype < YYNTOKENS)
 1133     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 1134 # endif
 1135   switch (yytype)
 1136     {
 1137       default:
 1138         break;
 1139     }
 1140   YYFPRINTF (yyoutput, ")");
 1141 }
 1142 
 1143 #endif /* ! YYDEBUG */
 1144 /*-----------------------------------------------.
 1145 | Release the memory associated to this symbol.  |
 1146 `-----------------------------------------------*/
 1147 
 1148 #if defined (__STDC__) || defined (__cplusplus)
 1149 static void
 1150 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 1151 #else
 1152 static void
 1153 yydestruct (yymsg, yytype, yyvaluep)
 1154     const char *yymsg;
 1155     int yytype;
 1156     YYSTYPE *yyvaluep;
 1157 #endif
 1158 {
 1159   /* Pacify ``unused variable'' warnings.  */
 1160   (void) yyvaluep;
 1161 
 1162   if (!yymsg)
 1163     yymsg = "Deleting";
 1164   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 1165 
 1166   switch (yytype)
 1167     {
 1168 
 1169       default:
 1170         break;
 1171     }
 1172 }
 1173 
 1174 
 1175 /* Prevent warnings from -Wmissing-prototypes.  */
 1176 
 1177 #ifdef YYPARSE_PARAM
 1178 # if defined (__STDC__) || defined (__cplusplus)
 1179 int yyparse (void *YYPARSE_PARAM);
 1180 # else
 1181 int yyparse ();
 1182 # endif
 1183 #else /* ! YYPARSE_PARAM */
 1184 #if defined (__STDC__) || defined (__cplusplus)
 1185 int yyparse (void);
 1186 #else
 1187 int yyparse ();
 1188 #endif
 1189 #endif /* ! YYPARSE_PARAM */
 1190 
 1191 
 1192 
 1193 /* The look-ahead symbol.  */
 1194 int yychar;
 1195 
 1196 /* The semantic value of the look-ahead symbol.  */
 1197 YYSTYPE yylval;
 1198 
 1199 /* Number of syntax errors so far.  */
 1200 int yynerrs;
 1201 
 1202 
 1203 
 1204 /*----------.
 1205 | yyparse.  |
 1206 `----------*/
 1207 
 1208 #ifdef YYPARSE_PARAM
 1209 # if defined (__STDC__) || defined (__cplusplus)
 1210 int yyparse (void *YYPARSE_PARAM)
 1211 # else
 1212 int yyparse (YYPARSE_PARAM)
 1213   void *YYPARSE_PARAM;
 1214 # endif
 1215 #else /* ! YYPARSE_PARAM */
 1216 #if defined (__STDC__) || defined (__cplusplus)
 1217 int
 1218 yyparse (void)
 1219 #else
 1220 int
 1221 yyparse ()
 1222     ;
 1223 #endif
 1224 #endif
 1225 {
 1226   
 1227   int yystate;
 1228   int yyn;
 1229   int yyresult;
 1230   /* Number of tokens to shift before error messages enabled.  */
 1231   int yyerrstatus;
 1232   /* Look-ahead token as an internal (translated) token number.  */
 1233   int yytoken = 0;
 1234 
 1235   /* Three stacks and their tools:
 1236      `yyss': related to states,
 1237      `yyvs': related to semantic values,
 1238      `yyls': related to locations.
 1239 
 1240      Refer to the stacks thru separate pointers, to allow yyoverflow
 1241      to reallocate them elsewhere.  */
 1242 
 1243   /* The state stack.  */
 1244   short int yyssa[YYINITDEPTH];
 1245   short int *yyss = yyssa;
 1246   short int *yyssp;
 1247 
 1248   /* The semantic value stack.  */
 1249   YYSTYPE yyvsa[YYINITDEPTH];
 1250   YYSTYPE *yyvs = yyvsa;
 1251   YYSTYPE *yyvsp;
 1252 
 1253 
 1254 
 1255 #define YYPOPSTACK   (yyvsp--, yyssp--)
 1256 
 1257   YYSIZE_T yystacksize = YYINITDEPTH;
 1258 
 1259   /* The variables used to return semantic value and location from the
 1260      action routines.  */
 1261   YYSTYPE yyval;
 1262 
 1263 
 1264   /* When reducing, the number of symbols on the RHS of the reduced
 1265      rule.  */
 1266   int yylen;
 1267 
 1268   YYDPRINTF ((stderr, "Starting parse\n"));
 1269 
 1270   yystate = 0;
 1271   yyerrstatus = 0;
 1272   yynerrs = 0;
 1273   yychar = YYEMPTY;     /* Cause a token to be read.  */
 1274 
 1275   /* Initialize stack pointers.
 1276      Waste one element of value and location stack
 1277      so that they stay on the same level as the state stack.
 1278      The wasted elements are never initialized.  */
 1279 
 1280   yyssp = yyss;
 1281   yyvsp = yyvs;
 1282 
 1283   goto yysetstate;
 1284 
 1285 /*------------------------------------------------------------.
 1286 | yynewstate -- Push a new state, which is found in yystate.  |
 1287 `------------------------------------------------------------*/
 1288  yynewstate:
 1289   /* In all cases, when you get here, the value and location stacks
 1290      have just been pushed. so pushing a state here evens the stacks.
 1291      */
 1292   yyssp++;
 1293 
 1294  yysetstate:
 1295   *yyssp = yystate;
 1296 
 1297   if (yyss + yystacksize - 1 <= yyssp)
 1298     {
 1299       /* Get the current used size of the three stacks, in elements.  */
 1300       YYSIZE_T yysize = yyssp - yyss + 1;
 1301 
 1302 #ifdef yyoverflow
 1303       {
 1304     /* Give user a chance to reallocate the stack. Use copies of
 1305        these so that the &'s don't force the real ones into
 1306        memory.  */
 1307     YYSTYPE *yyvs1 = yyvs;
 1308     short int *yyss1 = yyss;
 1309 
 1310 
 1311     /* Each stack pointer address is followed by the size of the
 1312        data in use in that stack, in bytes.  This used to be a
 1313        conditional around just the two extra args, but that might
 1314        be undefined if yyoverflow is a macro.  */
 1315     yyoverflow (YY_("memory exhausted"),
 1316             &yyss1, yysize * sizeof (*yyssp),
 1317             &yyvs1, yysize * sizeof (*yyvsp),
 1318 
 1319             &yystacksize);
 1320 
 1321     yyss = yyss1;
 1322     yyvs = yyvs1;
 1323       }
 1324 #else /* no yyoverflow */
 1325 # ifndef YYSTACK_RELOCATE
 1326       goto yyexhaustedlab;
 1327 # else
 1328       /* Extend the stack our own way.  */
 1329       if (YYMAXDEPTH <= yystacksize)
 1330     goto yyexhaustedlab;
 1331       yystacksize *= 2;
 1332       if (YYMAXDEPTH < yystacksize)
 1333     yystacksize = YYMAXDEPTH;
 1334 
 1335       {
 1336     short int *yyss1 = yyss;
 1337     union yyalloc *yyptr =
 1338       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 1339     if (! yyptr)
 1340       goto yyexhaustedlab;
 1341     YYSTACK_RELOCATE (yyss);
 1342     YYSTACK_RELOCATE (yyvs);
 1343 
 1344 #  undef YYSTACK_RELOCATE
 1345     if (yyss1 != yyssa)
 1346       YYSTACK_FREE (yyss1);
 1347       }
 1348 # endif
 1349 #endif /* no yyoverflow */
 1350 
 1351       yyssp = yyss + yysize - 1;
 1352       yyvsp = yyvs + yysize - 1;
 1353 
 1354 
 1355       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 1356           (unsigned long int) yystacksize));
 1357 
 1358       if (yyss + yystacksize - 1 <= yyssp)
 1359     YYABORT;
 1360     }
 1361 
 1362   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 1363 
 1364   goto yybackup;
 1365 
 1366 /*-----------.
 1367 | yybackup.  |
 1368 `-----------*/
 1369 yybackup:
 1370 
 1371 /* Do appropriate processing given the current state.  */
 1372 /* Read a look-ahead token if we need one and don't already have one.  */
 1373 /* yyresume: */
 1374 
 1375   /* First try to decide what to do without reference to look-ahead token.  */
 1376 
 1377   yyn = yypact[yystate];
 1378   if (yyn == YYPACT_NINF)
 1379     goto yydefault;
 1380 
 1381   /* Not known => get a look-ahead token if don't already have one.  */
 1382 
 1383   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
 1384   if (yychar == YYEMPTY)
 1385     {
 1386       YYDPRINTF ((stderr, "Reading a token: "));
 1387       yychar = YYLEX;
 1388     }
 1389 
 1390   if (yychar <= YYEOF)
 1391     {
 1392       yychar = yytoken = YYEOF;
 1393       YYDPRINTF ((stderr, "Now at end of input.\n"));
 1394     }
 1395   else
 1396     {
 1397       yytoken = YYTRANSLATE (yychar);
 1398       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 1399     }
 1400 
 1401   /* If the proper action on seeing token YYTOKEN is to reduce or to
 1402      detect an error, take that action.  */
 1403   yyn += yytoken;
 1404   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
 1405     goto yydefault;
 1406   yyn = yytable[yyn];
 1407   if (yyn <= 0)
 1408     {
 1409       if (yyn == 0 || yyn == YYTABLE_NINF)
 1410     goto yyerrlab;
 1411       yyn = -yyn;
 1412       goto yyreduce;
 1413     }
 1414 
 1415   if (yyn == YYFINAL)
 1416     YYACCEPT;
 1417 
 1418   /* Shift the look-ahead token.  */
 1419   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 1420 
 1421   /* Discard the token being shifted unless it is eof.  */
 1422   if (yychar != YYEOF)
 1423     yychar = YYEMPTY;
 1424 
 1425   *++yyvsp = yylval;
 1426 
 1427 
 1428   /* Count tokens shifted since error; after three, turn off error
 1429      status.  */
 1430   if (yyerrstatus)
 1431     yyerrstatus--;
 1432 
 1433   yystate = yyn;
 1434   goto yynewstate;
 1435 
 1436 
 1437 /*-----------------------------------------------------------.
 1438 | yydefault -- do the default action for the current state.  |
 1439 `-----------------------------------------------------------*/
 1440 yydefault:
 1441   yyn = yydefact[yystate];
 1442   if (yyn == 0)
 1443     goto yyerrlab;
 1444   goto yyreduce;
 1445 
 1446 
 1447 /*-----------------------------.
 1448 | yyreduce -- Do a reduction.  |
 1449 `-----------------------------*/
 1450 yyreduce:
 1451   /* yyn is the number of a rule to reduce with.  */
 1452   yylen = yyr2[yyn];
 1453 
 1454   /* If YYLEN is nonzero, implement the default value of the action:
 1455      `$$ = $1'.
 1456 
 1457      Otherwise, the following line sets YYVAL to garbage.
 1458      This behavior is undocumented and Bison
 1459      users should not rely upon it.  Assigning to YYVAL
 1460      unconditionally makes the parser a bit smaller, and it avoids a
 1461      GCC warning that YYVAL may be used uninitialized.  */
 1462   yyval = yyvsp[1-yylen];
 1463 
 1464 
 1465   YY_REDUCE_PRINT (yyn);
 1466   switch (yyn)
 1467     {
 1468         case 2:
 1469 #line 124 "bc.y"
 1470     {
 1471                   (yyval.i_value) = 0;
 1472                   if (interactive && !quiet)
 1473                 {
 1474                   show_bc_version ();
 1475                   welcome ();
 1476                 }
 1477                 }
 1478     break;
 1479 
 1480   case 4:
 1481 #line 135 "bc.y"
 1482     { run_code (); }
 1483     break;
 1484 
 1485   case 5:
 1486 #line 137 "bc.y"
 1487     { run_code (); }
 1488     break;
 1489 
 1490   case 6:
 1491 #line 139 "bc.y"
 1492     {
 1493                   yyerrok;
 1494                   init_gen ();
 1495                 }
 1496     break;
 1497 
 1498   case 8:
 1499 #line 146 "bc.y"
 1500     { warn ("newline not allowed"); }
 1501     break;
 1502 
 1503   case 9:
 1504 #line 149 "bc.y"
 1505     { (yyval.i_value) = 0; }
 1506     break;
 1507 
 1508   case 13:
 1509 #line 155 "bc.y"
 1510     { (yyval.i_value) = 0; }
 1511     break;
 1512 
 1513   case 20:
 1514 #line 164 "bc.y"
 1515     { (yyval.i_value) = (yyvsp[0].i_value); }
 1516     break;
 1517 
 1518   case 21:
 1519 #line 167 "bc.y"
 1520     { warranty (""); }
 1521     break;
 1522 
 1523   case 22:
 1524 #line 169 "bc.y"
 1525     { limits (); }
 1526     break;
 1527 
 1528   case 23:
 1529 #line 171 "bc.y"
 1530     {
 1531                   if ((yyvsp[0].i_value) & EX_COMP)
 1532                 warn ("comparison in expression");
 1533                   if ((yyvsp[0].i_value) & EX_REG)
 1534                 generate ("W");
 1535                   else 
 1536                 generate ("p");
 1537                 }
 1538     break;
 1539 
 1540   case 24:
 1541 #line 180 "bc.y"
 1542     {
 1543                   (yyval.i_value) = 0;
 1544                   generate ("w");
 1545                   generate ((yyvsp[0].s_value));
 1546                   free ((yyvsp[0].s_value));
 1547                 }
 1548     break;
 1549 
 1550   case 25:
 1551 #line 187 "bc.y"
 1552     {
 1553                   if (break_label == 0)
 1554                 yyerror ("Break outside a for/while");
 1555                   else
 1556                 {
 1557                   sprintf (genstr, "J%1d:", break_label);
 1558                   generate (genstr);
 1559                 }
 1560                 }
 1561     break;
 1562 
 1563   case 26:
 1564 #line 197 "bc.y"
 1565     {
 1566                   warn ("Continue statement");
 1567                   if (continue_label == 0)
 1568                 yyerror ("Continue outside a for");
 1569                   else
 1570                 {
 1571                   sprintf (genstr, "J%1d:", continue_label);
 1572                   generate (genstr);
 1573                 }
 1574                 }
 1575     break;
 1576 
 1577   case 27:
 1578 #line 208 "bc.y"
 1579     { exit (0); }
 1580     break;
 1581 
 1582   case 28:
 1583 #line 210 "bc.y"
 1584     { generate ("h"); }
 1585     break;
 1586 
 1587   case 29:
 1588 #line 212 "bc.y"
 1589     { generate ("R"); }
 1590     break;
 1591 
 1592   case 30:
 1593 #line 214 "bc.y"
 1594     {
 1595                   (yyvsp[0].i_value) = break_label; 
 1596                   break_label = next_label++;
 1597                 }
 1598     break;
 1599 
 1600   case 31:
 1601 #line 219 "bc.y"
 1602     {
 1603                   if ((yyvsp[-1].i_value) & EX_COMP)
 1604                 warn ("Comparison in first for expression");
 1605                   if ((yyvsp[-1].i_value) & EX_VOID)
 1606                 yyerror ("first expression is void");
 1607                   if (!((yyvsp[-1].i_value) & EX_EMPTY))
 1608                 generate ("p");
 1609                   (yyvsp[-1].i_value) = next_label++;
 1610                   sprintf (genstr, "N%1d:", (yyvsp[-1].i_value));
 1611                   generate (genstr);
 1612                 }
 1613     break;
 1614 
 1615   case 32:
 1616 #line 231 "bc.y"
 1617     {
 1618                   if ((yyvsp[-1].i_value) & EX_VOID)
 1619                 yyerror ("second expression is void");
 1620                   if ((yyvsp[-1].i_value) & EX_EMPTY ) generate ("1");
 1621                   (yyvsp[-1].i_value) = next_label++;
 1622                   sprintf (genstr, "B%1d:J%1d:", (yyvsp[-1].i_value), break_label);
 1623                   generate (genstr);
 1624                   (yyval.i_value) = continue_label;
 1625                   continue_label = next_label++;
 1626                   sprintf (genstr, "N%1d:", continue_label);
 1627                   generate (genstr);
 1628                 }
 1629     break;
 1630 
 1631   case 33:
 1632 #line 244 "bc.y"
 1633     {
 1634                   if ((yyvsp[-1].i_value) & EX_COMP)
 1635                 warn ("Comparison in third for expression");
 1636                   if ((yyvsp[-1].i_value) & EX_VOID)
 1637                 yyerror ("third expression is void");
 1638                   if ((yyvsp[-1].i_value) & EX_EMPTY)
 1639                 sprintf (genstr, "J%1d:N%1d:", (yyvsp[-7].i_value), (yyvsp[-4].i_value));
 1640                   else
 1641                 sprintf (genstr, "pJ%1d:N%1d:", (yyvsp[-7].i_value), (yyvsp[-4].i_value));
 1642                   generate (genstr);
 1643                 }
 1644     break;
 1645 
 1646   case 34:
 1647 #line 256 "bc.y"
 1648     {
 1649                   sprintf (genstr, "J%1d:N%1d:",
 1650                        continue_label, break_label);
 1651                   generate (genstr);
 1652                   break_label = (yyvsp[-13].i_value);
 1653                   continue_label = (yyvsp[-5].i_value);
 1654                 }
 1655     break;
 1656 
 1657   case 35:
 1658 #line 264 "bc.y"
 1659     {
 1660                   if ((yyvsp[-1].i_value) & EX_VOID)
 1661                 yyerror ("void expression");
 1662                   (yyvsp[-1].i_value) = if_label;
 1663                   if_label = next_label++;
 1664                   sprintf (genstr, "Z%1d:", if_label);
 1665                   generate (genstr);
 1666                 }
 1667     break;
 1668 
 1669   case 36:
 1670 #line 273 "bc.y"
 1671     {
 1672                   sprintf (genstr, "N%1d:", if_label); 
 1673                   generate (genstr);
 1674                   if_label = (yyvsp[-5].i_value);
 1675                 }
 1676     break;
 1677 
 1678   case 37:
 1679 #line 279 "bc.y"
 1680     {
 1681                   (yyvsp[0].i_value) = next_label++;
 1682                   sprintf (genstr, "N%1d:", (yyvsp[0].i_value));
 1683                   generate (genstr);
 1684                 }
 1685     break;
 1686 
 1687   case 38:
 1688 #line 285 "bc.y"
 1689     {
 1690                   if ((yyvsp[0].i_value) & EX_VOID)
 1691                 yyerror ("void expression");
 1692                   (yyvsp[0].i_value) = break_label; 
 1693                   break_label = next_label++;
 1694                   sprintf (genstr, "Z%1d:", break_label);
 1695                   generate (genstr);
 1696                 }
 1697     break;
 1698 
 1699   case 39:
 1700 #line 294 "bc.y"
 1701     {
 1702                   sprintf (genstr, "J%1d:N%1d:", (yyvsp[-7].i_value), break_label);
 1703                   generate (genstr);
 1704                   break_label = (yyvsp[-4].i_value);
 1705                 }
 1706     break;
 1707 
 1708   case 40:
 1709 #line 300 "bc.y"
 1710     { (yyval.i_value) = 0; }
 1711     break;
 1712 
 1713   case 41:
 1714 #line 302 "bc.y"
 1715     {  warn ("print statement"); }
 1716     break;
 1717 
 1718   case 45:
 1719 #line 309 "bc.y"
 1720     {
 1721                   generate ("O");
 1722                   generate ((yyvsp[0].s_value));
 1723                   free ((yyvsp[0].s_value));
 1724                 }
 1725     break;
 1726 
 1727   case 46:
 1728 #line 315 "bc.y"
 1729     {
 1730                   if ((yyvsp[0].i_value) & EX_VOID)
 1731                 yyerror ("void expression in print");
 1732                   generate ("P");
 1733                 }
 1734     break;
 1735 
 1736   case 48:
 1737 #line 323 "bc.y"
 1738     {
 1739                   warn ("else clause in if statement");
 1740                   (yyvsp[0].i_value) = next_label++;
 1741                   sprintf (genstr, "J%d:N%1d:", (yyvsp[0].i_value), if_label); 
 1742                   generate (genstr);
 1743                   if_label = (yyvsp[0].i_value);
 1744                 }
 1745     break;
 1746 
 1747   case 50:
 1748 #line 334 "bc.y"
 1749     { char *params, *autos;
 1750                   /* Check auto list against parameter list? */
 1751                   check_params ((yyvsp[-5].a_value),(yyvsp[0].a_value));
 1752                   params = arg_str ((yyvsp[-5].a_value));
 1753                   autos  = arg_str ((yyvsp[0].a_value));
 1754                   set_genstr_size (30 + strlen (params)
 1755                            + strlen (autos));
 1756                   cur_func = lookup((yyvsp[-7].s_value),FUNCTDEF);
 1757                   sprintf (genstr, "F%d,%s.%s[", cur_func, params,
 1758                        autos); 
 1759                   generate (genstr);
 1760                   functions[cur_func].f_void = (yyvsp[-8].i_value);
 1761                   free_args ((yyvsp[-5].a_value));
 1762                   free_args ((yyvsp[0].a_value));
 1763                   (yyvsp[-9].i_value) = next_label;
 1764                   next_label = 1;
 1765                 }
 1766     break;
 1767 
 1768   case 51:
 1769 #line 352 "bc.y"
 1770     {
 1771                   generate ("0R]");
 1772                   next_label = (yyvsp[-12].i_value);
 1773                   cur_func = -1;
 1774                 }
 1775     break;
 1776 
 1777   case 52:
 1778 #line 359 "bc.y"
 1779     { (yyval.i_value) = 0; }
 1780     break;
 1781 
 1782   case 53:
 1783 #line 361 "bc.y"
 1784     {
 1785                   (yyval.i_value) = 1;
 1786                   warn ("void functions");
 1787                 }
 1788     break;
 1789 
 1790   case 54:
 1791 #line 367 "bc.y"
 1792     { (yyval.a_value) = NULL; }
 1793     break;
 1794 
 1795   case 56:
 1796 #line 371 "bc.y"
 1797     { (yyval.a_value) = NULL; }
 1798     break;
 1799 
 1800   case 57:
 1801 #line 373 "bc.y"
 1802     { (yyval.a_value) = (yyvsp[-1].a_value); }
 1803     break;
 1804 
 1805   case 58:
 1806 #line 375 "bc.y"
 1807     { (yyval.a_value) = (yyvsp[-1].a_value); }
 1808     break;
 1809 
 1810   case 59:
 1811 #line 378 "bc.y"
 1812     { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[0].s_value),SIMPLE), FALSE);}
 1813     break;
 1814 
 1815   case 60:
 1816 #line 380 "bc.y"
 1817     { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), FALSE); }
 1818     break;
 1819 
 1820   case 61:
 1821 #line 382 "bc.y"
 1822     { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
 1823                   warn ("Call by variable arrays");
 1824                 }
 1825     break;
 1826 
 1827   case 62:
 1828 #line 386 "bc.y"
 1829     { (yyval.a_value) = nextarg (NULL, lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
 1830                   warn ("Call by variable arrays");
 1831                 }
 1832     break;
 1833 
 1834   case 63:
 1835 #line 390 "bc.y"
 1836     { (yyval.a_value) = nextarg ((yyvsp[-2].a_value), lookup ((yyvsp[0].s_value),SIMPLE), FALSE); }
 1837     break;
 1838 
 1839   case 64:
 1840 #line 392 "bc.y"
 1841     { (yyval.a_value) = nextarg ((yyvsp[-4].a_value), lookup ((yyvsp[-2].s_value),ARRAY), FALSE); }
 1842     break;
 1843 
 1844   case 65:
 1845 #line 394 "bc.y"
 1846     { (yyval.a_value) = nextarg ((yyvsp[-5].a_value), lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
 1847                   warn ("Call by variable arrays");
 1848                 }
 1849     break;
 1850 
 1851   case 66:
 1852 #line 398 "bc.y"
 1853     { (yyval.a_value) = nextarg ((yyvsp[-5].a_value), lookup ((yyvsp[-2].s_value),ARRAY), TRUE);
 1854                   warn ("Call by variable arrays");
 1855                 }
 1856     break;
 1857 
 1858   case 67:
 1859 #line 403 "bc.y"
 1860     { (yyval.a_value) = NULL; }
 1861     break;
 1862 
 1863   case 69:
 1864 #line 407 "bc.y"
 1865     {
 1866                   if ((yyvsp[0].i_value) & EX_COMP)
 1867                 warn ("comparison in argument");
 1868                   if ((yyvsp[0].i_value) & EX_VOID)
 1869                 yyerror ("void argument");
 1870                   (yyval.a_value) = nextarg (NULL,0,FALSE);
 1871                 }
 1872     break;
 1873 
 1874   case 70:
 1875 #line 415 "bc.y"
 1876     {
 1877                   sprintf (genstr, "K%d:", -lookup ((yyvsp[-2].s_value),ARRAY));
 1878                   generate (genstr);
 1879                   (yyval.a_value) = nextarg (NULL,1,FALSE);
 1880                 }
 1881     break;
 1882 
 1883   case 71:
 1884 #line 421 "bc.y"
 1885     {
 1886                   if ((yyvsp[0].i_value) & EX_COMP)
 1887                 warn ("comparison in argument");
 1888                   if ((yyvsp[0].i_value) & EX_VOID)
 1889                 yyerror ("void argument");
 1890                   (yyval.a_value) = nextarg ((yyvsp[-2].a_value),0,FALSE);
 1891                 }
 1892     break;
 1893 
 1894   case 72:
 1895 #line 429 "bc.y"
 1896     {
 1897                   sprintf (genstr, "K%d:", -lookup ((yyvsp[-2].s_value),ARRAY));
 1898                   generate (genstr);
 1899                   (yyval.a_value) = nextarg ((yyvsp[-4].a_value),1,FALSE);
 1900                 }
 1901     break;
 1902 
 1903   case 73:
 1904 #line 446 "bc.y"
 1905     {
 1906                   (yyval.i_value) = EX_EMPTY;
 1907                   warn ("Missing expression in for statement");
 1908                 }
 1909     break;
 1910 
 1911   case 75:
 1912 #line 453 "bc.y"
 1913     {
 1914                   (yyval.i_value) = 0;
 1915                   generate ("0");
 1916                   if (cur_func == -1)
 1917                 yyerror("Return outside of a function.");
 1918                 }
 1919     break;
 1920 
 1921   case 76:
 1922 #line 460 "bc.y"
 1923     {
 1924                   if ((yyvsp[0].i_value) & EX_COMP)
 1925                 warn ("comparison in return expresion");
 1926                   if (!((yyvsp[0].i_value) & EX_PAREN))
 1927                 warn ("return expression requires parenthesis");
 1928                   if ((yyvsp[0].i_value) & EX_VOID)
 1929                 yyerror("return requires non-void expression");
 1930                   if (cur_func == -1)
 1931                 yyerror("Return outside of a function.");
 1932                   else if (functions[cur_func].f_void)
 1933                 yyerror("Return expression in a void function.");
 1934                 }
 1935     break;
 1936 
 1937   case 77:
 1938 #line 474 "bc.y"
 1939     {
 1940                   if ((yyvsp[0].c_value) != '=')
 1941                 {
 1942                   if ((yyvsp[-1].i_value) < 0)
 1943                     sprintf (genstr, "DL%d:", -(yyvsp[-1].i_value));
 1944                   else
 1945                     sprintf (genstr, "l%d:", (yyvsp[-1].i_value));
 1946                   generate (genstr);
 1947                 }
 1948                 }
 1949     break;
 1950 
 1951   case 78:
 1952 #line 485 "bc.y"
 1953     {
 1954                   if ((yyvsp[0].i_value) & EX_ASSGN)
 1955                 warn("comparison in assignment");
 1956                   if ((yyvsp[0].i_value) & EX_VOID)
 1957                 yyerror("Assignment of a void expression");
 1958                   if ((yyvsp[-2].c_value) != '=')
 1959                 {
 1960                   sprintf (genstr, "%c", (yyvsp[-2].c_value));
 1961                   generate (genstr);
 1962                 }
 1963                   if ((yyvsp[-3].i_value) < 0)
 1964                 sprintf (genstr, "S%d:", -(yyvsp[-3].i_value));
 1965                   else
 1966                 sprintf (genstr, "s%d:", (yyvsp[-3].i_value));
 1967                   generate (genstr);
 1968                   (yyval.i_value) = EX_ASSGN;
 1969                 }
 1970     break;
 1971 
 1972   case 79:
 1973 #line 503 "bc.y"
 1974     {
 1975                   warn("&& operator");
 1976                   (yyvsp[0].i_value) = next_label++;
 1977                   sprintf (genstr, "DZ%d:p", (yyvsp[0].i_value));
 1978                   generate (genstr);
 1979                 }
 1980     break;
 1981 
 1982   case 80:
 1983 #line 510 "bc.y"
 1984     {
 1985                   if (((yyvsp[-3].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 1986                 yyerror ("void expression with &&");
 1987                   sprintf (genstr, "DZ%d:p1N%d:", (yyvsp[-2].i_value), (yyvsp[-2].i_value));
 1988                   generate (genstr);
 1989                   (yyval.i_value) = ((yyvsp[-3].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 1990                 }
 1991     break;
 1992 
 1993   case 81:
 1994 #line 518 "bc.y"
 1995     {
 1996                   warn("|| operator");
 1997                   (yyvsp[0].i_value) = next_label++;
 1998                   sprintf (genstr, "B%d:", (yyvsp[0].i_value));
 1999                   generate (genstr);
 2000                 }
 2001     break;
 2002 
 2003   case 82:
 2004 #line 525 "bc.y"
 2005     {
 2006                   int tmplab;
 2007                   if (((yyvsp[-3].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2008                 yyerror ("void expression with ||");
 2009                   tmplab = next_label++;
 2010                   sprintf (genstr, "B%d:0J%d:N%d:1N%d:",
 2011                        (yyvsp[-2].i_value), tmplab, (yyvsp[-2].i_value), tmplab);
 2012                   generate (genstr);
 2013                   (yyval.i_value) = ((yyvsp[-3].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2014                 }
 2015     break;
 2016 
 2017   case 83:
 2018 #line 536 "bc.y"
 2019     {
 2020                   if ((yyvsp[0].i_value) & EX_VOID)
 2021                 yyerror ("void expression with !");
 2022                   (yyval.i_value) = (yyvsp[0].i_value) & ~EX_PAREN;
 2023                   warn("! operator");
 2024                   generate ("!");
 2025                 }
 2026     break;
 2027 
 2028   case 84:
 2029 #line 544 "bc.y"
 2030     {
 2031                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2032                 yyerror ("void expression with comparison");
 2033                   (yyval.i_value) = EX_REG | EX_COMP;
 2034                   switch (*((yyvsp[-1].s_value)))
 2035                 {
 2036                 case '=':
 2037                   generate ("=");
 2038                   break;
 2039 
 2040                 case '!':
 2041                   generate ("#");
 2042                   break;
 2043 
 2044                 case '<':
 2045                   if ((yyvsp[-1].s_value)[1] == '=')
 2046                     generate ("{");
 2047                   else
 2048                     generate ("<");
 2049                   break;
 2050 
 2051                 case '>':
 2052                   if ((yyvsp[-1].s_value)[1] == '=')
 2053                     generate ("}");
 2054                   else
 2055                     generate (">");
 2056                   break;
 2057                 }
 2058                 }
 2059     break;
 2060 
 2061   case 85:
 2062 #line 574 "bc.y"
 2063     {
 2064                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2065                 yyerror ("void expression with +");
 2066                   generate ("+");
 2067                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2068                 }
 2069     break;
 2070 
 2071   case 86:
 2072 #line 581 "bc.y"
 2073     {
 2074                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2075                 yyerror ("void expression with -");
 2076                   generate ("-");
 2077                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2078                 }
 2079     break;
 2080 
 2081   case 87:
 2082 #line 588 "bc.y"
 2083     {
 2084                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2085                 yyerror ("void expression with *");
 2086                   generate ("*");
 2087                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2088                 }
 2089     break;
 2090 
 2091   case 88:
 2092 #line 595 "bc.y"
 2093     {
 2094                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2095                 yyerror ("void expression with /");
 2096                   generate ("/");
 2097                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2098                 }
 2099     break;
 2100 
 2101   case 89:
 2102 #line 602 "bc.y"
 2103     {
 2104                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2105                 yyerror ("void expression with %");
 2106                   generate ("%");
 2107                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2108                 }
 2109     break;
 2110 
 2111   case 90:
 2112 #line 609 "bc.y"
 2113     {
 2114                   if (((yyvsp[-2].i_value) & EX_VOID) || ((yyvsp[0].i_value) & EX_VOID))
 2115                 yyerror ("void expression with ^");
 2116                   generate ("^");
 2117                   (yyval.i_value) = ((yyvsp[-2].i_value) | (yyvsp[0].i_value)) & ~EX_PAREN;
 2118                 }
 2119     break;
 2120 
 2121   case 91:
 2122 #line 616 "bc.y"
 2123     {
 2124                   if ((yyvsp[0].i_value) & EX_VOID)
 2125                 yyerror ("void expression with unary -");
 2126                   generate ("n");
 2127                   (yyval.i_value) = (yyvsp[0].i_value) & ~EX_PAREN;
 2128                 }
 2129     break;
 2130 
 2131   case 92:
 2132 #line 623 "bc.y"
 2133     {
 2134                   (yyval.i_value) = EX_REG;
 2135                   if ((yyvsp[0].i_value) < 0)
 2136                 sprintf (genstr, "L%d:", -(yyvsp[0].i_value));
 2137                   else
 2138                 sprintf (genstr, "l%d:", (yyvsp[0].i_value));
 2139                   generate (genstr);
 2140                 }
 2141     break;
 2142 
 2143   case 93:
 2144 #line 632 "bc.y"
 2145     {
 2146                   int len = strlen((yyvsp[0].s_value));
 2147                   (yyval.i_value) = EX_REG;
 2148                   if (len == 1 && *(yyvsp[0].s_value) == '0')
 2149                 generate ("0");
 2150                   else if (len == 1 && *(yyvsp[0].s_value) == '1')
 2151                 generate ("1");
 2152                   else
 2153                 {
 2154                   generate ("K");
 2155                   generate ((yyvsp[0].s_value));
 2156                   generate (":");
 2157                 }
 2158                   free ((yyvsp[0].s_value));
 2159                 }
 2160     break;
 2161 
 2162   case 94:
 2163 #line 648 "bc.y"
 2164     { 
 2165                   if ((yyvsp[-1].i_value) & EX_VOID)
 2166                 yyerror ("void expression in parenthesis");
 2167                   (yyval.i_value) = (yyvsp[-1].i_value) | EX_REG | EX_PAREN;
 2168                 }
 2169     break;
 2170 
 2171   case 95:
 2172 #line 654 "bc.y"
 2173     { int fn;
 2174                   fn = lookup ((yyvsp[-3].s_value),FUNCT);
 2175                   if (functions[fn].f_void)
 2176                 (yyval.i_value) = EX_VOID;
 2177                   else
 2178                 (yyval.i_value) = EX_REG;
 2179                   if ((yyvsp[-1].a_value) != NULL)
 2180                 { char *params = call_str ((yyvsp[-1].a_value));
 2181                   set_genstr_size (20 + strlen (params));
 2182                   sprintf (genstr, "C%d,%s:", fn, params);
 2183                   free_args ((yyvsp[-1].a_value));
 2184                 }
 2185                   else
 2186                 {
 2187                   sprintf (genstr, "C%d:", fn);
 2188                 }
 2189                   generate (genstr);
 2190                 }
 2191     break;
 2192 
 2193   case 96:
 2194 #line 673 "bc.y"
 2195     {
 2196                   (yyval.i_value) = EX_REG;
 2197                   if ((yyvsp[0].i_value) < 0)
 2198                 {
 2199                   if ((yyvsp[-1].c_value) == '+')
 2200                     sprintf (genstr, "DA%d:L%d:", -(yyvsp[0].i_value), -(yyvsp[0].i_value));
 2201                   else
 2202                     sprintf (genstr, "DM%d:L%d:", -(yyvsp[0].i_value), -(yyvsp[0].i_value));
 2203                 }
 2204                   else
 2205                 {
 2206                   if ((yyvsp[-1].c_value) == '+')
 2207                     sprintf (genstr, "i%d:l%d:", (yyvsp[0].i_value), (yyvsp[0].i_value));
 2208                   else
 2209                     sprintf (genstr, "d%d:l%d:", (yyvsp[0].i_value), (yyvsp[0].i_value));
 2210                 }
 2211                   generate (genstr);
 2212                 }
 2213     break;
 2214 
 2215   case 97:
 2216 #line 692 "bc.y"
 2217     {
 2218                   (yyval.i_value) = EX_REG;
 2219                   if ((yyvsp[-1].i_value) < 0)
 2220                 {
 2221                   sprintf (genstr, "DL%d:x", -(yyvsp[-1].i_value));
 2222                   generate (genstr); 
 2223                   if ((yyvsp[0].c_value) == '+')
 2224                     sprintf (genstr, "A%d:", -(yyvsp[-1].i_value));
 2225                   else
 2226                       sprintf (genstr, "M%d:", -(yyvsp[-1].i_value));
 2227                 }
 2228                   else
 2229                 {
 2230                   sprintf (genstr, "l%d:", (yyvsp[-1].i_value));
 2231                   generate (genstr);
 2232                   if ((yyvsp[0].c_value) == '+')
 2233                     sprintf (genstr, "i%d:", (yyvsp[-1].i_value));
 2234                   else
 2235                     sprintf (genstr, "d%d:", (yyvsp[-1].i_value));
 2236                 }
 2237                   generate (genstr);
 2238                 }
 2239     break;
 2240 
 2241   case 98:
 2242 #line 715 "bc.y"
 2243     {
 2244                   if ((yyvsp[-1].i_value) & EX_VOID)
 2245                 yyerror ("void expression in length()");
 2246                   generate ("cL");
 2247                   (yyval.i_value) = EX_REG;
 2248                 }
 2249     break;
 2250 
 2251   case 99:
 2252 #line 722 "bc.y"
 2253     {
 2254                   if ((yyvsp[-1].i_value) & EX_VOID)
 2255                 yyerror ("void expression in sqrt()");
 2256                   generate ("cR");
 2257                   (yyval.i_value) = EX_REG;
 2258                 }
 2259     break;
 2260 
 2261   case 100:
 2262 #line 729 "bc.y"
 2263     {
 2264                   if ((yyvsp[-1].i_value) & EX_VOID)
 2265                 yyerror ("void expression in scale()");
 2266                   generate ("cS");
 2267                   (yyval.i_value) = EX_REG;
 2268                 }
 2269     break;
 2270 
 2271   case 101:
 2272 #line 736 "bc.y"
 2273     {
 2274                   warn ("read function");
 2275                   generate ("cI");
 2276                   (yyval.i_value) = EX_REG;
 2277                 }
 2278     break;
 2279 
 2280   case 102:
 2281 #line 742 "bc.y"
 2282     {
 2283                   warn ("random function");
 2284                   generate ("cX");
 2285                   (yyval.i_value) = EX_REG;
 2286                 }
 2287     break;
 2288 
 2289   case 103:
 2290 #line 749 "bc.y"
 2291     { (yyval.i_value) = lookup((yyvsp[0].s_value),SIMPLE); }
 2292     break;
 2293 
 2294   case 104:
 2295 #line 751 "bc.y"
 2296     {
 2297                   if ((yyvsp[-1].i_value) & EX_VOID)
 2298                 yyerror("void expression as subscript");
 2299                   if ((yyvsp[-1].i_value) & EX_COMP)
 2300                 warn("comparison in subscript");
 2301                   (yyval.i_value) = lookup((yyvsp[-3].s_value),ARRAY);
 2302                 }
 2303     break;
 2304 
 2305   case 105:
 2306 #line 759 "bc.y"
 2307     { (yyval.i_value) = 0; }
 2308     break;
 2309 
 2310   case 106:
 2311 #line 761 "bc.y"
 2312     { (yyval.i_value) = 1; }
 2313     break;
 2314 
 2315   case 107:
 2316 #line 763 "bc.y"
 2317     { (yyval.i_value) = 2; }
 2318     break;
 2319 
 2320   case 108:
 2321 #line 765 "bc.y"
 2322     { (yyval.i_value) = 3;
 2323                   warn ("History variable");
 2324                 }
 2325     break;
 2326 
 2327   case 109:
 2328 #line 769 "bc.y"
 2329     { (yyval.i_value) = 4;
 2330                   warn ("Last variable");
 2331                 }
 2332     break;
 2333 
 2334   case 110:
 2335 #line 775 "bc.y"
 2336     { warn ("End of line required"); }
 2337     break;
 2338 
 2339   case 112:
 2340 #line 778 "bc.y"
 2341     { warn ("Too many end of lines"); }
 2342     break;
 2343 
 2344 
 2345       default: break;
 2346     }
 2347 
 2348 /* Line 1126 of yacc.c.  */
 2349 #line 2350 "bc.c"
 2350 
 2351   yyvsp -= yylen;
 2352   yyssp -= yylen;
 2353 
 2354 
 2355   YY_STACK_PRINT (yyss, yyssp);
 2356 
 2357   *++yyvsp = yyval;
 2358 
 2359 
 2360   /* Now `shift' the result of the reduction.  Determine what state
 2361      that goes to, based on the state we popped back to and the rule
 2362      number reduced by.  */
 2363 
 2364   yyn = yyr1[yyn];
 2365 
 2366   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
 2367   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 2368     yystate = yytable[yystate];
 2369   else
 2370     yystate = yydefgoto[yyn - YYNTOKENS];
 2371 
 2372   goto yynewstate;
 2373 
 2374 
 2375 /*------------------------------------.
 2376 | yyerrlab -- here on detecting error |
 2377 `------------------------------------*/
 2378 yyerrlab:
 2379   /* If not already recovering from an error, report this error.  */
 2380   if (!yyerrstatus)
 2381     {
 2382       ++yynerrs;
 2383 #if YYERROR_VERBOSE
 2384       yyn = yypact[yystate];
 2385 
 2386       if (YYPACT_NINF < yyn && yyn < YYLAST)
 2387     {
 2388       int yytype = YYTRANSLATE (yychar);
 2389       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
 2390       YYSIZE_T yysize = yysize0;
 2391       YYSIZE_T yysize1;
 2392       int yysize_overflow = 0;
 2393       char *yymsg = 0;
 2394 #     define YYERROR_VERBOSE_ARGS_MAXIMUM 5
 2395       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 2396       int yyx;
 2397 
 2398 #if 0
 2399       /* This is so xgettext sees the translatable formats that are
 2400          constructed on the fly.  */
 2401       YY_("syntax error, unexpected %s");
 2402       YY_("syntax error, unexpected %s, expecting %s");
 2403       YY_("syntax error, unexpected %s, expecting %s or %s");
 2404       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
 2405       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
 2406 #endif
 2407       char *yyfmt;
 2408       char const *yyf;
 2409       static char const yyunexpected[] = "syntax error, unexpected %s";
 2410       static char const yyexpecting[] = ", expecting %s";
 2411       static char const yyor[] = " or %s";
 2412       char yyformat[sizeof yyunexpected
 2413             + sizeof yyexpecting - 1
 2414             + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
 2415                * (sizeof yyor - 1))];
 2416       char const *yyprefix = yyexpecting;
 2417 
 2418       /* Start YYX at -YYN if negative to avoid negative indexes in
 2419          YYCHECK.  */
 2420       int yyxbegin = yyn < 0 ? -yyn : 0;
 2421 
 2422       /* Stay within bounds of both yycheck and yytname.  */
 2423       int yychecklim = YYLAST - yyn;
 2424       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 2425       int yycount = 1;
 2426 
 2427       yyarg[0] = yytname[yytype];
 2428       yyfmt = yystpcpy (yyformat, yyunexpected);
 2429 
 2430       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 2431         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 2432           {
 2433         if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 2434           {
 2435             yycount = 1;
 2436             yysize = yysize0;
 2437             yyformat[sizeof yyunexpected - 1] = '\0';
 2438             break;
 2439           }
 2440         yyarg[yycount++] = yytname[yyx];
 2441         yysize1 = yysize + yytnamerr (0, yytname[yyx]);
 2442         yysize_overflow |= yysize1 < yysize;
 2443         yysize = yysize1;
 2444         yyfmt = yystpcpy (yyfmt, yyprefix);
 2445         yyprefix = yyor;
 2446           }
 2447 
 2448       yyf = YY_(yyformat);
 2449       yysize1 = yysize + yystrlen (yyf);
 2450       yysize_overflow |= yysize1 < yysize;
 2451       yysize = yysize1;
 2452 
 2453       if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
 2454         yymsg = (char *) YYSTACK_ALLOC (yysize);
 2455       if (yymsg)
 2456         {
 2457           /* Avoid sprintf, as that infringes on the user's name space.
 2458          Don't have undefined behavior even if the translation
 2459          produced a string with the wrong number of "%s"s.  */
 2460           char *yyp = yymsg;
 2461           int yyi = 0;
 2462           while ((*yyp = *yyf))
 2463         {
 2464           if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
 2465             {
 2466               yyp += yytnamerr (yyp, yyarg[yyi++]);
 2467               yyf += 2;
 2468             }
 2469           else
 2470             {
 2471               yyp++;
 2472               yyf++;
 2473             }
 2474         }
 2475           yyerror (yymsg);
 2476           YYSTACK_FREE (yymsg);
 2477         }
 2478       else
 2479         {
 2480           yyerror (YY_("syntax error"));
 2481           goto yyexhaustedlab;
 2482         }
 2483     }
 2484       else
 2485 #endif /* YYERROR_VERBOSE */
 2486     yyerror (YY_("syntax error"));
 2487     }
 2488 
 2489 
 2490 
 2491   if (yyerrstatus == 3)
 2492     {
 2493       /* If just tried and failed to reuse look-ahead token after an
 2494      error, discard it.  */
 2495 
 2496       if (yychar <= YYEOF)
 2497         {
 2498       /* Return failure if at end of input.  */
 2499       if (yychar == YYEOF)
 2500         YYABORT;
 2501         }
 2502       else
 2503     {
 2504       yydestruct ("Error: discarding", yytoken, &yylval);
 2505       yychar = YYEMPTY;
 2506     }
 2507     }
 2508 
 2509   /* Else will try to reuse look-ahead token after shifting the error
 2510      token.  */
 2511   goto yyerrlab1;
 2512 
 2513 
 2514 /*---------------------------------------------------.
 2515 | yyerrorlab -- error raised explicitly by YYERROR.  |
 2516 `---------------------------------------------------*/
 2517 yyerrorlab:
 2518 
 2519   /* Pacify compilers like GCC when the user code never invokes
 2520      YYERROR and the label yyerrorlab therefore never appears in user
 2521      code.  */
 2522   if (0)
 2523      goto yyerrorlab;
 2524 
 2525 yyvsp -= yylen;
 2526   yyssp -= yylen;
 2527   yystate = *yyssp;
 2528   goto yyerrlab1;
 2529 
 2530 
 2531 /*-------------------------------------------------------------.
 2532 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 2533 `-------------------------------------------------------------*/
 2534 yyerrlab1:
 2535   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
 2536 
 2537   for (;;)
 2538     {
 2539       yyn = yypact[yystate];
 2540       if (yyn != YYPACT_NINF)
 2541     {
 2542       yyn += YYTERROR;
 2543       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 2544         {
 2545           yyn = yytable[yyn];
 2546           if (0 < yyn)
 2547         break;
 2548         }
 2549     }
 2550 
 2551       /* Pop the current state because it cannot handle the error token.  */
 2552       if (yyssp == yyss)
 2553     YYABORT;
 2554 
 2555 
 2556       yydestruct ("Error: popping", yystos[yystate], yyvsp);
 2557       YYPOPSTACK;
 2558       yystate = *yyssp;
 2559       YY_STACK_PRINT (yyss, yyssp);
 2560     }
 2561 
 2562   if (yyn == YYFINAL)
 2563     YYACCEPT;
 2564 
 2565   *++yyvsp = yylval;
 2566 
 2567 
 2568   /* Shift the error token. */
 2569   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 2570 
 2571   yystate = yyn;
 2572   goto yynewstate;
 2573 
 2574 
 2575 /*-------------------------------------.
 2576 | yyacceptlab -- YYACCEPT comes here.  |
 2577 `-------------------------------------*/
 2578 yyacceptlab:
 2579   yyresult = 0;
 2580   goto yyreturn;
 2581 
 2582 /*-----------------------------------.
 2583 | yyabortlab -- YYABORT comes here.  |
 2584 `-----------------------------------*/
 2585 yyabortlab:
 2586   yyresult = 1;
 2587   goto yyreturn;
 2588 
 2589 #ifndef yyoverflow
 2590 /*-------------------------------------------------.
 2591 | yyexhaustedlab -- memory exhaustion comes here.  |
 2592 `-------------------------------------------------*/
 2593 yyexhaustedlab:
 2594   yyerror (YY_("memory exhausted"));
 2595   yyresult = 2;
 2596   /* Fall through.  */
 2597 #endif
 2598 
 2599 yyreturn:
 2600   if (yychar != YYEOF && yychar != YYEMPTY)
 2601      yydestruct ("Cleanup: discarding lookahead",
 2602          yytoken, &yylval);
 2603   while (yyssp != yyss)
 2604     {
 2605       yydestruct ("Cleanup: popping",
 2606           yystos[*yyssp], yyvsp);
 2607       YYPOPSTACK;
 2608     }
 2609 #ifndef yyoverflow
 2610   if (yyss != yyssa)
 2611     YYSTACK_FREE (yyss);
 2612 #endif
 2613   return yyresult;
 2614 }
 2615 
 2616 
 2617 #line 781 "bc.y"
 2618 
 2619 
 2620