/*      $OpenBSD: skeleton.c,v 1.40 2021/02/03 01:10:10 deraadt Exp $   */
/*      $NetBSD: skeleton.c,v 1.10 1996/03/25 00:36:18 mrg Exp $        */

/*
 * 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, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "defs.h"

/*  The definition of yysccsid in the banner should be replaced with    */
/*  a #pragma ident directive if the target C compiler supports         */
/*  #pragma ident directives.                                           */
/*                                                                      */
/*  If the skeleton is changed, the banner should be changed so that    */
/*  the altered version can be easily distinguished from the original.  */
/*                                                                      */
/*  The #defines included with the banner are there because they are    */
/*  useful in subsequent code.  The macros #defined in the header or    */
/*  the body either are not useful outside of semantic actions or       */
/*  are conditional.                                                    */

char *banner[] =
{
        "#include <stdlib.h>",
        "#include <string.h>",
        "#define YYBYACC 1",
        "#define YYMAJOR 1",
        "#define YYMINOR 9",
        "#define YYLEX yylex()",
        "#define YYEMPTY -1",
        "#define yyclearin (yychar=(YYEMPTY))",
        "#define yyerrok (yyerrflag=0)",
        "#define YYRECOVERING() (yyerrflag!=0)",
        NULL
};


char *tables[] =
{
        "extern const short yylhs[];",
        "extern const short yylen[];",
        "extern const short yydefred[];",
        "extern const short yydgoto[];",
        "extern const short yysindex[];",
        "extern const short yyrindex[];",
        "extern const short yygindex[];",
        "extern const short yytable[];",
        "extern const short yycheck[];",
        "#if YYDEBUG",
        "extern const char *const yyname[];",
        "extern const char *const yyrule[];",
        "#endif",
        NULL
};


char *header[] =
{
        "#ifdef YYSTACKSIZE",
        "#undef YYMAXDEPTH",
        "#define YYMAXDEPTH YYSTACKSIZE",
        "#else",
        "#ifdef YYMAXDEPTH",
        "#define YYSTACKSIZE YYMAXDEPTH",
        "#else",
        "#define YYSTACKSIZE 10000",
        "#define YYMAXDEPTH 10000",
        "#endif",
        "#endif",
        "#define YYINITSTACKSIZE 200",
        "/* LINTUSED */",
        "int yydebug;",
        "int yynerrs;",
        "int yyerrflag;",
        "int yychar;",
        "short *yyssp;",
        "YYSTYPE *yyvsp;",
        "YYSTYPE yyval;",
        "YYSTYPE yylval;",
        "short *yyss;",
        "short *yysslim;",
        "YYSTYPE *yyvs;",
        "unsigned int yystacksize;",
        "int yyparse(void);",
        NULL
};


char *body[] =
{
        "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
        "static int yygrowstack(void)",
        "{",
        "    unsigned int newsize;",
        "    long sslen;",
        "    short *newss;",
        "    YYSTYPE *newvs;",
        "",
        "    if ((newsize = yystacksize) == 0)",
        "        newsize = YYINITSTACKSIZE;",
        "    else if (newsize >= YYMAXDEPTH)",
        "        return -1;",
        "    else if ((newsize *= 2) > YYMAXDEPTH)",
        "        newsize = YYMAXDEPTH;",
        "    sslen = yyssp - yyss;",
        "#ifdef SIZE_MAX",
        "#define YY_SIZE_MAX SIZE_MAX",
        "#else",
        "#define YY_SIZE_MAX 0xffffffffU",
        "#endif",
        "    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)",
        "        goto bail;",
        "    newss = (short *)realloc(yyss, newsize * sizeof *newss);",
        "    if (newss == NULL)",
        "        goto bail;",
        "    yyss = newss;",
        "    yyssp = newss + sslen;",
        "    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)",
        "        goto bail;",
        "    newvs = (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs);",
        "    if (newvs == NULL)",
        "        goto bail;",
        "    yyvs = newvs;",
        "    yyvsp = newvs + sslen;",
        "    yystacksize = newsize;",
        "    yysslim = yyss + newsize - 1;",
        "    return 0;",
        "bail:",
        "    if (yyss)",
        "            free(yyss);",
        "    if (yyvs)",
        "            free(yyvs);",
        "    yyss = yyssp = NULL;",
        "    yyvs = yyvsp = NULL;",
        "    yystacksize = 0;",
        "    return -1;",
        "}",
        "",
        "#define YYABORT goto yyabort",
        "#define YYREJECT goto yyabort",
        "#define YYACCEPT goto yyaccept",
        "#define YYERROR goto yyerrlab",
        "int",
        "yyparse(void)",
        "{",
        "    int yym, yyn, yystate;",
        "#if YYDEBUG",
        "    const char *yys;",
        "",
        "    if ((yys = getenv(\"YYDEBUG\")))",
        "    {",
        "        yyn = *yys;",
        "        if (yyn >= '0' && yyn <= '9')",
        "            yydebug = yyn - '0';",
        "    }",
        "#endif /* YYDEBUG */",
        "",
        "    yynerrs = 0;",
        "    yyerrflag = 0;",
        "    yychar = (-1);",
        "",
        "    if (yyss == NULL && yygrowstack()) goto yyoverflow;",
        "    yyssp = yyss;",
        "    yyvsp = yyvs;",
        "    *yyssp = yystate = 0;",
        "",
        "yyloop:",
        "    if ((yyn = yydefred[yystate]) != 0) 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(\"%sdebug: state %d, reading %d (%s)\\n\",",
        "                    YYPREFIX, yystate, yychar, yys);",
        "        }",
        "#endif",
        "    }",
        "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
        "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
        "    {",
        "#if YYDEBUG",
        "        if (yydebug)",
        "            printf(\"%sdebug: state %d, shifting to state %d\\n\",",
        "                    YYPREFIX, yystate, yytable[yyn]);",
        "#endif",
        "        if (yyssp >= yysslim && yygrowstack())",
        "        {",
        "            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;",
        "#if defined(__GNUC__)",
        "    goto yynewerror;",
        "#endif",
        "yynewerror:",
        "    yyerror(\"syntax error\");",
        "#if defined(__GNUC__)",
        "    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(\"%sdebug: state %d, error recovery shifting\\",
        " to state %d\\n\", YYPREFIX, *yyssp, yytable[yyn]);",
        "#endif",
        "                if (yyssp >= yysslim && yygrowstack())",
        "                {",
        "                    goto yyoverflow;",
        "                }",
        "                *++yyssp = yystate = yytable[yyn];",
        "                *++yyvsp = yylval;",
        "                goto yyloop;",
        "            }",
        "            else",
        "            {",
        "#if YYDEBUG",
        "                if (yydebug)",
        "                    printf(\"%sdebug: error recovery discarding state %d\
\\n\",",
        "                            YYPREFIX, *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(\"%sdebug: state %d, error recovery discards token %d\
 (%s)\\n\",",
        "                    YYPREFIX, yystate, yychar, yys);",
        "        }",
        "#endif",
        "        yychar = (-1);",
        "        goto yyloop;",
        "    }",
        "yyreduce:",
        "#if YYDEBUG",
        "    if (yydebug)",
        "        printf(\"%sdebug: state %d, reducing by rule %d (%s)\\n\",",
        "                YYPREFIX, yystate, yyn, yyrule[yyn]);",
        "#endif",
        "    yym = yylen[yyn];",
        "    if (yym)",
        "        yyval = yyvsp[1-yym];",
        "    else",
        "        memset(&yyval, 0, sizeof yyval);",
        "    switch (yyn)",
        "    {",
        NULL
};


char *trailer[] =
{
        "    }",
        "    yyssp -= yym;",
        "    yystate = *yyssp;",
        "    yyvsp -= yym;",
        "    yym = yylhs[yyn];",
        "    if (yystate == 0 && yym == 0)",
        "    {",
        "#if YYDEBUG",
        "        if (yydebug)",
        "            printf(\"%sdebug: after reduction, shifting from state 0 to\\",
        " state %d\\n\", YYPREFIX, 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(\"%sdebug: state %d, reading %d (%s)\\n\",",
        "                        YYPREFIX, 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];",
        "#if YYDEBUG",
        "    if (yydebug)",
        "        printf(\"%sdebug: after reduction, shifting from state %d \\",
        "to state %d\\n\", YYPREFIX, *yyssp, yystate);",
        "#endif",
        "    if (yyssp >= yysslim && yygrowstack())",
        "    {",
        "        goto yyoverflow;",
        "    }",
        "    *++yyssp = yystate;",
        "    *++yyvsp = yyval;",
        "    goto yyloop;",
        "yyoverflow:",
        "    yyerror(\"yacc stack overflow\");",
        "yyabort:",
        "    if (yyss)",
        "            free(yyss);",
        "    if (yyvs)",
        "            free(yyvs);",
        "    yyss = yyssp = NULL;",
        "    yyvs = yyvsp = NULL;",
        "    yystacksize = 0;",
        "    return (1);",
        "yyaccept:",
        "    if (yyss)",
        "            free(yyss);",
        "    if (yyvs)",
        "            free(yyvs);",
        "    yyss = yyssp = NULL;",
        "    yyvs = yyvsp = NULL;",
        "    yystacksize = 0;",
        "    return (0);",
        "}",
        NULL
};


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

        for (i = 0; (s = section[i]); ++i) {
                ++outline;
                fputs(s, code_file);
                putc('\n', code_file);
        }
}