update from Bob Corbett

[unix-history] / usr / src / usr.bin / yacc / skeleton.c

/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Robert Paul Corbett.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley.  The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#ifndef lint
static char sccsid[] = "@(#)skeleton.c  5.2 (Berkeley) %G%";
#endif /* not lint */

#include "defs.h"

/*  The three line banner used here should be replaced with a one line  */
/*  #ident directive if the target C compiler supports #ident           */
/*  directives.                                                         */
/*                                                                      */
/*  If the skeleton is changed, the banner should be changed so that    */
/*  the altered version can easily be distinguished from the original.  */

char *banner[] =
{
   "#ifndef lint",
   "char yysccsid[] = \"@(#)yaccpar    1.1 (Berkeley) 12/10/89\";",
   "#endif",
   0
};


char *header[] =
{
   "#define yyclearin (yychar=(-1))",
   "#define yyerrok (yyerrflag=0)",
   "#ifndef YYSTACKSIZE",
   "#ifdef YYMAXDEPTH",
   "#define YYSTACKSIZE YYMAXDEPTH",
   "#else",
   "#define YYSTACKSIZE 300",
   "#endif",
   "#endif",
   "int yydebug;",
   "int yynerrs;",
   "int yyerrflag;",
   "int yychar;",
   "short *yyssp;",
   "YYSTYPE *yyvsp;",
   "YYSTYPE yyval;",
   "YYSTYPE yylval;",
   "#define yystacksize YYSTACKSIZE",
   "short yyss[YYSTACKSIZE];",
   "YYSTYPE yyvs[YYSTACKSIZE];",
   0
};


char *body[] =
{
   "#define YYABORT goto yyabort",
   "#define YYACCEPT goto yyaccept",
   "#define YYERROR goto yyerrlab",
   "int",
   "yyparse()",
   "{",
   "    register int yym, yyn, yystate;",
   "#if YYDEBUG",
   "    register char *yys;",
   "    extern char *getenv();",
   "",
   "    if (yys = getenv(\"YYDEBUG\"))",
   "    {",
   "        yyn = *yys;",
   "        if (yyn == '0')",
   "            yydebug = 0;",
   "        else if (yyn >= '1' && yyn <= '9')",
   "            yydebug = yyn - '0';",
   "    }",
   "#endif",
   "",
   "    yynerrs = 0;",
   "    yyerrflag = 0;",
   "    yychar = (-1);",
   "",
   "    yyssp = yyss;",
   "    yyvsp = yyvs;",
   "    *yyssp = yystate = 0;",
   "",
   "yyloop:",
   "    if (yyn = yydefred[yystate]) goto yyreduce;",
   "    if (yychar < 0)",
   "    {",
   "        if ((yychar = yylex()) < 0) yychar = 0;",
   "#if YYDEBUG",
   "        if (yydebug)",
   "        {",
   "            yys = 0;",
   "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
   "            if (!yys) yys = \"illegal-symbol\";",
   "            printf(\"yydebug: state %d, reading %d (%s)\\n\", yystate,",
   "                    yychar, yys);",
   "        }",
   "#endif",
   "    }",
   "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
   "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
   "    {",
   "#if YYDEBUG",
   "        if (yydebug)",
   "            printf(\"yydebug: state %d, shifting to state %d\\n\",",
   "                    yystate, yytable[yyn]);",
   "#endif",
   "        if (yyssp >= yyss + yystacksize - 1)",
   "        {",
   "            goto yyoverflow;",
   "        }",
   "        *++yyssp = yystate = yytable[yyn];",
   "        *++yyvsp = yylval;",
   "        yychar = (-1);",
   "        if (yyerrflag > 0)  --yyerrflag;",
   "        goto yyloop;",
   "    }",
   "    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&",
   "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
   "    {",
   "        yyn = yytable[yyn];",
   "        goto yyreduce;",
   "    }",
   "    if (yyerrflag) goto yyinrecovery;",
   "#ifdef lint",
   "    goto yynewerror;",
   "#endif",
   "yynewerror:",
   "    yyerror(\"syntax error\");",
   "#ifdef lint",
   "    goto yyerrlab;",
   "#endif",
   "yyerrlab:",
   "    ++yynerrs;",
   "yyinrecovery:",
   "    if (yyerrflag < 3)",
   "    {",
   "        yyerrflag = 3;",
   "        for (;;)",
   "        {",
   "            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&",
   "                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)",
   "            {",
   "#if YYDEBUG",
   "                if (yydebug)",
   "                    printf(\"yydebug: state %d, error recovery shifting\\",
   " to state %d\\n\", *yyssp, yytable[yyn]);",
   "#endif",
   "                if (yyssp >= yyss + yystacksize - 1)",
   "                {",
   "                    goto yyoverflow;",
   "                }",
   "                *++yyssp = yystate = yytable[yyn];",
   "                *++yyvsp = yylval;",
   "                goto yyloop;",
   "            }",
   "            else",
   "            {",
   "#if YYDEBUG",
   "                if (yydebug)",
   "                    printf(\"yydebug: error recovery discarding state %d\
\\n\",",
   "                            *yyssp);",
   "#endif",
   "                if (yyssp <= yyss) goto yyabort;",
   "                --yyssp;",
   "                --yyvsp;",
   "            }",
   "        }",
   "    }",
   "    else",
   "    {",
   "        if (yychar == 0) goto yyabort;",
   "#if YYDEBUG",
   "        if (yydebug)",
   "        {",
   "            yys = 0;",
   "            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
   "            if (!yys) yys = \"illegal-symbol\";",
   "            printf(\"yydebug: state %d, error recovery discards token %d\
(%s)\\n\",",
   "                    yystate, yychar, yys);",
   "        }",
   "#endif",
   "        yychar = (-1);",
   "        goto yyloop;",
   "    }",
   "yyreduce:",
   "#if YYDEBUG",
   "    if (yydebug)",
   "        printf(\"yydebug: state %d, reducing by rule %d (%s)\\n\",",
   "                yystate, yyn, yyrule[yyn]);",
   "#endif",
   "    yym = yylen[yyn];",
   "    yyval = yyvsp[1-yym];",
   "    switch (yyn)",
   "    {",
   0
};


char *trailer[] =
{
   "    }",
   "    yyssp -= yym;",
   "    yystate = *yyssp;",
   "    yyvsp -= yym;",
   "    yym = yylhs[yyn];",
   "    if (yystate == 0 && yym == 0)",
   "    {",
   "#ifdef YYDEBUG",
   "        if (yydebug)",
   "            printf(\"yydebug: after reduction, shifting from state 0 to\\",
   " state %d\\n\", YYFINAL);",
   "#endif",
   "        yystate = YYFINAL;",
   "        *++yyssp = YYFINAL;",
   "        *++yyvsp = yyval;",
   "        if (yychar < 0)",
   "        {",
   "            if ((yychar = yylex()) < 0) yychar = 0;",
   "#if YYDEBUG",
   "            if (yydebug)",
   "            {",
   "                yys = 0;",
   "                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
   "                if (!yys) yys = \"illegal-symbol\";",
   "                printf(\"yydebug: state %d, reading %d (%s)\\n\",",
   "                        YYFINAL, yychar, yys);",
   "            }",
   "#endif",
   "        }",
   "        if (yychar == 0) goto yyaccept;",
   "        goto yyloop;",
   "    }",
   "    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
   "            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)",
   "        yystate = yytable[yyn];",
   "    else",
   "        yystate = yydgoto[yym];",
   "#ifdef YYDEBUG",
   "    if (yydebug)",
   "        printf(\"yydebug: after reduction, shifting from state %d \\",
   "to state %d\\n\", *yyssp, yystate);",
   "#endif",
   "    if (yyssp >= yyss + yystacksize - 1)",
   "    {",
   "        goto yyoverflow;",
   "    }",
   "    *++yyssp = yystate;",
   "    *++yyvsp = yyval;",
   "    goto yyloop;",
   "yyoverflow:",
   "    yyerror(\"yacc stack overflow\");",
   "yyabort:",
   "    return (1);",
   "yyaccept:",
   "    return (0);",
   "}",
   0
};


write_section(section)
char *section[];
{
   register int i;

   for (i = 0; section[i]; ++i)
   {
       ++outline;
       fprintf(output_file, "%s\n", section[i]);
   }
}