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