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