contrib/byacc/skeleton.c

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