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