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