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