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