tools/regression/usr.bin/yacc/regress.09.out

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