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