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