test/btyacc/quote_calc-s.tab.c

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