contrib/byacc/yaccpar.c

   1 /* This file generated automatically using
   2  * @Id: skel2c,v 1.3 2014/04/06 19:48:04 tom Exp @
   3  */
   4
   5 /* @Id: yaccpar.skel,v 1.5 2014/04/07 21:51:00 tom Exp @ */
   6
   7 #include "defs.h"
   8
   9 /*  If the skeleton is changed, the banner should be changed so that    */
  10 /*  the altered version can be easily distinguished from the original.  */
  11 /*                                                                      */
  12 /*  The #defines included with the banner are there because they are    */
  13 /*  useful in subsequent code.  The macros #defined in the header or    */
  14 /*  the body either are not useful outside of semantic actions or       */
  15 /*  are conditional.                                                    */
  16
  17 const char *const banner[] =
  18 {
  19     "/* original parser id follows */",
  20     "/* yysccsid[] = \"@(#)yaccpar      1.9 (Berkeley) 02/21/93\" */",
  21     "/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */",
  22     "",
  23     "#define YYBYACC 1",
  24     CONCAT1("#define YYMAJOR ", YYMAJOR),
  25     CONCAT1("#define YYMINOR ", YYMINOR),
  26 #ifdef YYPATCH
  27     CONCAT1("#define YYPATCH ", YYPATCH),
  28 #endif
  29     "",
  30     "#define YYEMPTY        (-1)",
  31     "#define yyclearin      (yychar = YYEMPTY)",
  32     "#define yyerrok        (yyerrflag = 0)",
  33     "#define YYRECOVERING() (yyerrflag != 0)",
  34     "#define YYENOMEM       (-2)",
  35     "#define YYEOF          0",
  36     0
  37 };
  38
  39 const char *const xdecls[] =
  40 {
  41     "",
  42     "extern int YYPARSE_DECL();",
  43     0
  44 };
  45
  46 const char *const tables[] =
  47 {
  48     "extern YYINT yylhs[];",
  49     "extern YYINT yylen[];",
  50     "extern YYINT yydefred[];",
  51     "extern YYINT yydgoto[];",
  52     "extern YYINT yysindex[];",
  53     "extern YYINT yyrindex[];",
  54     "extern YYINT yygindex[];",
  55     "extern YYINT yytable[];",
  56     "extern YYINT yycheck[];",
  57     "",
  58     "#if YYDEBUG",
  59     "extern char *yyname[];",
  60     "extern char *yyrule[];",
  61     "#endif",
  62     0
  63 };
  64
  65 const char *const global_vars[] =
  66 {
  67     "",
  68     "int      yydebug;",
  69     "int      yynerrs;",
  70     0
  71 };
  72
  73 const char *const impure_vars[] =
  74 {
  75     "",
  76     "int      yyerrflag;",
  77     "int      yychar;",
  78     "YYSTYPE  yyval;",
  79     "YYSTYPE  yylval;",
  80     0
  81 };
  82
  83 const char *const hdr_defs[] =
  84 {
  85     "",
  86     "/* define the initial stack-sizes */",
  87     "#ifdef YYSTACKSIZE",
  88     "#undef YYMAXDEPTH",
  89     "#define YYMAXDEPTH  YYSTACKSIZE",
  90     "#else",
  91     "#ifdef YYMAXDEPTH",
  92     "#define YYSTACKSIZE YYMAXDEPTH",
  93     "#else",
  94     "#define YYSTACKSIZE 10000",
  95     "#define YYMAXDEPTH  10000",
  96     "#endif",
  97     "#endif",
  98     "",
  99     "#define YYINITSTACKSIZE 200",
 100     "",
 101     "typedef struct {",
 102     "    unsigned stacksize;",
 103     "    YYINT    *s_base;",
 104     "    YYINT    *s_mark;",
 105     "    YYINT    *s_last;",
 106     "    YYSTYPE  *l_base;",
 107     "    YYSTYPE  *l_mark;",
 108     "} YYSTACKDATA;",
 109     0
 110 };
 111
 112 const char *const hdr_vars[] =
 113 {
 114     "/* variables for the parser stack */",
 115     "static YYSTACKDATA yystack;",
 116     0
 117 };
 118
 119 const char *const body_vars[] =
 120 {
 121     "    int      yyerrflag;",
 122     "    int      yychar;",
 123     "    YYSTYPE  yyval;",
 124     "    YYSTYPE  yylval;",
 125     "",
 126     "    /* variables for the parser stack */",
 127     "    YYSTACKDATA yystack;",
 128     0
 129 };
 130
 131 const char *const body_1[] =
 132 {
 133     "",
 134     "#if YYDEBUG",
 135     "#include <stdio.h>         /* needed for printf */",
 136     "#endif",
 137     "",
 138     "#include <stdlib.h>        /* needed for malloc, etc */",
 139     "#include <string.h>        /* needed for memset */",
 140     "",
 141     "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
 142     "static int yygrowstack(YYSTACKDATA *data)",
 143     "{",
 144     "    int i;",
 145     "    unsigned newsize;",
 146     "    YYINT *newss;",
 147     "    YYSTYPE *newvs;",
 148     "",
 149     "    if ((newsize = data->stacksize) == 0)",
 150     "        newsize = YYINITSTACKSIZE;",
 151     "    else if (newsize >= YYMAXDEPTH)",
 152     "        return YYENOMEM;",
 153     "    else if ((newsize *= 2) > YYMAXDEPTH)",
 154     "        newsize = YYMAXDEPTH;",
 155     "",
 156     "    i = (int) (data->s_mark - data->s_base);",
 157     "    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));",
 158     "    if (newss == 0)",
 159     "        return YYENOMEM;",
 160     "",
 161     "    data->s_base = newss;",
 162     "    data->s_mark = newss + i;",
 163     "",
 164     "    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
 165     "    if (newvs == 0)",
 166     "        return YYENOMEM;",
 167     "",
 168     "    data->l_base = newvs;",
 169     "    data->l_mark = newvs + i;",
 170     "",
 171     "    data->stacksize = newsize;",
 172     "    data->s_last = data->s_base + newsize - 1;",
 173     "    return 0;",
 174     "}",
 175     "",
 176     "#if YYPURE || defined(YY_NO_LEAKS)",
 177     "static void yyfreestack(YYSTACKDATA *data)",
 178     "{",
 179     "    free(data->s_base);",
 180     "    free(data->l_base);",
 181     "    memset(data, 0, sizeof(*data));",
 182     "}",
 183     "#else",
 184     "#define yyfreestack(data) /* nothing */",
 185     "#endif",
 186     "",
 187     "#define YYABORT  goto yyabort",
 188     "#define YYREJECT goto yyabort",
 189     "#define YYACCEPT goto yyaccept",
 190     "#define YYERROR  goto yyerrlab",
 191     "",
 192     "int",
 193     "YYPARSE_DECL()",
 194     "{",
 195     0
 196 };
 197
 198 const char *const body_2[] =
 199 {
 200     "    int yym, yyn, yystate;",
 201     "#if YYDEBUG",
 202     "    const char *yys;",
 203     "",
 204     "    if ((yys = getenv(\"YYDEBUG\")) != 0)",
 205     "    {",
 206     "        yyn = *yys;",
 207     "        if (yyn >= '0' && yyn <= '9')",
 208     "            yydebug = yyn - '0';",
 209     "    }",
 210     "#endif",
 211     "",
 212     "    yynerrs = 0;",
 213     "    yyerrflag = 0;",
 214     "    yychar = YYEMPTY;",
 215     "    yystate = 0;",
 216     "",
 217     "#if YYPURE",
 218     "    memset(&yystack, 0, sizeof(yystack));",
 219     "#endif",
 220     "",
 221     "    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
 222     "    yystack.s_mark = yystack.s_base;",
 223     "    yystack.l_mark = yystack.l_base;",
 224     "    yystate = 0;",
 225     "    *yystack.s_mark = 0;",
 226     "",
 227     "yyloop:",
 228     "    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
 229     "    if (yychar < 0)",
 230     "    {",
 231     "        if ((yychar = YYLEX) < 0) yychar = YYEOF;",
 232     "#if YYDEBUG",
 233     "        if (yydebug)",
 234     "        {",
 235     "            yys = yyname[YYTRANSLATE(yychar)];",
 236     "            printf(\"%sdebug: state %d, reading %d (%s)\\n\",",
 237     "                    YYPREFIX, yystate, yychar, yys);",
 238     "        }",
 239     "#endif",
 240     "    }",
 241     "    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&",
 242     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
 243     "    {",
 244     "#if YYDEBUG",
 245     "        if (yydebug)",
 246     "            printf(\"%sdebug: state %d, shifting to state %d\\n\",",
 247     "                    YYPREFIX, yystate, yytable[yyn]);",
 248     "#endif",
 249     "        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
 250     "        {",
 251     "            goto yyoverflow;",
 252     "        }",
 253     "        yystate = yytable[yyn];",
 254     "        *++yystack.s_mark = yytable[yyn];",
 255     "        *++yystack.l_mark = yylval;",
 256     "        yychar = YYEMPTY;",
 257     "        if (yyerrflag > 0)  --yyerrflag;",
 258     "        goto yyloop;",
 259     "    }",
 260     "    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&",
 261     "            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)",
 262     "    {",
 263     "        yyn = yytable[yyn];",
 264     "        goto yyreduce;",
 265     "    }",
 266     "    if (yyerrflag) goto yyinrecovery;",
 267     "",
 268     "    YYERROR_CALL(\"syntax error\");",
 269     "",
 270     "    goto yyerrlab;",
 271     "",
 272     "yyerrlab:",
 273     "    ++yynerrs;",
 274     "",
 275     "yyinrecovery:",
 276     "    if (yyerrflag < 3)",
 277     "    {",
 278     "        yyerrflag = 3;",
 279     "        for (;;)",
 280     "        {",
 281     "            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&",
 282     "                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)",
 283     "            {",
 284     "#if YYDEBUG",
 285     "                if (yydebug)",
 286     "                    printf(\"%sdebug: state %d, error recovery shifting\\",
 287     " to state %d\\n\", YYPREFIX, *yystack.s_mark, yytable[yyn]);",
 288     "#endif",
 289     "                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
 290     "                {",
 291     "                    goto yyoverflow;",
 292     "                }",
 293     "                yystate = yytable[yyn];",
 294     "                *++yystack.s_mark = yytable[yyn];",
 295     "                *++yystack.l_mark = yylval;",
 296     "                goto yyloop;",
 297     "            }",
 298     "            else",
 299     "            {",
 300     "#if YYDEBUG",
 301     "                if (yydebug)",
 302     "                    printf(\"%sdebug: error recovery discarding state %d\\n\",",
 303     "                            YYPREFIX, *yystack.s_mark);",
 304     "#endif",
 305     "                if (yystack.s_mark <= yystack.s_base) goto yyabort;",
 306     "                --yystack.s_mark;",
 307     "                --yystack.l_mark;",
 308     "            }",
 309     "        }",
 310     "    }",
 311     "    else",
 312     "    {",
 313     "        if (yychar == YYEOF) goto yyabort;",
 314     "#if YYDEBUG",
 315     "        if (yydebug)",
 316     "        {",
 317     "            yys = yyname[YYTRANSLATE(yychar)];",
 318     "            printf(\"%sdebug: state %d, error recovery discards token %d (%s)\\n\",",
 319     "                    YYPREFIX, yystate, yychar, yys);",
 320     "        }",
 321     "#endif",
 322     "        yychar = YYEMPTY;",
 323     "        goto yyloop;",
 324     "    }",
 325     "",
 326     "yyreduce:",
 327     "#if YYDEBUG",
 328     "    if (yydebug)",
 329     "        printf(\"%sdebug: state %d, reducing by rule %d (%s)\\n\",",
 330     "                YYPREFIX, yystate, yyn, yyrule[yyn]);",
 331     "#endif",
 332     "    yym = yylen[yyn];",
 333     "    if (yym)",
 334     "        yyval = yystack.l_mark[1-yym];",
 335     "    else",
 336     "        memset(&yyval, 0, sizeof yyval);",
 337     "    switch (yyn)",
 338     "    {",
 339     0
 340 };
 341
 342 const char *const trailer[] =
 343 {
 344     "    }",
 345     "    yystack.s_mark -= yym;",
 346     "    yystate = *yystack.s_mark;",
 347     "    yystack.l_mark -= yym;",
 348     "    yym = yylhs[yyn];",
 349     "    if (yystate == 0 && yym == 0)",
 350     "    {",
 351     "#if YYDEBUG",
 352     "        if (yydebug)",
 353     "            printf(\"%sdebug: after reduction, shifting from state 0 to\\",
 354     " state %d\\n\", YYPREFIX, YYFINAL);",
 355     "#endif",
 356     "        yystate = YYFINAL;",
 357     "        *++yystack.s_mark = YYFINAL;",
 358     "        *++yystack.l_mark = yyval;",
 359     "        if (yychar < 0)",
 360     "        {",
 361     "            if ((yychar = YYLEX) < 0) yychar = YYEOF;",
 362     "#if YYDEBUG",
 363     "            if (yydebug)",
 364     "            {",
 365     "                yys = yyname[YYTRANSLATE(yychar)];",
 366     "                printf(\"%sdebug: state %d, reading %d (%s)\\n\",",
 367     "                        YYPREFIX, YYFINAL, yychar, yys);",
 368     "            }",
 369     "#endif",
 370     "        }",
 371     "        if (yychar == YYEOF) goto yyaccept;",
 372     "        goto yyloop;",
 373     "    }",
 374     "    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
 375     "            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)",
 376     "        yystate = yytable[yyn];",
 377     "    else",
 378     "        yystate = yydgoto[yym];",
 379     "#if YYDEBUG",
 380     "    if (yydebug)",
 381     "        printf(\"%sdebug: after reduction, shifting from state %d \\",
 382     "to state %d\\n\", YYPREFIX, *yystack.s_mark, yystate);",
 383     "#endif",
 384     "    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
 385     "    {",
 386     "        goto yyoverflow;",
 387     "    }",
 388     "    *++yystack.s_mark = (YYINT) yystate;",
 389     "    *++yystack.l_mark = yyval;",
 390     "    goto yyloop;",
 391     "",
 392     "yyoverflow:",
 393     "    YYERROR_CALL(\"yacc stack overflow\");",
 394     "",
 395     "yyabort:",
 396     "    yyfreestack(&yystack);",
 397     "    return (1);",
 398     "",
 399     "yyaccept:",
 400     "    yyfreestack(&yystack);",
 401     "    return (0);",
 402     "}",
 403     0
 404 };
 405
 406 void
 407 write_section(FILE * fp, const char *const section[])
 408 {
 409     int i;
 410     const char *s;
 411
 412     for (i = 0; (s = section[i]) != 0; ++i)
 413     {
 414         if (fp == code_file)
 415             ++outline;
 416         fprintf(fp, "%s\n", s);
 417     }
 418 }