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