home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / misc_utils / yacc_419 / src / test / error.tab.c < prev    next >
C/C++ Source or Header  |  1990-06-03  |  6KB  |  266 lines
  1. #ifndef lint
  2. char yysccsid[] = "@(#)yaccpar    1.5 (Berkeley) 06/03/90";
  3. #endif
  4. #define YYERRCODE 256
  5. short yylhs[] = {                                        -1,
  6.     0,
  7. };
  8. short yylen[] = {                                         2,
  9.     1,
  10. };
  11. short yydefred[] = {                                      0,
  12.     1,    0,
  13. };
  14. short yydgoto[] = {                                       2,
  15. };
  16. short yysindex[] = {                                   -256,
  17.     0,    0,
  18. };
  19. short yyrindex[] = {                                      0,
  20.     0,    0,
  21. };
  22. short yygindex[] = {                                      0,
  23. };
  24. #define YYTABLESIZE 0
  25. short yytable[] = {                                       1,
  26. };
  27. short yycheck[] = {                                     256,
  28. };
  29. #define YYFINAL 2
  30. #ifndef YYDEBUG
  31. #define YYDEBUG 0
  32. #endif
  33. #define YYMAXTOKEN 0
  34. #if YYDEBUG
  35. char *yyname[] = {
  36. "end-of-file",
  37. };
  38. char *yyrule[] = {
  39. "$accept : S",
  40. "S : error",
  41. };
  42. #endif
  43. #ifndef YYSTYPE
  44. typedef int YYSTYPE;
  45. #endif
  46. #define yyclearin (yychar=(-1))
  47. #define yyerrok (yyerrflag=0)
  48. #ifndef YYSTACKSIZE
  49. #ifdef YYMAXDEPTH
  50. #define YYSTACKSIZE YYMAXDEPTH
  51. #else
  52. #define YYSTACKSIZE 300
  53. #endif
  54. #endif
  55. int yydebug;
  56. int yynerrs;
  57. int yyerrflag;
  58. int yychar;
  59. short *yyssp;
  60. YYSTYPE *yyvsp;
  61. YYSTYPE yyval;
  62. YYSTYPE yylval;
  63. #define yystacksize YYSTACKSIZE
  64. short yyss[YYSTACKSIZE];
  65. YYSTYPE yyvs[YYSTACKSIZE];
  66. #line 4 "error.y"
  67. main(){printf("yyparse() = %d\n",yyparse());}
  68. yylex(){return-1;}
  69. yyerror(s)char*s;{printf("%s\n",s);}
  70. #line 71 "error.tab.c"
  71. #define YYABORT goto yyabort
  72. #define YYACCEPT goto yyaccept
  73. #define YYERROR goto yyerrlab
  74. int
  75. yyparse()
  76. {
  77.     register int yym, yyn, yystate;
  78. #if YYDEBUG
  79.     register char *yys;
  80.     extern char *getenv();
  81.  
  82.     if (yys = getenv("YYDEBUG"))
  83.     {
  84.         yyn = *yys;
  85.         if (yyn >= '0' && yyn <= '9')
  86.             yydebug = yyn - '0';
  87.     }
  88. #endif
  89.  
  90.     yynerrs = 0;
  91.     yyerrflag = 0;
  92.     yychar = (-1);
  93.  
  94.     yyssp = yyss;
  95.     yyvsp = yyvs;
  96.     *yyssp = yystate = 0;
  97.  
  98. yyloop:
  99.     if (yyn = yydefred[yystate]) goto yyreduce;
  100.     if (yychar < 0)
  101.     {
  102.         if ((yychar = yylex()) < 0) yychar = 0;
  103. #if YYDEBUG
  104.         if (yydebug)
  105.         {
  106.             yys = 0;
  107.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  108.             if (!yys) yys = "illegal-symbol";
  109.             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  110.                     yychar, yys);
  111.         }
  112. #endif
  113.     }
  114.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  115.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  116.     {
  117. #if YYDEBUG
  118.         if (yydebug)
  119.             printf("yydebug: state %d, shifting to state %d\n",
  120.                     yystate, yytable[yyn]);
  121. #endif
  122.         if (yyssp >= yyss + yystacksize - 1)
  123.         {
  124.             goto yyoverflow;
  125.         }
  126.         *++yyssp = yystate = yytable[yyn];
  127.         *++yyvsp = yylval;
  128.         yychar = (-1);
  129.         if (yyerrflag > 0)  --yyerrflag;
  130.         goto yyloop;
  131.     }
  132.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  133.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  134.     {
  135.         yyn = yytable[yyn];
  136.         goto yyreduce;
  137.     }
  138.     if (yyerrflag) goto yyinrecovery;
  139. #ifdef lint
  140.     goto yynewerror;
  141. #endif
  142. yynewerror:
  143.     yyerror("syntax error");
  144. #ifdef lint
  145.     goto yyerrlab;
  146. #endif
  147. yyerrlab:
  148.     ++yynerrs;
  149. yyinrecovery:
  150.     if (yyerrflag < 3)
  151.     {
  152.         yyerrflag = 3;
  153.         for (;;)
  154.         {
  155.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  156.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  157.             {
  158. #if YYDEBUG
  159.                 if (yydebug)
  160.                     printf("yydebug: state %d, error recovery shifting\
  161.  to state %d\n", *yyssp, yytable[yyn]);
  162. #endif
  163.                 if (yyssp >= yyss + yystacksize - 1)
  164.                 {
  165.                     goto yyoverflow;
  166.                 }
  167.                 *++yyssp = yystate = yytable[yyn];
  168.                 *++yyvsp = yylval;
  169.                 goto yyloop;
  170.             }
  171.             else
  172.             {
  173. #if YYDEBUG
  174.                 if (yydebug)
  175.                     printf("yydebug: error recovery discarding state %d\n",
  176.                             *yyssp);
  177. #endif
  178.                 if (yyssp <= yyss) goto yyabort;
  179.                 --yyssp;
  180.                 --yyvsp;
  181.             }
  182.         }
  183.     }
  184.     else
  185.     {
  186.         if (yychar == 0) goto yyabort;
  187. #if YYDEBUG
  188.         if (yydebug)
  189.         {
  190.             yys = 0;
  191.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  192.             if (!yys) yys = "illegal-symbol";
  193.             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  194.                     yystate, yychar, yys);
  195.         }
  196. #endif
  197.         yychar = (-1);
  198.         goto yyloop;
  199.     }
  200. yyreduce:
  201. #if YYDEBUG
  202.     if (yydebug)
  203.         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  204.                 yystate, yyn, yyrule[yyn]);
  205. #endif
  206.     yym = yylen[yyn];
  207.     yyval = yyvsp[1-yym];
  208.     switch (yyn)
  209.     {
  210.     }
  211.     yyssp -= yym;
  212.     yystate = *yyssp;
  213.     yyvsp -= yym;
  214.     yym = yylhs[yyn];
  215.     if (yystate == 0 && yym == 0)
  216.     {
  217. #if YYDEBUG
  218.         if (yydebug)
  219.             printf("yydebug: after reduction, shifting from state 0 to\
  220.  state %d\n", YYFINAL);
  221. #endif
  222.         yystate = YYFINAL;
  223.         *++yyssp = YYFINAL;
  224.         *++yyvsp = yyval;
  225.         if (yychar < 0)
  226.         {
  227.             if ((yychar = yylex()) < 0) yychar = 0;
  228. #if YYDEBUG
  229.             if (yydebug)
  230.             {
  231.                 yys = 0;
  232.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  233.                 if (!yys) yys = "illegal-symbol";
  234.                 printf("yydebug: state %d, reading %d (%s)\n",
  235.                         YYFINAL, yychar, yys);
  236.             }
  237. #endif
  238.         }
  239.         if (yychar == 0) goto yyaccept;
  240.         goto yyloop;
  241.     }
  242.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  243.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  244.         yystate = yytable[yyn];
  245.     else
  246.         yystate = yydgoto[yym];
  247. #if YYDEBUG
  248.     if (yydebug)
  249.         printf("yydebug: after reduction, shifting from state %d \
  250. to state %d\n", *yyssp, yystate);
  251. #endif
  252.     if (yyssp >= yyss + yystacksize - 1)
  253.     {
  254.         goto yyoverflow;
  255.     }
  256.     *++yyssp = yystate;
  257.     *++yyvsp = yyval;
  258.     goto yyloop;
  259. yyoverflow:
  260.     yyerror("yacc stack overflow");
  261. yyabort:
  262.     return (1);
  263. yyaccept:
  264.     return (0);
  265. }
  266.