src/output.c

   1 /* Output the generated parsing program for Bison.
   2
   3    Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
   4    2005, 2006 Free Software Foundation, Inc.
   5
   6    This file is part of Bison, the GNU Compiler Compiler.
   7
   8    Bison is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    Bison is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Bison; see the file COPYING.  If not, write to the Free
  20    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include <config.h>
  24 #include "system.h"
  25
  26 #include <configmake.h>
  27 #include <error.h>
  28 #include <get-errno.h>
  29 #include <quotearg.h>
  30 #include <subpipe.h>
  31 #include <timevar.h>
  32
  33 #include "complain.h"
  34 #include "files.h"
  35 #include "getargs.h"
  36 #include "gram.h"
  37 #include "muscle_tab.h"
  38 #include "output.h"
  39 #include "reader.h"
  40 #include "scan-code.h"    /* max_left_semantic_context */
  41 #include "scan-skel.h"
  42 #include "symtab.h"
  43 #include "tables.h"
  44
  45
  46 static struct obstack format_obstack;
  47
  48
  49 /*-------------------------------------------------------------------.
  50 | Create a function NAME which associates to the muscle NAME the     |
  51 | result of formatting the FIRST and then TABLE_DATA[BEGIN..END[ (of |
  52 | TYPE), and to the muscle NAME_max, the max value of the            |
  53 | TABLE_DATA.                                                        |
  54 `-------------------------------------------------------------------*/
  55
  56
  57 #define GENERATE_MUSCLE_INSERT_TABLE(Name, Type)                        \
  58                                                                         \
  59 static void                                                             \
  60 Name (char const *name,                                                 \
  61       Type *table_data,                                                 \
  62       Type first,                                                       \
  63       int begin,                                                        \
  64       int end)                                                          \
  65 {                                                                       \
  66   Type min = first;                                                     \
  67   Type max = first;                                                     \
  68   long int lmin;                                                        \
  69   long int lmax;                                                        \
  70   int i;                                                                \
  71   int j = 1;                                                            \
  72                                                                         \
  73   obstack_fgrow1 (&format_obstack, "%6d", first);                       \
  74   for (i = begin; i < end; ++i)                                         \
  75     {                                                                   \
  76       obstack_1grow (&format_obstack, ',');                             \
  77       if (j >= 10)                                                      \
  78         {                                                               \
  79           obstack_sgrow (&format_obstack, "\n  ");                      \
  80           j = 1;                                                        \
  81         }                                                               \
  82       else                                                              \
  83         ++j;                                                            \
  84       obstack_fgrow1 (&format_obstack, "%6d", table_data[i]);           \
  85       if (table_data[i] < min)                                          \
  86         min = table_data[i];                                            \
  87       if (max < table_data[i])                                          \
  88         max = table_data[i];                                            \
  89     }                                                                   \
  90   obstack_1grow (&format_obstack, 0);                                   \
  91   muscle_insert (name, obstack_finish (&format_obstack));               \
  92                                                                         \
  93   lmin = min;                                                           \
  94   lmax = max;                                                           \
  95   /* Build `NAME_min' and `NAME_max' in the obstack. */                 \
  96   obstack_fgrow1 (&format_obstack, "%s_min", name);                     \
  97   obstack_1grow (&format_obstack, 0);                                   \
  98   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin);      \
  99   obstack_fgrow1 (&format_obstack, "%s_max", name);                     \
 100   obstack_1grow (&format_obstack, 0);                                   \
 101   MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax);      \
 102 }
 103
 104 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
 105 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)
 106 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
 107 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
 108 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
 109 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number)
 110 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
 111
 112
 113 /*--------------------------------------------------------------------.
 114 | Print to OUT a representation of STRING escaped both for C and M4.  |
 115 `--------------------------------------------------------------------*/
 116
 117 static void
 118 escaped_output (FILE *out, char const *string)
 119 {
 120   char const *p;
 121   fprintf (out, "[[");
 122
 123   for (p = quotearg_style (c_quoting_style, string); *p; p++)
 124     switch (*p)
 125       {
 126       case '$': fputs ("$][", out); break;
 127       case '@': fputs ("@@",  out); break;
 128       case '[': fputs ("@{",  out); break;
 129       case ']': fputs ("@}",  out); break;
 130       default: fputc (*p, out); break;
 131       }
 132
 133   fprintf (out, "]]");
 134 }
 135
 136
 137 /*------------------------------------------------------------------.
 138 | Prepare the muscles related to the symbols: translate, tname, and |
 139 | toknum.                                                           |
 140 `------------------------------------------------------------------*/
 141
 142 static void
 143 prepare_symbols (void)
 144 {
 145   MUSCLE_INSERT_BOOL ("token_table", token_table_flag);
 146   MUSCLE_INSERT_INT ("tokens_number", ntokens);
 147   MUSCLE_INSERT_INT ("nterms_number", nvars);
 148   MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
 149   MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
 150
 151   muscle_insert_symbol_number_table ("translate",
 152                                      token_translations,
 153                                      token_translations[0],
 154                                      1, max_user_token_number + 1);
 155
 156   /* tname -- token names.  */
 157   {
 158     int i;
 159     /* We assume that the table will be output starting at column 2. */
 160     int j = 2;
 161     for (i = 0; i < nsyms; i++)
 162       {
 163         char const *cp = quotearg_style (c_quoting_style, symbols[i]->tag);
 164         /* Width of the next token, including the two quotes, the
 165            comma and the space.  */
 166         int width = strlen (cp) + 2;
 167
 168         if (j + width > 75)
 169           {
 170             obstack_sgrow (&format_obstack, "\n ");
 171             j = 1;
 172           }
 173
 174         if (i)
 175           obstack_1grow (&format_obstack, ' ');
 176         MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
 177         obstack_1grow (&format_obstack, ',');
 178         j += width;
 179       }
 180     obstack_sgrow (&format_obstack, " ]b4_null[");
 181
 182     /* Finish table and store. */
 183     obstack_1grow (&format_obstack, 0);
 184     muscle_insert ("tname", obstack_finish (&format_obstack));
 185   }
 186
 187   /* Output YYTOKNUM. */
 188   {
 189     int i;
 190     int *values = xnmalloc (ntokens, sizeof *values);
 191     for (i = 0; i < ntokens; ++i)
 192       values[i] = symbols[i]->user_token_number;
 193     muscle_insert_int_table ("toknum", values,
 194                              values[0], 1, ntokens);
 195     free (values);
 196   }
 197 }
 198
 199
 200 /*-------------------------------------------------------------.
 201 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
 202 | rline, dprec, merger.                                        |
 203 `-------------------------------------------------------------*/
 204
 205 static void
 206 prepare_rules (void)
 207 {
 208   rule_number r;
 209   unsigned int i = 0;
 210   item_number *rhs = xnmalloc (nritems, sizeof *rhs);
 211   unsigned int *prhs = xnmalloc (nrules, sizeof *prhs);
 212   unsigned int *rline = xnmalloc (nrules, sizeof *rline);
 213   symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
 214   unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
 215   int *dprec = xnmalloc (nrules, sizeof *dprec);
 216   int *merger = xnmalloc (nrules, sizeof *merger);
 217
 218   for (r = 0; r < nrules; ++r)
 219     {
 220       item_number *rhsp = NULL;
 221       /* Index of rule R in RHS. */
 222       prhs[r] = i;
 223       /* RHS of the rule R. */
 224       for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
 225         rhs[i++] = *rhsp;
 226       /* LHS of the rule R. */
 227       r1[r] = rules[r].lhs->number;
 228       /* Length of rule R's RHS. */
 229       r2[r] = i - prhs[r];
 230       /* Separator in RHS. */
 231       rhs[i++] = -1;
 232       /* Line where rule was defined. */
 233       rline[r] = rules[r].location.start.line;
 234       /* Dynamic precedence (GLR).  */
 235       dprec[r] = rules[r].dprec;
 236       /* Merger-function index (GLR).  */
 237       merger[r] = rules[r].merger;
 238     }
 239   aver (i == nritems);
 240
 241   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
 242   muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
 243   muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
 244   muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
 245   muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
 246   muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
 247   muscle_insert_int_table ("merger", merger, 0, 0, nrules);
 248
 249   MUSCLE_INSERT_INT ("rules_number", nrules);
 250   MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
 251
 252   free (rhs);
 253   free (prhs);
 254   free (rline);
 255   free (r1);
 256   free (r2);
 257   free (dprec);
 258   free (merger);
 259 }
 260
 261 /*--------------------------------------------.
 262 | Prepare the muscles related to the states.  |
 263 `--------------------------------------------*/
 264
 265 static void
 266 prepare_states (void)
 267 {
 268   state_number i;
 269   symbol_number *values = xnmalloc (nstates, sizeof *values);
 270   for (i = 0; i < nstates; ++i)
 271     values[i] = states[i]->accessing_symbol;
 272   muscle_insert_symbol_number_table ("stos", values,
 273                                      0, 1, nstates);
 274   free (values);
 275
 276   MUSCLE_INSERT_INT ("last", high);
 277   MUSCLE_INSERT_INT ("final_state_number", final_state->number);
 278   MUSCLE_INSERT_INT ("states_number", nstates);
 279 }
 280
 281
 282
 283 /*---------------------------------.
 284 | Output the user actions to OUT.  |
 285 `---------------------------------*/
 286
 287 static void
 288 user_actions_output (FILE *out)
 289 {
 290   rule_number r;
 291
 292   fputs ("m4_define([b4_actions], \n[", out);
 293   for (r = 0; r < nrules; ++r)
 294     if (rules[r].action)
 295       {
 296         fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
 297                  rules[r].action_location.start.line);
 298         escaped_output (out, rules[r].action_location.start.file);
 299         fprintf (out, ")\n[    %s]])\n\n", rules[r].action);
 300       }
 301   fputs ("])\n\n", out);
 302 }
 303
 304 /*--------------------------------------.
 305 | Output the merge functions to OUT.   |
 306 `--------------------------------------*/
 307
 308 static void
 309 merger_output (FILE *out)
 310 {
 311   int n;
 312   merger_list* p;
 313
 314   fputs ("m4_define([b4_mergers], \n[[", out);
 315   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
 316     {
 317       if (p->type[0] == '\0')
 318         fprintf (out, "  case %d: *yy0 = %s (*yy0, *yy1); break;\n",
 319                  n, p->name);
 320       else
 321         fprintf (out, "  case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
 322                  n, p->type, p->name);
 323     }
 324   fputs ("]])\n\n", out);
 325 }
 326
 327 /*--------------------------------------.
 328 | Output the tokens definition to OUT.  |
 329 `--------------------------------------*/
 330
 331 static void
 332 token_definitions_output (FILE *out)
 333 {
 334   int i;
 335   char const *sep = "";
 336
 337   fputs ("m4_define([b4_tokens], \n[", out);
 338   for (i = 0; i < ntokens; ++i)
 339     {
 340       symbol *sym = symbols[i];
 341       int number = sym->user_token_number;
 342
 343       /* At this stage, if there are literal aliases, they are part of
 344          SYMBOLS, so we should not find symbols which are the aliases
 345          here.  */
 346       aver (number != USER_NUMBER_ALIAS);
 347
 348       /* Skip error token.  */
 349       if (sym == errtoken)
 350         continue;
 351
 352       /* If this string has an alias, then it is necessarily the alias
 353          which is to be output.  */
 354       if (sym->alias)
 355         sym = sym->alias;
 356
 357       /* Don't output literal chars or strings (when defined only as a
 358          string).  Note that must be done after the alias resolution:
 359          think about `%token 'f' "f"'.  */
 360       if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
 361         continue;
 362
 363       /* Don't #define nonliteral tokens whose names contain periods
 364          or '$' (as does the default value of the EOF token).  */
 365       if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))
 366         continue;
 367
 368       fprintf (out, "%s[[[%s]], %d]",
 369                sep, sym->tag, number);
 370       sep = ",\n";
 371     }
 372   fputs ("])\n\n", out);
 373 }
 374
 375
 376 /*---------------------------------------.
 377 | Output the symbol destructors to OUT.  |
 378 `---------------------------------------*/
 379
 380 static void
 381 symbol_destructors_output (FILE *out)
 382 {
 383   int i;
 384   char const *sep = "";
 385
 386   fputs ("m4_define([b4_symbol_destructors], \n[", out);
 387   for (i = 0; i < nsyms; ++i)
 388     if (symbol_destructor_get (symbols[i]))
 389       {
 390         symbol *sym = symbols[i];
 391
 392         /* Filename, lineno,
 393            Symbol-name, Symbol-number,
 394            destructor, optional typename.  */
 395         fprintf (out, "%s[", sep);
 396         sep = ",\n";
 397         escaped_output (out, symbol_destructor_location_get (sym).start.file);
 398         fprintf (out, ", %d, ",
 399                  symbol_destructor_location_get (sym).start.line);
 400         escaped_output (out, sym->tag);
 401         fprintf (out, ", %d, [[%s]]", sym->number,
 402                  symbol_destructor_get (sym));
 403         if (sym->type_name)
 404           fprintf (out, ", [[%s]]", sym->type_name);
 405         fputc (']', out);
 406       }
 407   fputs ("])\n\n", out);
 408 }
 409
 410
 411 /*------------------------------------.
 412 | Output the symbol printers to OUT.  |
 413 `------------------------------------*/
 414
 415 static void
 416 symbol_printers_output (FILE *out)
 417 {
 418   int i;
 419   char const *sep = "";
 420
 421   fputs ("m4_define([b4_symbol_printers], \n[", out);
 422   for (i = 0; i < nsyms; ++i)
 423     if (symbol_printer_get (symbols[i]))
 424       {
 425         symbol *sym = symbols[i];
 426
 427         /* Filename, lineno,
 428            Symbol-name, Symbol-number,
 429            printer, optional typename.  */
 430         fprintf (out, "%s[", sep);
 431         sep = ",\n";
 432         escaped_output (out, symbol_printer_location_get (sym).start.file);
 433         fprintf (out, ", %d, ", symbol_printer_location_get (sym).start.line);
 434         escaped_output (out, sym->tag);
 435         fprintf (out, ", %d, [[%s]]", sym->number, symbol_printer_get (sym));
 436         if (sym->type_name)
 437           fprintf (out, ", [[%s]]", sym->type_name);
 438         fputc (']', out);
 439       }
 440   fputs ("])\n\n", out);
 441 }
 442
 443
 444 static void
 445 prepare_actions (void)
 446 {
 447   /* Figure out the actions for the specified state, indexed by
 448      lookahead token type.  */
 449
 450   muscle_insert_rule_number_table ("defact", yydefact,
 451                                    yydefact[0], 1, nstates);
 452
 453   /* Figure out what to do after reducing with each rule, depending on
 454      the saved state from before the beginning of parsing the data
 455      that matched this rule.  */
 456   muscle_insert_state_number_table ("defgoto", yydefgoto,
 457                                     yydefgoto[0], 1, nsyms - ntokens);
 458
 459
 460   /* Output PACT. */
 461   muscle_insert_base_table ("pact", base,
 462                              base[0], 1, nstates);
 463   MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
 464
 465   /* Output PGOTO. */
 466   muscle_insert_base_table ("pgoto", base,
 467                              base[nstates], nstates + 1, nvectors);
 468
 469   muscle_insert_base_table ("table", table,
 470                             table[0], 1, high + 1);
 471   MUSCLE_INSERT_INT ("table_ninf", table_ninf);
 472
 473   muscle_insert_base_table ("check", check,
 474                             check[0], 1, high + 1);
 475
 476   /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
 477      YYPACT) so that in states with unresolved conflicts, the default
 478      reduction is not used in the conflicted entries, so that there is
 479      a place to put a conflict pointer.
 480
 481      This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
 482      parser, so we could avoid accidents by not writing them out in
 483      that case.  Nevertheless, it seems even better to be able to use
 484      the GLR skeletons even without the non-deterministic tables.  */
 485   muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
 486                                     conflict_table[0], 1, high + 1);
 487   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
 488                                     0, 1, conflict_list_cnt);
 489 }
 490
 491 \f
 492 /*---------------------------.
 493 | Call the skeleton parser.  |
 494 `---------------------------*/
 495
 496 static void
 497 output_skeleton (void)
 498 {
 499   FILE *in;
 500   FILE *out;
 501   int filter_fd[2];
 502   char const *argv[6];
 503   pid_t pid;
 504
 505   /* Compute the names of the package data dir and skeleton file.
 506      Test whether m4sugar.m4 is readable, to check for proper
 507      installation.  A faulty installation can cause deadlock, so a
 508      cheap sanity check is worthwhile.  */
 509   char const m4sugar[] = "m4sugar/m4sugar.m4";
 510   char *full_m4sugar;
 511   char *full_skeleton;
 512   char const *p;
 513   char const *m4 = (p = getenv ("M4")) ? p : M4;
 514   char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;
 515   size_t skeleton_size = strlen (skeleton) + 1;
 516   size_t pkgdatadirlen = strlen (pkgdatadir);
 517   while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
 518     pkgdatadirlen--;
 519   full_skeleton = xmalloc (pkgdatadirlen + 1
 520                            + (skeleton_size < sizeof m4sugar
 521                               ? sizeof m4sugar : skeleton_size));
 522   strcpy (full_skeleton, pkgdatadir);
 523   full_skeleton[pkgdatadirlen] = '/';
 524   strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
 525   full_m4sugar = xstrdup (full_skeleton);
 526   strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
 527   xfclose (xfopen (full_m4sugar, "r"));
 528
 529   /* Create an m4 subprocess connected to us via two pipes.  */
 530
 531   if (trace_flag & trace_tools)
 532     fprintf (stderr, "running: %s %s - %s\n",
 533              m4, full_m4sugar, full_skeleton);
 534
 535   argv[0] = m4;
 536   argv[1] = full_m4sugar;
 537   argv[2] = "-";
 538   argv[3] = full_skeleton;
 539   argv[4] = trace_flag & trace_m4 ? "-dV" : NULL;
 540   argv[5] = NULL;
 541
 542   init_subpipe ();
 543   pid = create_subpipe (argv, filter_fd);
 544   free (full_m4sugar);
 545   free (full_skeleton);
 546
 547   out = fdopen (filter_fd[0], "w");
 548   if (! out)
 549     error (EXIT_FAILURE, get_errno (),
 550            "fdopen");
 551
 552   /* Output the definitions of all the muscles.  */
 553   fputs ("m4_init()\n", out);
 554
 555   user_actions_output (out);
 556   merger_output (out);
 557   token_definitions_output (out);
 558   symbol_destructors_output (out);
 559   symbol_printers_output (out);
 560
 561   muscles_m4_output (out);
 562
 563   fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
 564   fputs ("m4_divert_push(0)dnl\n", out);
 565   xfclose (out);
 566
 567   /* Read and process m4's output.  */
 568   timevar_push (TV_M4);
 569   end_of_output_subpipe (pid, filter_fd);
 570   in = fdopen (filter_fd[1], "r");
 571   if (! in)
 572     error (EXIT_FAILURE, get_errno (),
 573            "fdopen");
 574   scan_skel (in);
 575   xfclose (in);
 576   reap_subpipe (pid, m4);
 577   timevar_pop (TV_M4);
 578 }
 579
 580 static void
 581 prepare (void)
 582 {
 583   /* Flags. */
 584   MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
 585   MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
 586   MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
 587   MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
 588   MUSCLE_INSERT_BOOL ("pure_flag", pure_parser);
 589   MUSCLE_INSERT_BOOL ("push_flag", push_parser);
 590   MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
 591   MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
 592   MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
 593
 594   /* File names.  */
 595   MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
 596 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
 597   DEFINE (dir_prefix);
 598   DEFINE (parser_file_name);
 599   DEFINE (spec_defines_file);
 600   DEFINE (spec_file_prefix);
 601   DEFINE (spec_graph_file);
 602   DEFINE (spec_name_prefix);
 603   DEFINE (spec_outfile);
 604   DEFINE (spec_verbose_file);
 605 #undef DEFINE
 606
 607   /* User Code.  */
 608   obstack_1grow (&pre_prologue_obstack, 0);
 609   obstack_1grow (&post_prologue_obstack, 0);
 610   muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));
 611   muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack));
 612
 613   /* Find the right skeleton file.  */
 614   if (!skeleton)
 615     {
 616       if (glr_parser || nondeterministic_parser)
 617         skeleton = "glr.c";
 618       else
 619         skeleton = "yacc.c";
 620     }
 621
 622   /* About the skeletons. */
 623   {
 624     char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
 625     MUSCLE_INSERT_STRING ("pkgdatadir", pkgdatadir ? pkgdatadir : PKGDATADIR);
 626     MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
 627   }
 628 }
 629
 630
 631 /*----------------------------------------------------------.
 632 | Output the parsing tables and the parser code to ftable.  |
 633 `----------------------------------------------------------*/
 634
 635 void
 636 output (void)
 637 {
 638   obstack_init (&format_obstack);
 639
 640   prepare_symbols ();
 641   prepare_rules ();
 642   prepare_states ();
 643   prepare_actions ();
 644
 645   prepare ();
 646
 647   /* Process the selected skeleton file.  */
 648   output_skeleton ();
 649
 650   obstack_free (&format_obstack, NULL);
 651   obstack_free (&pre_prologue_obstack, NULL);
 652   obstack_free (&post_prologue_obstack, NULL);
 653 }