contrib/byacc/test/btyacc/quote_calc4-s.tab.c

   1 /* original parser id follows */
   2 /* yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93" */
   3 /* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8 #define YYCHECK "yyyymmdd"
   9
  10 #define YYEMPTY        (-1)
  11 #define yyclearin      (yychar = YYEMPTY)
  12 #define yyerrok        (yyerrflag = 0)
  13 #define YYRECOVERING() (yyerrflag != 0)
  14 #define YYENOMEM       (-2)
  15 #define YYEOF          0
  16 #undef YYBTYACC
  17 #define YYBTYACC 0
  18 #define YYDEBUGSTR YYPREFIX "debug"
  19
  20 #ifndef yyparse
  21 #define yyparse    quote_calc4_parse
  22 #endif /* yyparse */
  23
  24 #ifndef yylex
  25 #define yylex      quote_calc4_lex
  26 #endif /* yylex */
  27
  28 #ifndef yyerror
  29 #define yyerror    quote_calc4_error
  30 #endif /* yyerror */
  31
  32 #ifndef yychar
  33 #define yychar     quote_calc4_char
  34 #endif /* yychar */
  35
  36 #ifndef yyval
  37 #define yyval      quote_calc4_val
  38 #endif /* yyval */
  39
  40 #ifndef yylval
  41 #define yylval     quote_calc4_lval
  42 #endif /* yylval */
  43
  44 #ifndef yydebug
  45 #define yydebug    quote_calc4_debug
  46 #endif /* yydebug */
  47
  48 #ifndef yynerrs
  49 #define yynerrs    quote_calc4_nerrs
  50 #endif /* yynerrs */
  51
  52 #ifndef yyerrflag
  53 #define yyerrflag  quote_calc4_errflag
  54 #endif /* yyerrflag */
  55
  56 #ifndef yylhs
  57 #define yylhs      quote_calc4_lhs
  58 #endif /* yylhs */
  59
  60 #ifndef yylen
  61 #define yylen      quote_calc4_len
  62 #endif /* yylen */
  63
  64 #ifndef yydefred
  65 #define yydefred   quote_calc4_defred
  66 #endif /* yydefred */
  67
  68 #ifndef yystos
  69 #define yystos     quote_calc4_stos
  70 #endif /* yystos */
  71
  72 #ifndef yydgoto
  73 #define yydgoto    quote_calc4_dgoto
  74 #endif /* yydgoto */
  75
  76 #ifndef yysindex
  77 #define yysindex   quote_calc4_sindex
  78 #endif /* yysindex */
  79
  80 #ifndef yyrindex
  81 #define yyrindex   quote_calc4_rindex
  82 #endif /* yyrindex */
  83
  84 #ifndef yygindex
  85 #define yygindex   quote_calc4_gindex
  86 #endif /* yygindex */
  87
  88 #ifndef yytable
  89 #define yytable    quote_calc4_table
  90 #endif /* yytable */
  91
  92 #ifndef yycheck
  93 #define yycheck    quote_calc4_check
  94 #endif /* yycheck */
  95
  96 #ifndef yyname
  97 #define yyname     quote_calc4_name
  98 #endif /* yyname */
  99
 100 #ifndef yyrule
 101 #define yyrule     quote_calc4_rule
 102 #endif /* yyrule */
 103
 104 #if YYBTYACC
 105
 106 #ifndef yycindex
 107 #define yycindex   quote_calc4_cindex
 108 #endif /* yycindex */
 109
 110 #ifndef yyctable
 111 #define yyctable   quote_calc4_ctable
 112 #endif /* yyctable */
 113
 114 #endif /* YYBTYACC */
 115
 116 #define YYPREFIX "quote_calc4_"
 117
 118 #define YYPURE 0
 119
 120 #line 2 "quote_calc4.y"
 121 # include <stdio.h>
 122 # include <ctype.h>
 123
 124 int regs[26];
 125 int base;
 126
 127 int yylex(void);
 128 static void yyerror(const char *s);
 129
 130 #line 131 "quote_calc4-s.tab.c"
 131
 132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
 133 /* Default: YYSTYPE is the semantic value type. */
 134 typedef int YYSTYPE;
 135 # define YYSTYPE_IS_DECLARED 1
 136 #endif
 137
 138 /* compatibility with bison */
 139 #ifdef YYPARSE_PARAM
 140 /* compatibility with FreeBSD */
 141 # ifdef YYPARSE_PARAM_TYPE
 142 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 143 # else
 144 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 145 # endif
 146 #else
 147 # define YYPARSE_DECL() yyparse(void)
 148 #endif
 149
 150 /* Parameters sent to lex. */
 151 #ifdef YYLEX_PARAM
 152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 153 # define YYLEX yylex(YYLEX_PARAM)
 154 #else
 155 # define YYLEX_DECL() yylex(void)
 156 # define YYLEX yylex()
 157 #endif
 158
 159 /* Parameters sent to yyerror. */
 160 #ifndef YYERROR_DECL
 161 #define YYERROR_DECL() yyerror(const char *s)
 162 #endif
 163 #ifndef YYERROR_CALL
 164 #define YYERROR_CALL(msg) yyerror(msg)
 165 #endif
 166
 167 extern int YYPARSE_DECL();
 168
 169 #define OP_ADD 257
 170 #define OP_SUB 259
 171 #define OP_MUL 261
 172 #define OP_DIV 263
 173 #define OP_MOD 265
 174 #define OP_AND 267
 175 #define DIGIT 269
 176 #define LETTER 270
 177 #define UMINUS 271
 178 #define YYERRCODE 256
 179 typedef short YYINT;
 180 static const YYINT quote_calc4_lhs[] = {                 -1,
 181     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 182     2,    2,    2,    2,    2,    2,    3,    3,
 183 };
 184 static const YYINT quote_calc4_len[] = {                  2,
 185     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 186     3,    3,    3,    2,    1,    1,    1,    2,
 187 };
 188 static const YYINT quote_calc4_defred[] = {               1,
 189     0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
 190    15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
 191     0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
 192     0,    0,
 193 };
 194 static const YYINT quote_calc4_stos[] = {                 0,
 195   273,  256,  260,  269,  270,   40,  274,  275,  276,   10,
 196   270,  275,   61,  275,   10,  258,  260,  262,  264,  266,
 197   268,  124,  269,  275,   41,  275,  275,  275,  275,  275,
 198   275,  275,
 199 };
 200 static const YYINT quote_calc4_dgoto[] = {                1,
 201     7,    8,    9,
 202 };
 203 static const YYINT quote_calc4_sindex[] = {               0,
 204   -38,    4,  -36,    0,  -51,  -36,    6, -121, -249,    0,
 205     0, -243,  -36,  -23,    0,  -36,  -36,  -36,  -36,  -36,
 206   -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
 207  -121, -243,
 208 };
 209 static const YYINT quote_calc4_rindex[] = {               0,
 210     0,    0,    0,    0,   -9,    0,    0,   12,  -10,    0,
 211     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,    0,    0,   14,    0,   -3,   -2,   -1,    1,    2,
 213     3,   -4,
 214 };
 215 #if YYBTYACC
 216 static const YYINT quote_calc4_cindex[] = {               0,
 217     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 218     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 219     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 220     0,    0,
 221 };
 222 #endif
 223 static const YYINT quote_calc4_gindex[] = {               0,
 224     0,   42,    0,
 225 };
 226 #define YYTABLESIZE 259
 227 static const YYINT quote_calc4_table[] = {               16,
 228    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 229    10,   11,   12,   10,   16,   15,   17,   25,   18,   23,
 230    19,    4,   20,    5,   21,    0,    0,    0,    0,    0,
 231    16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
 232     0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
 233     0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
 234    29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
 235     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 236     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 237     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 238    22,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 239     0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
 240     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 241     0,    0,    0,    0,    0,    0,   16,    0,   17,    0,
 242    18,    0,   19,    0,   20,    0,   21,    0,    0,    0,
 243     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 244     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 245     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 246     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 247     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 248     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 249     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 250     0,    3,    0,    3,    0,    0,    0,    0,    0,    0,
 251     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 252    19,    0,   20,    0,   21,    0,    0,   16,   15,   16,
 253    15,   16,   15,   16,   15,   16,   15,   16,   15,
 254 };
 255 static const YYINT quote_calc4_check[] = {               10,
 256    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 257    10,   10,   10,   10,  258,   10,  260,   41,  262,  269,
 258   264,   10,  266,   10,  268,   -1,   -1,   -1,   -1,   -1,
 259    41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
 260    -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
 261    -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
 262    19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
 263    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 264    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 265    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 266   124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 267    -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
 268    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 269    -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,  260,   -1,
 270   262,   -1,  264,   -1,  266,   -1,  268,   -1,   -1,   -1,
 271    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 272    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 273    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 274    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 275    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 276    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 277    -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
 278    -1,  260,   -1,  260,   -1,   -1,   -1,   -1,   -1,   -1,
 279   269,  270,  269,  270,  258,   -1,  260,   -1,  262,   -1,
 280   264,   -1,  266,   -1,  268,   -1,   -1,  258,  258,  260,
 281   260,  262,  262,  264,  264,  266,  266,  268,  268,
 282 };
 283 #if YYBTYACC
 284 static const YYINT quote_calc4_ctable[] = {              -1,
 285    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 286    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 287    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 288    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 289    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 290    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 291    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 292    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 293    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 294    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 295    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 296    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 297    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 298    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 299    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 300    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 301    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 302    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 303    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 304    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 305    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 306    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 307    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 308    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 309    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 310    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 311 };
 312 #endif
 313 #define YYFINAL 1
 314 #ifndef YYDEBUG
 315 #define YYDEBUG 0
 316 #endif
 317 #define YYMAXTOKEN 271
 318 #define YYUNDFTOKEN 277
 319 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 320 #if YYDEBUG
 321 static const char *const quote_calc4_name[] = {
 322
 323 "$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 324 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
 325 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 326 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
 327 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 330 0,0,"error","OP_ADD","\"ADD-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
 331 "\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
 332 "OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS","$accept","list","stat",
 333 "expr","number","illegal-symbol",
 334 };
 335 static const char *const quote_calc4_rule[] = {
 336 "$accept : list",
 337 "list :",
 338 "list : list stat '\\n'",
 339 "list : list error '\\n'",
 340 "stat : expr",
 341 "stat : LETTER '=' expr",
 342 "expr : '(' expr ')'",
 343 "expr : expr \"ADD-operator\" expr",
 344 "expr : expr \"SUB-operator\" expr",
 345 "expr : expr \"MUL-operator\" expr",
 346 "expr : expr \"DIV-operator\" expr",
 347 "expr : expr \"MOD-operator\" expr",
 348 "expr : expr \"AND-operator\" expr",
 349 "expr : expr '|' expr",
 350 "expr : \"SUB-operator\" expr",
 351 "expr : LETTER",
 352 "expr : number",
 353 "number : DIGIT",
 354 "number : number DIGIT",
 355
 356 };
 357 #endif
 358
 359 int      yydebug;
 360 int      yynerrs;
 361
 362 int      yyerrflag;
 363 int      yychar;
 364 YYSTYPE  yyval;
 365 YYSTYPE  yylval;
 366 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 367 YYLTYPE  yyloc; /* position returned by actions */
 368 YYLTYPE  yylloc; /* position from the lexer */
 369 #endif
 370
 371 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 372 #ifndef YYLLOC_DEFAULT
 373 #define YYLLOC_DEFAULT(loc, rhs, n) \
 374 do \
 375 { \
 376     if (n == 0) \
 377     { \
 378         (loc).first_line   = ((rhs)[-1]).last_line; \
 379         (loc).first_column = ((rhs)[-1]).last_column; \
 380         (loc).last_line    = ((rhs)[-1]).last_line; \
 381         (loc).last_column  = ((rhs)[-1]).last_column; \
 382     } \
 383     else \
 384     { \
 385         (loc).first_line   = ((rhs)[ 0 ]).first_line; \
 386         (loc).first_column = ((rhs)[ 0 ]).first_column; \
 387         (loc).last_line    = ((rhs)[n-1]).last_line; \
 388         (loc).last_column  = ((rhs)[n-1]).last_column; \
 389     } \
 390 } while (0)
 391 #endif /* YYLLOC_DEFAULT */
 392 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
 393 #if YYBTYACC
 394
 395 #ifndef YYLVQUEUEGROWTH
 396 #define YYLVQUEUEGROWTH 32
 397 #endif
 398 #endif /* YYBTYACC */
 399
 400 /* define the initial stack-sizes */
 401 #ifdef YYSTACKSIZE
 402 #undef YYMAXDEPTH
 403 #define YYMAXDEPTH  YYSTACKSIZE
 404 #else
 405 #ifdef YYMAXDEPTH
 406 #define YYSTACKSIZE YYMAXDEPTH
 407 #else
 408 #define YYSTACKSIZE 10000
 409 #define YYMAXDEPTH  10000
 410 #endif
 411 #endif
 412
 413 #ifndef YYINITSTACKSIZE
 414 #define YYINITSTACKSIZE 200
 415 #endif
 416
 417 typedef struct {
 418     unsigned stacksize;
 419     short    *s_base;
 420     short    *s_mark;
 421     short    *s_last;
 422     YYSTYPE  *l_base;
 423     YYSTYPE  *l_mark;
 424 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 425     YYLTYPE  *p_base;
 426     YYLTYPE  *p_mark;
 427 #endif
 428 } YYSTACKDATA;
 429 #if YYBTYACC
 430
 431 struct YYParseState_s
 432 {
 433     struct YYParseState_s *save;    /* Previously saved parser state */
 434     YYSTACKDATA            yystack; /* saved parser stack */
 435     int                    state;   /* saved parser state */
 436     int                    errflag; /* saved error recovery status */
 437     int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
 438     YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
 439 };
 440 typedef struct YYParseState_s YYParseState;
 441 #endif /* YYBTYACC */
 442 /* variables for the parser stack */
 443 static YYSTACKDATA yystack;
 444 #if YYBTYACC
 445
 446 /* Current parser state */
 447 static YYParseState *yyps = 0;
 448
 449 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
 450 static YYParseState *yypath = 0;
 451
 452 /* Base of the lexical value queue */
 453 static YYSTYPE *yylvals = 0;
 454
 455 /* Current position at lexical value queue */
 456 static YYSTYPE *yylvp = 0;
 457
 458 /* End position of lexical value queue */
 459 static YYSTYPE *yylve = 0;
 460
 461 /* The last allocated position at the lexical value queue */
 462 static YYSTYPE *yylvlim = 0;
 463
 464 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 465 /* Base of the lexical position queue */
 466 static YYLTYPE *yylpsns = 0;
 467
 468 /* Current position at lexical position queue */
 469 static YYLTYPE *yylpp = 0;
 470
 471 /* End position of lexical position queue */
 472 static YYLTYPE *yylpe = 0;
 473
 474 /* The last allocated position at the lexical position queue */
 475 static YYLTYPE *yylplim = 0;
 476 #endif
 477
 478 /* Current position at lexical token queue */
 479 static short  *yylexp = 0;
 480
 481 static short  *yylexemes = 0;
 482 #endif /* YYBTYACC */
 483 #line 73 "quote_calc4.y"
 484  /* start of programs */
 485
 486 int
 487 main (void)
 488 {
 489     while(!feof(stdin)) {
 490         yyparse();
 491     }
 492     return 0;
 493 }
 494
 495 static void
 496 yyerror(const char *s)
 497 {
 498     fprintf(stderr, "%s\n", s);
 499 }
 500
 501 int
 502 yylex(void) {
 503         /* lexical analysis routine */
 504         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 505         /* return DIGIT for a digit, yylval = 0 through 9 */
 506         /* all other characters are returned immediately */
 507
 508     int c;
 509
 510     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 511
 512     /* c is now nonblank */
 513
 514     if( islower( c )) {
 515         yylval = c - 'a';
 516         return ( LETTER );
 517     }
 518     if( isdigit( c )) {
 519         yylval = c - '0';
 520         return ( DIGIT );
 521     }
 522     return( c );
 523 }
 524 #line 525 "quote_calc4-s.tab.c"
 525
 526 /* For use in generated program */
 527 #define yydepth (int)(yystack.s_mark - yystack.s_base)
 528 #if YYBTYACC
 529 #define yytrial (yyps->save)
 530 #endif /* YYBTYACC */
 531
 532 #if YYDEBUG
 533 #include <stdio.h>         /* needed for printf */
 534 #endif
 535
 536 #include <stdlib.h>        /* needed for malloc, etc */
 537 #include <string.h>        /* needed for memset */
 538
 539 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 540 static int yygrowstack(YYSTACKDATA *data)
 541 {
 542     int i;
 543     unsigned newsize;
 544     short *newss;
 545     YYSTYPE *newvs;
 546 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 547     YYLTYPE *newps;
 548 #endif
 549
 550     if ((newsize = data->stacksize) == 0)
 551         newsize = YYINITSTACKSIZE;
 552     else if (newsize >= YYMAXDEPTH)
 553         return YYENOMEM;
 554     else if ((newsize *= 2) > YYMAXDEPTH)
 555         newsize = YYMAXDEPTH;
 556
 557     i = (int) (data->s_mark - data->s_base);
 558     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 559     if (newss == 0)
 560         return YYENOMEM;
 561
 562     data->s_base = newss;
 563     data->s_mark = newss + i;
 564
 565     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 566     if (newvs == 0)
 567         return YYENOMEM;
 568
 569     data->l_base = newvs;
 570     data->l_mark = newvs + i;
 571
 572 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 573     newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
 574     if (newps == 0)
 575         return YYENOMEM;
 576
 577     data->p_base = newps;
 578     data->p_mark = newps + i;
 579 #endif
 580
 581     data->stacksize = newsize;
 582     data->s_last = data->s_base + newsize - 1;
 583
 584 #if YYDEBUG
 585     if (yydebug)
 586         fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
 587 #endif
 588     return 0;
 589 }
 590
 591 #if YYPURE || defined(YY_NO_LEAKS)
 592 static void yyfreestack(YYSTACKDATA *data)
 593 {
 594     free(data->s_base);
 595     free(data->l_base);
 596 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 597     free(data->p_base);
 598 #endif
 599     memset(data, 0, sizeof(*data));
 600 }
 601 #else
 602 #define yyfreestack(data) /* nothing */
 603 #endif /* YYPURE || defined(YY_NO_LEAKS) */
 604 #if YYBTYACC
 605
 606 static YYParseState *
 607 yyNewState(unsigned size)
 608 {
 609     YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
 610     if (p == NULL) return NULL;
 611
 612     p->yystack.stacksize = size;
 613     if (size == 0)
 614     {
 615         p->yystack.s_base = NULL;
 616         p->yystack.l_base = NULL;
 617 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 618         p->yystack.p_base = NULL;
 619 #endif
 620         return p;
 621     }
 622     p->yystack.s_base    = (short *) malloc(size * sizeof(short));
 623     if (p->yystack.s_base == NULL) return NULL;
 624     p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
 625     if (p->yystack.l_base == NULL) return NULL;
 626     memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
 627 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 628     p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
 629     if (p->yystack.p_base == NULL) return NULL;
 630     memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
 631 #endif
 632
 633     return p;
 634 }
 635
 636 static void
 637 yyFreeState(YYParseState *p)
 638 {
 639     yyfreestack(&p->yystack);
 640     free(p);
 641 }
 642 #endif /* YYBTYACC */
 643
 644 #define YYABORT  goto yyabort
 645 #define YYREJECT goto yyabort
 646 #define YYACCEPT goto yyaccept
 647 #define YYERROR  goto yyerrlab
 648 #if YYBTYACC
 649 #define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
 650 #define YYVALID_NESTED do { if (yyps->save && \
 651                                 yyps->save->save == 0) goto yyvalid; } while(0)
 652 #endif /* YYBTYACC */
 653
 654 int
 655 YYPARSE_DECL()
 656 {
 657     int yym, yyn, yystate, yyresult;
 658 #if YYBTYACC
 659     int yynewerrflag;
 660     YYParseState *yyerrctx = NULL;
 661 #endif /* YYBTYACC */
 662 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 663     YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
 664 #endif
 665 #if YYDEBUG
 666     const char *yys;
 667
 668     if ((yys = getenv("YYDEBUG")) != 0)
 669     {
 670         yyn = *yys;
 671         if (yyn >= '0' && yyn <= '9')
 672             yydebug = yyn - '0';
 673     }
 674     if (yydebug)
 675         fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
 676 #endif
 677
 678 #if YYBTYACC
 679     yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
 680     yyps->save = 0;
 681 #endif /* YYBTYACC */
 682     yynerrs = 0;
 683     yyerrflag = 0;
 684     yychar = YYEMPTY;
 685     yystate = 0;
 686
 687 #if YYPURE
 688     memset(&yystack, 0, sizeof(yystack));
 689 #endif
 690
 691     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 692     yystack.s_mark = yystack.s_base;
 693     yystack.l_mark = yystack.l_base;
 694 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 695     yystack.p_mark = yystack.p_base;
 696 #endif
 697     yystate = 0;
 698     *yystack.s_mark = 0;
 699
 700 yyloop:
 701     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 702     if (yychar < 0)
 703     {
 704 #if YYBTYACC
 705         do {
 706         if (yylvp < yylve)
 707         {
 708             /* we're currently re-reading tokens */
 709             yylval = *yylvp++;
 710 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 711             yylloc = *yylpp++;
 712 #endif
 713             yychar = *yylexp++;
 714             break;
 715         }
 716         if (yyps->save)
 717         {
 718             /* in trial mode; save scanner results for future parse attempts */
 719             if (yylvp == yylvlim)
 720             {   /* Enlarge lexical value queue */
 721                 size_t p = (size_t) (yylvp - yylvals);
 722                 size_t s = (size_t) (yylvlim - yylvals);
 723
 724                 s += YYLVQUEUEGROWTH;
 725                 if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
 726                 if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
 727 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 728                 if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
 729 #endif
 730                 yylvp   = yylve = yylvals + p;
 731                 yylvlim = yylvals + s;
 732 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 733                 yylpp   = yylpe = yylpsns + p;
 734                 yylplim = yylpsns + s;
 735 #endif
 736                 yylexp  = yylexemes + p;
 737             }
 738             *yylexp = (short) YYLEX;
 739             *yylvp++ = yylval;
 740             yylve++;
 741 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 742             *yylpp++ = yylloc;
 743             yylpe++;
 744 #endif
 745             yychar = *yylexp++;
 746             break;
 747         }
 748         /* normal operation, no conflict encountered */
 749 #endif /* YYBTYACC */
 750         yychar = YYLEX;
 751 #if YYBTYACC
 752         } while (0);
 753 #endif /* YYBTYACC */
 754         if (yychar < 0) yychar = YYEOF;
 755         /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
 756 #if YYDEBUG
 757         if (yydebug)
 758         {
 759             yys = yyname[YYTRANSLATE(yychar)];
 760             fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
 761                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
 762 #ifdef YYSTYPE_TOSTRING
 763 #if YYBTYACC
 764             if (!yytrial)
 765 #endif /* YYBTYACC */
 766                 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
 767 #endif
 768             fputc('\n', stderr);
 769         }
 770 #endif
 771     }
 772 #if YYBTYACC
 773
 774     /* Do we have a conflict? */
 775     if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 776         yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 777     {
 778         YYINT ctry;
 779
 780         if (yypath)
 781         {
 782             YYParseState *save;
 783 #if YYDEBUG
 784             if (yydebug)
 785                 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
 786                                 YYDEBUGSTR, yydepth, yystate);
 787 #endif
 788             /* Switch to the next conflict context */
 789             save = yypath;
 790             yypath = save->save;
 791             save->save = NULL;
 792             ctry = save->ctry;
 793             if (save->state != yystate) YYABORT;
 794             yyFreeState(save);
 795
 796         }
 797         else
 798         {
 799
 800             /* Unresolved conflict - start/continue trial parse */
 801             YYParseState *save;
 802 #if YYDEBUG
 803             if (yydebug)
 804             {
 805                 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
 806                 if (yyps->save)
 807                     fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
 808                 else
 809                     fputs("Starting trial parse.\n", stderr);
 810             }
 811 #endif
 812             save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
 813             if (save == NULL) goto yyenomem;
 814             save->save            = yyps->save;
 815             save->state           = yystate;
 816             save->errflag         = yyerrflag;
 817             save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
 818             memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
 819             save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
 820             memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
 821 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 822             save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
 823             memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 824 #endif
 825             ctry                  = yytable[yyn];
 826             if (yyctable[ctry] == -1)
 827             {
 828 #if YYDEBUG
 829                 if (yydebug && yychar >= YYEOF)
 830                     fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
 831 #endif
 832                 ctry++;
 833             }
 834             save->ctry = ctry;
 835             if (yyps->save == NULL)
 836             {
 837                 /* If this is a first conflict in the stack, start saving lexemes */
 838                 if (!yylexemes)
 839                 {
 840                     yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
 841                     if (yylexemes == NULL) goto yyenomem;
 842                     yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
 843                     if (yylvals == NULL) goto yyenomem;
 844                     yylvlim   = yylvals + YYLVQUEUEGROWTH;
 845 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 846                     yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
 847                     if (yylpsns == NULL) goto yyenomem;
 848                     yylplim   = yylpsns + YYLVQUEUEGROWTH;
 849 #endif
 850                 }
 851                 if (yylvp == yylve)
 852                 {
 853                     yylvp  = yylve = yylvals;
 854 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 855                     yylpp  = yylpe = yylpsns;
 856 #endif
 857                     yylexp = yylexemes;
 858                     if (yychar >= YYEOF)
 859                     {
 860                         *yylve++ = yylval;
 861 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 862                         *yylpe++ = yylloc;
 863 #endif
 864                         *yylexp  = (short) yychar;
 865                         yychar   = YYEMPTY;
 866                     }
 867                 }
 868             }
 869             if (yychar >= YYEOF)
 870             {
 871                 yylvp--;
 872 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 873                 yylpp--;
 874 #endif
 875                 yylexp--;
 876                 yychar = YYEMPTY;
 877             }
 878             save->lexeme = (int) (yylvp - yylvals);
 879             yyps->save   = save;
 880         }
 881         if (yytable[yyn] == ctry)
 882         {
 883 #if YYDEBUG
 884             if (yydebug)
 885                 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
 886                                 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
 887 #endif
 888             if (yychar < 0)
 889             {
 890                 yylvp++;
 891 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 892                 yylpp++;
 893 #endif
 894                 yylexp++;
 895             }
 896             if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 897                 goto yyoverflow;
 898             yystate = yyctable[ctry];
 899             *++yystack.s_mark = (short) yystate;
 900             *++yystack.l_mark = yylval;
 901 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 902             *++yystack.p_mark = yylloc;
 903 #endif
 904             yychar  = YYEMPTY;
 905             if (yyerrflag > 0) --yyerrflag;
 906             goto yyloop;
 907         }
 908         else
 909         {
 910             yyn = yyctable[ctry];
 911             goto yyreduce;
 912         }
 913     } /* End of code dealing with conflicts */
 914 #endif /* YYBTYACC */
 915     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 916             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 917     {
 918 #if YYDEBUG
 919         if (yydebug)
 920             fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
 921                             YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
 922 #endif
 923         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 924         yystate = yytable[yyn];
 925         *++yystack.s_mark = yytable[yyn];
 926         *++yystack.l_mark = yylval;
 927 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 928         *++yystack.p_mark = yylloc;
 929 #endif
 930         yychar = YYEMPTY;
 931         if (yyerrflag > 0)  --yyerrflag;
 932         goto yyloop;
 933     }
 934     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 935             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 936     {
 937         yyn = yytable[yyn];
 938         goto yyreduce;
 939     }
 940     if (yyerrflag != 0) goto yyinrecovery;
 941 #if YYBTYACC
 942
 943     yynewerrflag = 1;
 944     goto yyerrhandler;
 945     goto yyerrlab;
 946
 947 yyerrlab:
 948     yynewerrflag = 0;
 949 yyerrhandler:
 950     while (yyps->save)
 951     {
 952         int ctry;
 953         YYParseState *save = yyps->save;
 954 #if YYDEBUG
 955         if (yydebug)
 956             fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
 957                             YYDEBUGSTR, yydepth, yystate, yyps->save->state,
 958                     (int)(yylvp - yylvals - yyps->save->lexeme));
 959 #endif
 960         /* Memorize most forward-looking error state in case it's really an error. */
 961         if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
 962         {
 963             /* Free old saved error context state */
 964             if (yyerrctx) yyFreeState(yyerrctx);
 965             /* Create and fill out new saved error context state */
 966             yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
 967             if (yyerrctx == NULL) goto yyenomem;
 968             yyerrctx->save           = yyps->save;
 969             yyerrctx->state          = yystate;
 970             yyerrctx->errflag        = yyerrflag;
 971             yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
 972             memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
 973             yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
 974             memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
 975 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 976             yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
 977             memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 978 #endif
 979             yyerrctx->lexeme         = (int) (yylvp - yylvals);
 980         }
 981         yylvp          = yylvals   + save->lexeme;
 982 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 983         yylpp          = yylpsns   + save->lexeme;
 984 #endif
 985         yylexp         = yylexemes + save->lexeme;
 986         yychar         = YYEMPTY;
 987         yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
 988         memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
 989         yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
 990         memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
 991 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
 992         yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
 993         memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
 994 #endif
 995         ctry           = ++save->ctry;
 996         yystate        = save->state;
 997         /* We tried shift, try reduce now */
 998         if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
 999         yyps->save     = save->save;
1000         save->save     = NULL;
1001         yyFreeState(save);
1002
1003         /* Nothing left on the stack -- error */
1004         if (!yyps->save)
1005         {
1006 #if YYDEBUG
1007             if (yydebug)
1008                 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1009                                 YYPREFIX, yydepth);
1010 #endif
1011             /* Restore state as it was in the most forward-advanced error */
1012             yylvp          = yylvals   + yyerrctx->lexeme;
1013 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1014             yylpp          = yylpsns   + yyerrctx->lexeme;
1015 #endif
1016             yylexp         = yylexemes + yyerrctx->lexeme;
1017             yychar         = yylexp[-1];
1018             yylval         = yylvp[-1];
1019 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1020             yylloc         = yylpp[-1];
1021 #endif
1022             yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1023             memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1024             yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1025             memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1026 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1027             yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1028             memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1029 #endif
1030             yystate        = yyerrctx->state;
1031             yyFreeState(yyerrctx);
1032             yyerrctx       = NULL;
1033         }
1034         yynewerrflag = 1;
1035     }
1036     if (yynewerrflag == 0) goto yyinrecovery;
1037 #endif /* YYBTYACC */
1038
1039     YYERROR_CALL("syntax error");
1040 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1041     yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1042 #endif
1043
1044 #if !YYBTYACC
1045     goto yyerrlab;
1046 yyerrlab:
1047 #endif
1048     ++yynerrs;
1049
1050 yyinrecovery:
1051     if (yyerrflag < 3)
1052     {
1053         yyerrflag = 3;
1054         for (;;)
1055         {
1056             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1057                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1058             {
1059 #if YYDEBUG
1060                 if (yydebug)
1061                     fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1062                                     YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1063 #endif
1064                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1065                 yystate = yytable[yyn];
1066                 *++yystack.s_mark = yytable[yyn];
1067                 *++yystack.l_mark = yylval;
1068 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1069                 /* lookahead position is error end position */
1070                 yyerror_loc_range[1] = yylloc;
1071                 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1072                 *++yystack.p_mark = yyloc;
1073 #endif
1074                 goto yyloop;
1075             }
1076             else
1077             {
1078 #if YYDEBUG
1079                 if (yydebug)
1080                     fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1081                                     YYDEBUGSTR, yydepth, *yystack.s_mark);
1082 #endif
1083                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1084 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1085                 /* the current TOS position is the error start position */
1086                 yyerror_loc_range[0] = *yystack.p_mark;
1087 #endif
1088 #if defined(YYDESTRUCT_CALL)
1089 #if YYBTYACC
1090                 if (!yytrial)
1091 #endif /* YYBTYACC */
1092 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1093                     YYDESTRUCT_CALL("error: discarding state",
1094                                     yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1095 #else
1096                     YYDESTRUCT_CALL("error: discarding state",
1097                                     yystos[*yystack.s_mark], yystack.l_mark);
1098 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1099 #endif /* defined(YYDESTRUCT_CALL) */
1100                 --yystack.s_mark;
1101                 --yystack.l_mark;
1102 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1103                 --yystack.p_mark;
1104 #endif
1105             }
1106         }
1107     }
1108     else
1109     {
1110         if (yychar == YYEOF) goto yyabort;
1111 #if YYDEBUG
1112         if (yydebug)
1113         {
1114             yys = yyname[YYTRANSLATE(yychar)];
1115             fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1116                             YYDEBUGSTR, yydepth, yystate, yychar, yys);
1117         }
1118 #endif
1119 #if defined(YYDESTRUCT_CALL)
1120 #if YYBTYACC
1121         if (!yytrial)
1122 #endif /* YYBTYACC */
1123 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1124             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1125 #else
1126             YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1127 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1128 #endif /* defined(YYDESTRUCT_CALL) */
1129         yychar = YYEMPTY;
1130         goto yyloop;
1131     }
1132
1133 yyreduce:
1134     yym = yylen[yyn];
1135 #if YYDEBUG
1136     if (yydebug)
1137     {
1138         fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1139                         YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1140 #ifdef YYSTYPE_TOSTRING
1141 #if YYBTYACC
1142         if (!yytrial)
1143 #endif /* YYBTYACC */
1144             if (yym > 0)
1145             {
1146                 int i;
1147                 fputc('<', stderr);
1148                 for (i = yym; i > 0; i--)
1149                 {
1150                     if (i != yym) fputs(", ", stderr);
1151                     fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1152                                            yystack.l_mark[1-i]), stderr);
1153                 }
1154                 fputc('>', stderr);
1155             }
1156 #endif
1157         fputc('\n', stderr);
1158     }
1159 #endif
1160     if (yym > 0)
1161         yyval = yystack.l_mark[1-yym];
1162     else
1163         memset(&yyval, 0, sizeof yyval);
1164 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1165
1166     /* Perform position reduction */
1167     memset(&yyloc, 0, sizeof(yyloc));
1168 #if YYBTYACC
1169     if (!yytrial)
1170 #endif /* YYBTYACC */
1171     {
1172         YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1173         /* just in case YYERROR is invoked within the action, save
1174            the start of the rhs as the error start position */
1175         yyerror_loc_range[0] = yystack.p_mark[1-yym];
1176     }
1177 #endif
1178
1179     switch (yyn)
1180     {
1181 case 3:
1182 #line 35 "quote_calc4.y"
1183         {  yyerrok ; }
1184 break;
1185 case 4:
1186 #line 39 "quote_calc4.y"
1187         {  printf("%d\n",yystack.l_mark[0]);}
1188 break;
1189 case 5:
1190 #line 41 "quote_calc4.y"
1191         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1192 break;
1193 case 6:
1194 #line 45 "quote_calc4.y"
1195         {  yyval = yystack.l_mark[-1]; }
1196 break;
1197 case 7:
1198 #line 47 "quote_calc4.y"
1199         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1200 break;
1201 case 8:
1202 #line 49 "quote_calc4.y"
1203         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1204 break;
1205 case 9:
1206 #line 51 "quote_calc4.y"
1207         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1208 break;
1209 case 10:
1210 #line 53 "quote_calc4.y"
1211         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1212 break;
1213 case 11:
1214 #line 55 "quote_calc4.y"
1215         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1216 break;
1217 case 12:
1218 #line 57 "quote_calc4.y"
1219         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1220 break;
1221 case 13:
1222 #line 59 "quote_calc4.y"
1223         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1224 break;
1225 case 14:
1226 #line 61 "quote_calc4.y"
1227         {  yyval = - yystack.l_mark[0]; }
1228 break;
1229 case 15:
1230 #line 63 "quote_calc4.y"
1231         {  yyval = regs[yystack.l_mark[0]]; }
1232 break;
1233 case 17:
1234 #line 68 "quote_calc4.y"
1235         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1236 break;
1237 case 18:
1238 #line 70 "quote_calc4.y"
1239         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1240 break;
1241 #line 1242 "quote_calc4-s.tab.c"
1242     default:
1243         break;
1244     }
1245     yystack.s_mark -= yym;
1246     yystate = *yystack.s_mark;
1247     yystack.l_mark -= yym;
1248 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1249     yystack.p_mark -= yym;
1250 #endif
1251     yym = yylhs[yyn];
1252     if (yystate == 0 && yym == 0)
1253     {
1254 #if YYDEBUG
1255         if (yydebug)
1256         {
1257             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1258 #ifdef YYSTYPE_TOSTRING
1259 #if YYBTYACC
1260             if (!yytrial)
1261 #endif /* YYBTYACC */
1262                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1263 #endif
1264             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1265         }
1266 #endif
1267         yystate = YYFINAL;
1268         *++yystack.s_mark = YYFINAL;
1269         *++yystack.l_mark = yyval;
1270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1271         *++yystack.p_mark = yyloc;
1272 #endif
1273         if (yychar < 0)
1274         {
1275 #if YYBTYACC
1276             do {
1277             if (yylvp < yylve)
1278             {
1279                 /* we're currently re-reading tokens */
1280                 yylval = *yylvp++;
1281 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1282                 yylloc = *yylpp++;
1283 #endif
1284                 yychar = *yylexp++;
1285                 break;
1286             }
1287             if (yyps->save)
1288             {
1289                 /* in trial mode; save scanner results for future parse attempts */
1290                 if (yylvp == yylvlim)
1291                 {   /* Enlarge lexical value queue */
1292                     size_t p = (size_t) (yylvp - yylvals);
1293                     size_t s = (size_t) (yylvlim - yylvals);
1294
1295                     s += YYLVQUEUEGROWTH;
1296                     if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)
1297                         goto yyenomem;
1298                     if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1299                         goto yyenomem;
1300 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1301                     if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1302                         goto yyenomem;
1303 #endif
1304                     yylvp   = yylve = yylvals + p;
1305                     yylvlim = yylvals + s;
1306 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1307                     yylpp   = yylpe = yylpsns + p;
1308                     yylplim = yylpsns + s;
1309 #endif
1310                     yylexp  = yylexemes + p;
1311                 }
1312                 *yylexp = (short) YYLEX;
1313                 *yylvp++ = yylval;
1314                 yylve++;
1315 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1316                 *yylpp++ = yylloc;
1317                 yylpe++;
1318 #endif
1319                 yychar = *yylexp++;
1320                 break;
1321             }
1322             /* normal operation, no conflict encountered */
1323 #endif /* YYBTYACC */
1324             yychar = YYLEX;
1325 #if YYBTYACC
1326             } while (0);
1327 #endif /* YYBTYACC */
1328             if (yychar < 0) yychar = YYEOF;
1329             /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1330 #if YYDEBUG
1331             if (yydebug)
1332             {
1333                 yys = yyname[YYTRANSLATE(yychar)];
1334                 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1335                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1336             }
1337 #endif
1338         }
1339         if (yychar == YYEOF) goto yyaccept;
1340         goto yyloop;
1341     }
1342     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1343             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1344         yystate = yytable[yyn];
1345     else
1346         yystate = yydgoto[yym];
1347 #if YYDEBUG
1348     if (yydebug)
1349     {
1350         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1351 #ifdef YYSTYPE_TOSTRING
1352 #if YYBTYACC
1353         if (!yytrial)
1354 #endif /* YYBTYACC */
1355             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1356 #endif
1357         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1358     }
1359 #endif
1360     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1361     *++yystack.s_mark = (short) yystate;
1362     *++yystack.l_mark = yyval;
1363 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1364     *++yystack.p_mark = yyloc;
1365 #endif
1366     goto yyloop;
1367 #if YYBTYACC
1368
1369     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1370 yyvalid:
1371     if (yypath) YYABORT;
1372     while (yyps->save)
1373     {
1374         YYParseState *save = yyps->save;
1375         yyps->save = save->save;
1376         save->save = yypath;
1377         yypath = save;
1378     }
1379 #if YYDEBUG
1380     if (yydebug)
1381         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1382                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1383 #endif
1384     if (yyerrctx)
1385     {
1386         yyFreeState(yyerrctx);
1387         yyerrctx = NULL;
1388     }
1389     yylvp          = yylvals + yypath->lexeme;
1390 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1391     yylpp          = yylpsns + yypath->lexeme;
1392 #endif
1393     yylexp         = yylexemes + yypath->lexeme;
1394     yychar         = YYEMPTY;
1395     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1396     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1397     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1398     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1399 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1400     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1401     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1402 #endif
1403     yystate        = yypath->state;
1404     goto yyloop;
1405 #endif /* YYBTYACC */
1406
1407 yyoverflow:
1408     YYERROR_CALL("yacc stack overflow");
1409 #if YYBTYACC
1410     goto yyabort_nomem;
1411 yyenomem:
1412     YYERROR_CALL("memory exhausted");
1413 yyabort_nomem:
1414 #endif /* YYBTYACC */
1415     yyresult = 2;
1416     goto yyreturn;
1417
1418 yyabort:
1419     yyresult = 1;
1420     goto yyreturn;
1421
1422 yyaccept:
1423 #if YYBTYACC
1424     if (yyps->save) goto yyvalid;
1425 #endif /* YYBTYACC */
1426     yyresult = 0;
1427
1428 yyreturn:
1429 #if defined(YYDESTRUCT_CALL)
1430     if (yychar != YYEOF && yychar != YYEMPTY)
1431 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1432         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1433 #else
1434         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1435 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1436
1437     {
1438         YYSTYPE *pv;
1439 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1440         YYLTYPE *pp;
1441
1442         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1443              YYDESTRUCT_CALL("cleanup: discarding state",
1444                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1445 #else
1446         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1447              YYDESTRUCT_CALL("cleanup: discarding state",
1448                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1449 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1450     }
1451 #endif /* defined(YYDESTRUCT_CALL) */
1452
1453 #if YYBTYACC
1454     if (yyerrctx)
1455     {
1456         yyFreeState(yyerrctx);
1457         yyerrctx = NULL;
1458     }
1459     while (yyps)
1460     {
1461         YYParseState *save = yyps;
1462         yyps = save->save;
1463         save->save = NULL;
1464         yyFreeState(save);
1465     }
1466     while (yypath)
1467     {
1468         YYParseState *save = yypath;
1469         yypath = save->save;
1470         save->save = NULL;
1471         yyFreeState(save);
1472     }
1473 #endif /* YYBTYACC */
1474     yyfreestack(&yystack);
1475     return (yyresult);
1476 }