src/output.c

   1 /* Output the generated parsing program for Bison.
   2
   3    Copyright (C) 1984, 1986, 1989, 1992, 2000-2012 Free Software
   4    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 <spawn-pipe.h>
  29 #include <timevar.h>
  30 #include <wait-process.h>
  31
  32 #include "complain.h"
  33 #include "files.h"
  34 #include "getargs.h"
  35 #include "gram.h"
  36 #include "muscle-tab.h"
  37 #include "output.h"
  38 #include "reader.h"
  39 #include "scan-code.h"    /* max_left_semantic_context */
  40 #include "scan-skel.h"
  41 #include "symtab.h"
  42 #include "tables.h"
  43
  44 # define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
  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_INT ("tokens_number", ntokens);
 146   MUSCLE_INSERT_INT ("nterms_number", nvars);
 147   MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
 148   MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
 149
 150   muscle_insert_symbol_number_table ("translate",
 151                                      token_translations,
 152                                      token_translations[0],
 153                                      1, max_user_token_number + 1);
 154
 155   /* tname -- token names.  */
 156   {
 157     int i;
 158     /* We assume that the table will be output starting at column 2. */
 159     int j = 2;
 160     struct quoting_options *qo = clone_quoting_options (0);
 161     set_quoting_style (qo, c_quoting_style);
 162     set_quoting_flags (qo, QA_SPLIT_TRIGRAPHS);
 163     for (i = 0; i < nsyms; i++)
 164       {
 165         char *cp = quotearg_alloc (symbols[i]->tag, -1, qo);
 166         /* Width of the next token, including the two quotes, the
 167            comma and the space.  */
 168         int width = strlen (cp) + 2;
 169
 170         if (j + width > 75)
 171           {
 172             obstack_sgrow (&format_obstack, "\n ");
 173             j = 1;
 174           }
 175
 176         if (i)
 177           obstack_1grow (&format_obstack, ' ');
 178         MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
 179         free (cp);
 180         obstack_1grow (&format_obstack, ',');
 181         j += width;
 182       }
 183     free (qo);
 184     obstack_sgrow (&format_obstack, " ]b4_null[");
 185
 186     /* Finish table and store. */
 187     obstack_1grow (&format_obstack, 0);
 188     muscle_insert ("tname", obstack_finish (&format_obstack));
 189   }
 190
 191   /* Output YYTOKNUM. */
 192   {
 193     int i;
 194     int *values = xnmalloc (ntokens, sizeof *values);
 195     for (i = 0; i < ntokens; ++i)
 196       values[i] = symbols[i]->user_token_number;
 197     muscle_insert_int_table ("toknum", values,
 198                              values[0], 1, ntokens);
 199     free (values);
 200   }
 201 }
 202
 203
 204 /*-------------------------------------------------------------.
 205 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
 206 | rline, dprec, merger.                                        |
 207 `-------------------------------------------------------------*/
 208
 209 static void
 210 prepare_rules (void)
 211 {
 212   rule_number r;
 213   unsigned int i = 0;
 214   item_number *rhs = xnmalloc (nritems, sizeof *rhs);
 215   unsigned int *prhs = xnmalloc (nrules, sizeof *prhs);
 216   unsigned int *rline = xnmalloc (nrules, sizeof *rline);
 217   symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
 218   unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
 219   int *dprec = xnmalloc (nrules, sizeof *dprec);
 220   int *merger = xnmalloc (nrules, sizeof *merger);
 221
 222   for (r = 0; r < nrules; ++r)
 223     {
 224       item_number *rhsp = NULL;
 225       /* Index of rule R in RHS. */
 226       prhs[r] = i;
 227       /* RHS of the rule R. */
 228       for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
 229         rhs[i++] = *rhsp;
 230       /* LHS of the rule R. */
 231       r1[r] = rules[r].lhs->number;
 232       /* Length of rule R's RHS. */
 233       r2[r] = i - prhs[r];
 234       /* Separator in RHS. */
 235       rhs[i++] = -1;
 236       /* Line where rule was defined. */
 237       rline[r] = rules[r].location.start.line;
 238       /* Dynamic precedence (GLR).  */
 239       dprec[r] = rules[r].dprec;
 240       /* Merger-function index (GLR).  */
 241       merger[r] = rules[r].merger;
 242     }
 243   aver (i == nritems);
 244
 245   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
 246   muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
 247   muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
 248   muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
 249   muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
 250   muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
 251   muscle_insert_int_table ("merger", merger, 0, 0, nrules);
 252
 253   MUSCLE_INSERT_INT ("rules_number", nrules);
 254   MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
 255
 256   free (rhs);
 257   free (prhs);
 258   free (rline);
 259   free (r1);
 260   free (r2);
 261   free (dprec);
 262   free (merger);
 263 }
 264
 265 /*--------------------------------------------.
 266 | Prepare the muscles related to the states.  |
 267 `--------------------------------------------*/
 268
 269 static void
 270 prepare_states (void)
 271 {
 272   state_number i;
 273   symbol_number *values = xnmalloc (nstates, sizeof *values);
 274   for (i = 0; i < nstates; ++i)
 275     values[i] = states[i]->accessing_symbol;
 276   muscle_insert_symbol_number_table ("stos", values,
 277                                      0, 1, nstates);
 278   free (values);
 279
 280   MUSCLE_INSERT_INT ("last", high);
 281   MUSCLE_INSERT_INT ("final_state_number", final_state->number);
 282   MUSCLE_INSERT_INT ("states_number", nstates);
 283 }
 284
 285
 286
 287 /*---------------------------------.
 288 | Output the user actions to OUT.  |
 289 `---------------------------------*/
 290
 291 static void
 292 user_actions_output (FILE *out)
 293 {
 294   rule_number r;
 295
 296   fputs ("m4_define([b4_actions], \n[", out);
 297   for (r = 0; r < nrules; ++r)
 298     if (rules[r].action)
 299       {
 300         fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
 301                  rules[r].action_location.start.line);
 302         escaped_output (out, rules[r].action_location.start.file);
 303         fprintf (out, ")\n[    %s]])\n\n", rules[r].action);
 304       }
 305   fputs ("])\n\n", out);
 306 }
 307
 308 /*--------------------------------------.
 309 | Output the merge functions to OUT.   |
 310 `--------------------------------------*/
 311
 312 static void
 313 merger_output (FILE *out)
 314 {
 315   int n;
 316   merger_list* p;
 317
 318   fputs ("m4_define([b4_mergers], \n[[", out);
 319   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
 320     {
 321       if (p->type[0] == '\0')
 322         fprintf (out, "  case %d: *yy0 = %s (*yy0, *yy1); break;\n",
 323                  n, p->name);
 324       else
 325         fprintf (out, "  case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
 326                  n, p->type, p->name);
 327     }
 328   fputs ("]])\n\n", out);
 329 }
 330
 331 /*--------------------------------------.
 332 | Output the tokens definition to OUT.  |
 333 `--------------------------------------*/
 334
 335 static void
 336 token_definitions_output (FILE *out)
 337 {
 338   int i;
 339   char const *sep = "";
 340
 341   fputs ("m4_define([b4_tokens], \n[", out);
 342   for (i = 0; i < ntokens; ++i)
 343     {
 344       symbol *sym = symbols[i];
 345       int number = sym->user_token_number;
 346
 347       /* At this stage, if there are literal string aliases, they are
 348          part of SYMBOLS, so we should not find their aliased symbols
 349          here.  */
 350       aver (number != USER_NUMBER_HAS_STRING_ALIAS);
 351
 352       /* Skip error token.  */
 353       if (sym == errtoken)
 354         continue;
 355
 356       /* If this string has an alias, then it is necessarily the alias
 357          which is to be output.  */
 358       if (sym->alias)
 359         sym = sym->alias;
 360
 361       /* Don't output literal chars or strings (when defined only as a
 362          string).  Note that must be done after the alias resolution:
 363          think about `%token 'f' "f"'.  */
 364       if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
 365         continue;
 366
 367       /* Don't #define nonliteral tokens whose names contain periods,
 368          dashes or '$' (as does the default value of the EOF token).  */
 369       if (mbschr (sym->tag, '.')
 370           || mbschr (sym->tag, '-')
 371           || mbschr (sym->tag, '$'))
 372         continue;
 373
 374       fprintf (out, "%s[[[%s]], %d]",
 375                sep, sym->tag, number);
 376       sep = ",\n";
 377     }
 378   fputs ("])\n\n", out);
 379 }
 380
 381
 382 /*---------------------------------------------------.
 383 | Output the symbol destructors or printers to OUT.  |
 384 `---------------------------------------------------*/
 385
 386 static void
 387 symbol_code_props_output (FILE *out, char const *what,
 388                           code_props const *(*get)(symbol const *))
 389 {
 390   int i;
 391   char const *sep = "";
 392
 393   fputs ("m4_define([b4_symbol_", out);
 394   fputs (what, out);
 395   fputs ("], \n[", out);
 396   for (i = 0; i < nsyms; ++i)
 397     {
 398       symbol *sym = symbols[i];
 399       char const *code = (*get) (sym)->code;
 400       if (code)
 401         {
 402           location loc = (*get) (sym)->location;
 403           /* Filename, lineno,
 404              Symbol-name, Symbol-number,
 405              code, optional typename.  */
 406           fprintf (out, "%s[", sep);
 407           sep = ",\n";
 408           escaped_output (out, loc.start.file);
 409           fprintf (out, ", %d, ", loc.start.line);
 410           escaped_output (out, sym->tag);
 411           fprintf (out, ", %d, [[%s]]", sym->number, code);
 412           if (sym->type_name)
 413             fprintf (out, ", [[%s]]", sym->type_name);
 414           fputc (']', out);
 415         }
 416     }
 417   fputs ("])\n\n", out);
 418 }
 419
 420
 421 static void
 422 prepare_actions (void)
 423 {
 424   /* Figure out the actions for the specified state, indexed by
 425      lookahead token type.  */
 426
 427   muscle_insert_rule_number_table ("defact", yydefact,
 428                                    yydefact[0], 1, nstates);
 429
 430   /* Figure out what to do after reducing with each rule, depending on
 431      the saved state from before the beginning of parsing the data
 432      that matched this rule.  */
 433   muscle_insert_state_number_table ("defgoto", yydefgoto,
 434                                     yydefgoto[0], 1, nsyms - ntokens);
 435
 436
 437   /* Output PACT. */
 438   muscle_insert_base_table ("pact", base,
 439                              base[0], 1, nstates);
 440   MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
 441
 442   /* Output PGOTO. */
 443   muscle_insert_base_table ("pgoto", base,
 444                              base[nstates], nstates + 1, nvectors);
 445
 446   muscle_insert_base_table ("table", table,
 447                             table[0], 1, high + 1);
 448   MUSCLE_INSERT_INT ("table_ninf", table_ninf);
 449
 450   muscle_insert_base_table ("check", check,
 451                             check[0], 1, high + 1);
 452
 453   /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
 454      YYPACT) so that in states with unresolved conflicts, the default
 455      reduction is not used in the conflicted entries, so that there is
 456      a place to put a conflict pointer.
 457
 458      This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
 459      parser, so we could avoid accidents by not writing them out in
 460      that case.  Nevertheless, it seems even better to be able to use
 461      the GLR skeletons even without the non-deterministic tables.  */
 462   muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
 463                                     conflict_table[0], 1, high + 1);
 464   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
 465                                     0, 1, conflict_list_cnt);
 466 }
 467
 468 /*--------------------------------------------.
 469 | Output the definitions of all the muscles.  |
 470 `--------------------------------------------*/
 471
 472 static void
 473 muscles_output (FILE *out)
 474 {
 475   fputs ("m4_init()\n", out);
 476
 477   user_actions_output (out);
 478   merger_output (out);
 479   token_definitions_output (out);
 480   symbol_code_props_output (out, "destructors", &symbol_destructor_get);
 481   symbol_code_props_output (out, "printers", &symbol_printer_get);
 482
 483   muscles_m4_output (out);
 484 }
 485 \f
 486 /*---------------------------.
 487 | Call the skeleton parser.  |
 488 `---------------------------*/
 489
 490 static void
 491 output_skeleton (void)
 492 {
 493   FILE *in;
 494   int filter_fd[2];
 495   char const *argv[10];
 496   pid_t pid;
 497
 498   /* Compute the names of the package data dir and skeleton files.  */
 499   char const m4sugar[] = "m4sugar/m4sugar.m4";
 500   char const m4bison[] = "bison.m4";
 501   char *full_m4sugar;
 502   char *full_m4bison;
 503   char *full_skeleton;
 504   char const *p;
 505   char const *m4 = (p = getenv ("M4")) ? p : M4;
 506   char const *pkgdatadir = compute_pkgdatadir ();
 507   size_t skeleton_size = strlen (skeleton) + 1;
 508   size_t pkgdatadirlen = strlen (pkgdatadir);
 509   while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
 510     pkgdatadirlen--;
 511   full_skeleton = xmalloc (pkgdatadirlen + 1
 512                            + (skeleton_size < sizeof m4sugar
 513                               ? sizeof m4sugar : skeleton_size));
 514   memcpy (full_skeleton, pkgdatadir, pkgdatadirlen);
 515   full_skeleton[pkgdatadirlen] = '/';
 516   strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
 517   full_m4sugar = xstrdup (full_skeleton);
 518   strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
 519   full_m4bison = xstrdup (full_skeleton);
 520   if (mbschr (skeleton, '/'))
 521     strcpy (full_skeleton, skeleton);
 522   else
 523     strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
 524
 525   /* Test whether m4sugar.m4 is readable, to check for proper
 526      installation.  A faulty installation can cause deadlock, so a
 527      cheap sanity check is worthwhile.  */
 528   xfclose (xfopen (full_m4sugar, "r"));
 529
 530   /* Create an m4 subprocess connected to us via two pipes.  */
 531
 532   if (trace_flag & trace_tools)
 533     fprintf (stderr, "running: %s %s - %s %s\n",
 534              m4, full_m4sugar, full_m4bison, full_skeleton);
 535
 536   /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
 537      position-dependent manner.  Keep it as the first argument so that all
 538      files are traced.
 539
 540      See the thread starting at
 541      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 542      for details.  */
 543   {
 544     int i = 0;
 545     argv[i++] = m4;
 546
 547     /* When POSIXLY_CORRECT is set, GNU M4 1.6 and later disable GNU
 548        extensions, which Bison's skeletons depend on.  With older M4,
 549        it has no effect.  M4 1.4.12 added a -g/--gnu command-line
 550        option to make it explicit that a program wants GNU M4
 551        extensions even when POSIXLY_CORRECT is set.
 552
 553        See the thread starting at
 554        <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 555        for details.  */
 556     if (*M4_GNU_OPTION)
 557       argv[i++] = M4_GNU_OPTION;
 558
 559     argv[i++] = "-I";
 560     argv[i++] = pkgdatadir;
 561     if (trace_flag & trace_m4)
 562       argv[i++] = "-dV";
 563     argv[i++] = full_m4sugar;
 564     argv[i++] = "-";
 565     argv[i++] = full_m4bison;
 566     argv[i++] = full_skeleton;
 567     argv[i++] = NULL;
 568     aver (i <= ARRAY_CARDINALITY (argv));
 569   }
 570
 571   /* The ugly cast is because gnulib gets the const-ness wrong.  */
 572   pid = create_pipe_bidi ("m4", m4, (char **)(void*)argv, false, true,
 573                           true, filter_fd);
 574   free (full_m4sugar);
 575   free (full_m4bison);
 576   free (full_skeleton);
 577
 578   if (trace_flag & trace_muscles)
 579     muscles_output (stderr);
 580   {
 581     FILE *out = fdopen (filter_fd[1], "w");
 582     if (! out)
 583       error (EXIT_FAILURE, get_errno (),
 584              "fdopen");
 585     muscles_output (out);
 586     xfclose (out);
 587   }
 588
 589   /* Read and process m4's output.  */
 590   timevar_push (TV_M4);
 591   in = fdopen (filter_fd[0], "r");
 592   if (! in)
 593     error (EXIT_FAILURE, get_errno (),
 594            "fdopen");
 595   scan_skel (in);
 596   /* scan_skel should have read all of M4's output.  Otherwise, when we
 597      close the pipe, we risk letting M4 report a broken-pipe to the
 598      Bison user.  */
 599   aver (feof (in));
 600   xfclose (in);
 601   wait_subprocess (pid, "m4", false, false, true, true, NULL);
 602   timevar_pop (TV_M4);
 603 }
 604
 605 static void
 606 prepare (void)
 607 {
 608   /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
 609      for the user.  */
 610   char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
 611   bool use_push_for_pull_flag = false;
 612   if (use_push_for_pull_env != NULL
 613       && use_push_for_pull_env[0] != '\0'
 614       && 0 != strcmp (use_push_for_pull_env, "0"))
 615     use_push_for_pull_flag = true;
 616
 617   /* Flags. */
 618   MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
 619   MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
 620   MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
 621   MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
 622   MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
 623   MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
 624   MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
 625   MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
 626   MUSCLE_INSERT_BOOL ("token_table_flag", token_table_flag);
 627   MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
 628   MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
 629
 630   /* File names.  */
 631   if (spec_name_prefix)
 632     MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
 633
 634   MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
 635
 636 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
 637   DEFINE (dir_prefix);
 638   DEFINE (parser_file_name);
 639   DEFINE (spec_defines_file);
 640   DEFINE (spec_file_prefix);
 641   DEFINE (spec_graph_file);
 642   DEFINE (spec_name_prefix);
 643   DEFINE (spec_outfile);
 644   DEFINE (spec_verbose_file);
 645 #undef DEFINE
 646
 647   /* Find the right skeleton file, and add muscles about the skeletons.  */
 648   if (skeleton)
 649     MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
 650   else
 651     skeleton = language->skeleton;
 652
 653   /* About the skeletons.  */
 654   {
 655     /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
 656        would never be expanded.  Hopefully no one has M4-special characters in
 657        his Bison installation path.  */
 658     MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
 659   }
 660 }
 661
 662
 663 /*----------------------------------------------------------.
 664 | Output the parsing tables and the parser code to ftable.  |
 665 `----------------------------------------------------------*/
 666
 667 void
 668 output (void)
 669 {
 670   obstack_init (&format_obstack);
 671
 672   prepare_symbols ();
 673   prepare_rules ();
 674   prepare_states ();
 675   prepare_actions ();
 676
 677   prepare ();
 678
 679   /* Process the selected skeleton file.  */
 680   output_skeleton ();
 681
 682   obstack_free (&format_obstack, NULL);
 683 }
 684
 685 char const *
 686 compute_pkgdatadir (void)
 687 {
 688   char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
 689   return pkgdatadir ? pkgdatadir : PKGDATADIR;
 690 }