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

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