contrib/byacc/test/calc.tab.c

   1 #ifndef lint
   2 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   3 #endif
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8
   9 #define YYEMPTY        (-1)
  10 #define yyclearin      (yychar = YYEMPTY)
  11 #define yyerrok        (yyerrflag = 0)
  12 #define YYRECOVERING() (yyerrflag != 0)
  13
  14
  15 #ifndef yyparse
  16 #define yyparse    calc_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      calc_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    calc_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     calc_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      calc_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     calc_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    calc_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    calc_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  calc_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      calc_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      calc_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   calc_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    calc_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   calc_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   calc_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   calc_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    calc_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    calc_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     calc_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     calc_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "calc_"
  95
  96 #define YYPURE 0
  97
  98 #line 2 "calc.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 int regs[26];
 103 int base;
 104
 105 extern int yylex(void);
 106 static void yyerror(const char *s);
 107
 108 #line 109 "calc.tab.c"
 109
 110 #ifndef YYSTYPE
 111 typedef int YYSTYPE;
 112 #endif
 113
 114 /* compatibility with bison */
 115 #ifdef YYPARSE_PARAM
 116 /* compatibility with FreeBSD */
 117 # ifdef YYPARSE_PARAM_TYPE
 118 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 119 # else
 120 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 121 # endif
 122 #else
 123 # define YYPARSE_DECL() yyparse(void)
 124 #endif
 125
 126 /* Parameters sent to lex. */
 127 #ifdef YYLEX_PARAM
 128 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 129 # define YYLEX yylex(YYLEX_PARAM)
 130 #else
 131 # define YYLEX_DECL() yylex(void)
 132 # define YYLEX yylex()
 133 #endif
 134
 135 /* Parameters sent to yyerror. */
 136 #ifndef YYERROR_DECL
 137 #define YYERROR_DECL() yyerror(const char *s)
 138 #endif
 139 #ifndef YYERROR_CALL
 140 #define YYERROR_CALL(msg) yyerror(msg)
 141 #endif
 142
 143 extern int YYPARSE_DECL();
 144
 145 #define DIGIT 257
 146 #define LETTER 258
 147 #define UMINUS 259
 148 #define YYERRCODE 256
 149 static const short calc_lhs[] = {                        -1,
 150     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 151     2,    2,    2,    2,    2,    2,    3,    3,
 152 };
 153 static const short calc_len[] = {                         2,
 154     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 155     3,    3,    3,    2,    1,    1,    1,    2,
 156 };
 157 static const short calc_defred[] = {                      1,
 158     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 159     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 160     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 161    10,   11,
 162 };
 163 static const short calc_dgoto[] = {                       1,
 164     7,    8,    9,
 165 };
 166 static const short calc_sindex[] = {                      0,
 167   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 168   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 169   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 170     0,    0,
 171 };
 172 static const short calc_rindex[] = {                      0,
 173     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 174     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 175     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 176     0,    0,
 177 };
 178 static const short calc_gindex[] = {                      0,
 179     0,   65,    0,
 180 };
 181 #define YYTABLESIZE 220
 182 static const short calc_table[] = {                       6,
 183    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 184    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 185     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 186     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 187     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 188     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 189     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 190    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 191    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 192     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 193     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 194     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 195     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 196     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 197     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 198     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 199     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 200     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 201     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 202     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 203     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 204     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 205 };
 206 static const short calc_check[] = {                      40,
 207    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 208    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 209    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 210    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 211    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 212    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 213    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 214     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 215    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 216    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 217    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 218    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 219    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 220    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 221    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 222    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 223    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 224    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 225    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 226    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 227    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 228    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 229 };
 230 #define YYFINAL 1
 231 #ifndef YYDEBUG
 232 #define YYDEBUG 0
 233 #endif
 234 #define YYMAXTOKEN 259
 235 #if YYDEBUG
 236 static const char *yyname[] = {
 237
 238 "end-of-file",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,
 239 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
 240 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 241 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
 242 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 243 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 244 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 245 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
 246 };
 247 static const char *yyrule[] = {
 248 "$accept : list",
 249 "list :",
 250 "list : list stat '\\n'",
 251 "list : list error '\\n'",
 252 "stat : expr",
 253 "stat : LETTER '=' expr",
 254 "expr : '(' expr ')'",
 255 "expr : expr '+' expr",
 256 "expr : expr '-' expr",
 257 "expr : expr '*' expr",
 258 "expr : expr '/' expr",
 259 "expr : expr '%' expr",
 260 "expr : expr '&' expr",
 261 "expr : expr '|' expr",
 262 "expr : '-' expr",
 263 "expr : LETTER",
 264 "expr : number",
 265 "number : DIGIT",
 266 "number : number DIGIT",
 267
 268 };
 269 #endif
 270
 271 int      yydebug;
 272 int      yynerrs;
 273
 274 int      yyerrflag;
 275 int      yychar;
 276 YYSTYPE  yyval;
 277 YYSTYPE  yylval;
 278
 279 /* define the initial stack-sizes */
 280 #ifdef YYSTACKSIZE
 281 #undef YYMAXDEPTH
 282 #define YYMAXDEPTH  YYSTACKSIZE
 283 #else
 284 #ifdef YYMAXDEPTH
 285 #define YYSTACKSIZE YYMAXDEPTH
 286 #else
 287 #define YYSTACKSIZE 500
 288 #define YYMAXDEPTH  500
 289 #endif
 290 #endif
 291
 292 #define YYINITSTACKSIZE 500
 293
 294 typedef struct {
 295     unsigned stacksize;
 296     short    *s_base;
 297     short    *s_mark;
 298     short    *s_last;
 299     YYSTYPE  *l_base;
 300     YYSTYPE  *l_mark;
 301 } YYSTACKDATA;
 302 /* variables for the parser stack */
 303 static YYSTACKDATA yystack;
 304 #line 66 "calc.y"
 305  /* start of programs */
 306
 307 int
 308 main (void)
 309 {
 310     while(!feof(stdin)) {
 311         yyparse();
 312     }
 313     return 0;
 314 }
 315
 316 static void
 317 yyerror(const char *s)
 318 {
 319     fprintf(stderr, "%s\n", s);
 320 }
 321
 322 int
 323 yylex(void)
 324 {
 325         /* lexical analysis routine */
 326         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 327         /* return DIGIT for a digit, yylval = 0 through 9 */
 328         /* all other characters are returned immediately */
 329
 330     int c;
 331
 332     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 333
 334     /* c is now nonblank */
 335
 336     if( islower( c )) {
 337         yylval = c - 'a';
 338         return ( LETTER );
 339     }
 340     if( isdigit( c )) {
 341         yylval = c - '0';
 342         return ( DIGIT );
 343     }
 344     return( c );
 345 }
 346 #line 347 "calc.tab.c"
 347
 348 #if YYDEBUG
 349 #include <stdio.h>              /* needed for printf */
 350 #endif
 351
 352 #include <stdlib.h>     /* needed for malloc, etc */
 353 #include <string.h>     /* needed for memset */
 354
 355 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 356 static int yygrowstack(YYSTACKDATA *data)
 357 {
 358     int i;
 359     unsigned newsize;
 360     short *newss;
 361     YYSTYPE *newvs;
 362
 363     if ((newsize = data->stacksize) == 0)
 364         newsize = YYINITSTACKSIZE;
 365     else if (newsize >= YYMAXDEPTH)
 366         return -1;
 367     else if ((newsize *= 2) > YYMAXDEPTH)
 368         newsize = YYMAXDEPTH;
 369
 370     i = (int) (data->s_mark - data->s_base);
 371     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 372     if (newss == 0)
 373         return -1;
 374
 375     data->s_base = newss;
 376     data->s_mark = newss + i;
 377
 378     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 379     if (newvs == 0)
 380         return -1;
 381
 382     data->l_base = newvs;
 383     data->l_mark = newvs + i;
 384
 385     data->stacksize = newsize;
 386     data->s_last = data->s_base + newsize - 1;
 387     return 0;
 388 }
 389
 390 #if YYPURE || defined(YY_NO_LEAKS)
 391 static void yyfreestack(YYSTACKDATA *data)
 392 {
 393     free(data->s_base);
 394     free(data->l_base);
 395     memset(data, 0, sizeof(*data));
 396 }
 397 #else
 398 #define yyfreestack(data) /* nothing */
 399 #endif
 400
 401 #define YYABORT  goto yyabort
 402 #define YYREJECT goto yyabort
 403 #define YYACCEPT goto yyaccept
 404 #define YYERROR  goto yyerrlab
 405
 406 int
 407 YYPARSE_DECL()
 408 {
 409     int yym, yyn, yystate;
 410 #if YYDEBUG
 411     const char *yys;
 412
 413     if ((yys = getenv("YYDEBUG")) != 0)
 414     {
 415         yyn = *yys;
 416         if (yyn >= '0' && yyn <= '9')
 417             yydebug = yyn - '0';
 418     }
 419 #endif
 420
 421     yynerrs = 0;
 422     yyerrflag = 0;
 423     yychar = YYEMPTY;
 424     yystate = 0;
 425
 426 #if YYPURE
 427     memset(&yystack, 0, sizeof(yystack));
 428 #endif
 429
 430     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 431     yystack.s_mark = yystack.s_base;
 432     yystack.l_mark = yystack.l_base;
 433     yystate = 0;
 434     *yystack.s_mark = 0;
 435
 436 yyloop:
 437     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 438     if (yychar < 0)
 439     {
 440         if ((yychar = YYLEX) < 0) yychar = 0;
 441 #if YYDEBUG
 442         if (yydebug)
 443         {
 444             yys = 0;
 445             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 446             if (!yys) yys = "illegal-symbol";
 447             printf("%sdebug: state %d, reading %d (%s)\n",
 448                     YYPREFIX, yystate, yychar, yys);
 449         }
 450 #endif
 451     }
 452     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 453             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 454     {
 455 #if YYDEBUG
 456         if (yydebug)
 457             printf("%sdebug: state %d, shifting to state %d\n",
 458                     YYPREFIX, yystate, yytable[yyn]);
 459 #endif
 460         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 461         {
 462             goto yyoverflow;
 463         }
 464         yystate = yytable[yyn];
 465         *++yystack.s_mark = yytable[yyn];
 466         *++yystack.l_mark = yylval;
 467         yychar = YYEMPTY;
 468         if (yyerrflag > 0)  --yyerrflag;
 469         goto yyloop;
 470     }
 471     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 472             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 473     {
 474         yyn = yytable[yyn];
 475         goto yyreduce;
 476     }
 477     if (yyerrflag) goto yyinrecovery;
 478
 479     yyerror("syntax error");
 480
 481     goto yyerrlab;
 482
 483 yyerrlab:
 484     ++yynerrs;
 485
 486 yyinrecovery:
 487     if (yyerrflag < 3)
 488     {
 489         yyerrflag = 3;
 490         for (;;)
 491         {
 492             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 493                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 494             {
 495 #if YYDEBUG
 496                 if (yydebug)
 497                     printf("%sdebug: state %d, error recovery shifting\
 498  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 499 #endif
 500                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 501                 {
 502                     goto yyoverflow;
 503                 }
 504                 yystate = yytable[yyn];
 505                 *++yystack.s_mark = yytable[yyn];
 506                 *++yystack.l_mark = yylval;
 507                 goto yyloop;
 508             }
 509             else
 510             {
 511 #if YYDEBUG
 512                 if (yydebug)
 513                     printf("%sdebug: error recovery discarding state %d\n",
 514                             YYPREFIX, *yystack.s_mark);
 515 #endif
 516                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 517                 --yystack.s_mark;
 518                 --yystack.l_mark;
 519             }
 520         }
 521     }
 522     else
 523     {
 524         if (yychar == 0) goto yyabort;
 525 #if YYDEBUG
 526         if (yydebug)
 527         {
 528             yys = 0;
 529             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 530             if (!yys) yys = "illegal-symbol";
 531             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 532                     YYPREFIX, yystate, yychar, yys);
 533         }
 534 #endif
 535         yychar = YYEMPTY;
 536         goto yyloop;
 537     }
 538
 539 yyreduce:
 540 #if YYDEBUG
 541     if (yydebug)
 542         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 543                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 544 #endif
 545     yym = yylen[yyn];
 546     if (yym)
 547         yyval = yystack.l_mark[1-yym];
 548     else
 549         memset(&yyval, 0, sizeof yyval);
 550     switch (yyn)
 551     {
 552 case 3:
 553 #line 28 "calc.y"
 554         {  yyerrok ; }
 555 break;
 556 case 4:
 557 #line 32 "calc.y"
 558         {  printf("%d\n",yystack.l_mark[0]);}
 559 break;
 560 case 5:
 561 #line 34 "calc.y"
 562         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 563 break;
 564 case 6:
 565 #line 38 "calc.y"
 566         {  yyval = yystack.l_mark[-1]; }
 567 break;
 568 case 7:
 569 #line 40 "calc.y"
 570         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 571 break;
 572 case 8:
 573 #line 42 "calc.y"
 574         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 575 break;
 576 case 9:
 577 #line 44 "calc.y"
 578         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 579 break;
 580 case 10:
 581 #line 46 "calc.y"
 582         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 583 break;
 584 case 11:
 585 #line 48 "calc.y"
 586         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 587 break;
 588 case 12:
 589 #line 50 "calc.y"
 590         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 591 break;
 592 case 13:
 593 #line 52 "calc.y"
 594         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 595 break;
 596 case 14:
 597 #line 54 "calc.y"
 598         {  yyval = - yystack.l_mark[0]; }
 599 break;
 600 case 15:
 601 #line 56 "calc.y"
 602         {  yyval = regs[yystack.l_mark[0]]; }
 603 break;
 604 case 17:
 605 #line 61 "calc.y"
 606         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 607 break;
 608 case 18:
 609 #line 63 "calc.y"
 610         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 611 break;
 612 #line 613 "calc.tab.c"
 613     }
 614     yystack.s_mark -= yym;
 615     yystate = *yystack.s_mark;
 616     yystack.l_mark -= yym;
 617     yym = yylhs[yyn];
 618     if (yystate == 0 && yym == 0)
 619     {
 620 #if YYDEBUG
 621         if (yydebug)
 622             printf("%sdebug: after reduction, shifting from state 0 to\
 623  state %d\n", YYPREFIX, YYFINAL);
 624 #endif
 625         yystate = YYFINAL;
 626         *++yystack.s_mark = YYFINAL;
 627         *++yystack.l_mark = yyval;
 628         if (yychar < 0)
 629         {
 630             if ((yychar = YYLEX) < 0) yychar = 0;
 631 #if YYDEBUG
 632             if (yydebug)
 633             {
 634                 yys = 0;
 635                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 636                 if (!yys) yys = "illegal-symbol";
 637                 printf("%sdebug: state %d, reading %d (%s)\n",
 638                         YYPREFIX, YYFINAL, yychar, yys);
 639             }
 640 #endif
 641         }
 642         if (yychar == 0) goto yyaccept;
 643         goto yyloop;
 644     }
 645     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 646             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 647         yystate = yytable[yyn];
 648     else
 649         yystate = yydgoto[yym];
 650 #if YYDEBUG
 651     if (yydebug)
 652         printf("%sdebug: after reduction, shifting from state %d \
 653 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 654 #endif
 655     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 656     {
 657         goto yyoverflow;
 658     }
 659     *++yystack.s_mark = (short) yystate;
 660     *++yystack.l_mark = yyval;
 661     goto yyloop;
 662
 663 yyoverflow:
 664     yyerror("yacc stack overflow");
 665
 666 yyabort:
 667     yyfreestack(&yystack);
 668     return (1);
 669
 670 yyaccept:
 671     yyfreestack(&yystack);
 672     return (0);
 673 }