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