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 | For each symbol type, its tags and type name.  |
 288 `-----------------------------------------------*/
 289
 290 static void
 291 type_names_output (FILE *out)
 292 {
 293   int i;
 294   char const *sep = "";
 295
 296   fputs ("m4_define([b4_type_names],\n[", out);
 297   for (i = 0; i < nsyms; ++i)
 298     {
 299       symbol *sym = symbols[i];
 300       /* Symbol-name, Symbol-number, optional typename.  */
 301       fprintf (out, "%s[", i ? ",\n" : "");
 302       escaped_output (out, sym->tag);
 303       fprintf (out, ", %d, [[%s]]]",
 304                sym->number,
 305                sym->type_name ? sym->type_name : "");
 306     }
 307   fputs ("])\n\n", out);
 308 }
 309
 310
 311 /*---------------------------------.
 312 | Output the user actions to OUT.  |
 313 `---------------------------------*/
 314
 315 static void
 316 user_actions_output (FILE *out)
 317 {
 318   rule_number r;
 319
 320   fputs ("m4_define([b4_actions], \n[", out);
 321   for (r = 0; r < nrules; ++r)
 322     if (rules[r].action)
 323       {
 324         fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
 325                  rules[r].action_location.start.line);
 326         escaped_output (out, rules[r].action_location.start.file);
 327         fprintf (out, ")\n[    %s]])\n\n", rules[r].action);
 328       }
 329   fputs ("])\n\n", out);
 330 }
 331
 332 /*--------------------------------------.
 333 | Output the merge functions to OUT.   |
 334 `--------------------------------------*/
 335
 336 static void
 337 merger_output (FILE *out)
 338 {
 339   int n;
 340   merger_list* p;
 341
 342   fputs ("m4_define([b4_mergers], \n[[", out);
 343   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
 344     {
 345       if (p->type[0] == '\0')
 346         fprintf (out, "  case %d: *yy0 = %s (*yy0, *yy1); break;\n",
 347                  n, p->name);
 348       else
 349         fprintf (out, "  case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
 350                  n, p->type, p->name);
 351     }
 352   fputs ("]])\n\n", out);
 353 }
 354
 355 /*--------------------------------------.
 356 | Output the tokens definition to OUT.  |
 357 `--------------------------------------*/
 358
 359 static void
 360 token_definitions_output (FILE *out)
 361 {
 362   int i;
 363   char const *sep = "";
 364
 365   fputs ("m4_define([b4_tokens], \n[", out);
 366   for (i = 0; i < ntokens; ++i)
 367     {
 368       symbol *sym = symbols[i];
 369       int number = sym->user_token_number;
 370
 371       /* At this stage, if there are literal aliases, they are part of
 372          SYMBOLS, so we should not find symbols which are the aliases
 373          here.  */
 374       aver (number != USER_NUMBER_ALIAS);
 375
 376       /* Skip error token.  */
 377       if (sym == errtoken)
 378         continue;
 379
 380       /* If this string has an alias, then it is necessarily the alias
 381          which is to be output.  */
 382       if (sym->alias)
 383         sym = sym->alias;
 384
 385       /* Don't output literal chars or strings (when defined only as a
 386          string).  Note that must be done after the alias resolution:
 387          think about `%token 'f' "f"'.  */
 388       if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
 389         continue;
 390
 391       /* Don't #define nonliteral tokens whose names contain periods
 392          or '$' (as does the default value of the EOF token).  */
 393       if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))
 394         continue;
 395
 396       fprintf (out, "%s[[[%s]], %d]",
 397                sep, sym->tag, number);
 398       sep = ",\n";
 399     }
 400   fputs ("])\n\n", out);
 401 }
 402
 403
 404 /*---------------------------------------------------.
 405 | Output the symbol destructors or printers to OUT.  |
 406 `---------------------------------------------------*/
 407
 408 static void
 409 symbol_code_props_output (FILE *out, char const *what,
 410                           code_props const *(*get)(symbol const *))
 411 {
 412   int i;
 413   char const *sep = "";
 414
 415   fputs ("m4_define([b4_symbol_", out);
 416   fputs (what, out);
 417   fputs ("], \n[", out);
 418   for (i = 0; i < nsyms; ++i)
 419     {
 420       symbol *sym = symbols[i];
 421       char const *code = (*get) (sym)->code;
 422       if (code)
 423         {
 424           location loc = (*get) (sym)->location;
 425           /* Filename, lineno,
 426              Symbol-name, Symbol-number,
 427              code, optional typename.  */
 428           fprintf (out, "%s[", sep);
 429           sep = ",\n";
 430           escaped_output (out, loc.start.file);
 431           fprintf (out, ", %d, ", loc.start.line);
 432           escaped_output (out, sym->tag);
 433           fprintf (out, ", %d, [[%s]]", sym->number, code);
 434           if (sym->type_name)
 435             fprintf (out, ", [[%s]]", sym->type_name);
 436           fputc (']', out);
 437         }
 438     }
 439   fputs ("])\n\n", out);
 440 }
 441
 442
 443 static void
 444 prepare_actions (void)
 445 {
 446   /* Figure out the actions for the specified state, indexed by
 447      lookahead token type.  */
 448
 449   muscle_insert_rule_number_table ("defact", yydefact,
 450                                    yydefact[0], 1, nstates);
 451
 452   /* Figure out what to do after reducing with each rule, depending on
 453      the saved state from before the beginning of parsing the data
 454      that matched this rule.  */
 455   muscle_insert_state_number_table ("defgoto", yydefgoto,
 456                                     yydefgoto[0], 1, nsyms - ntokens);
 457
 458
 459   /* Output PACT. */
 460   muscle_insert_base_table ("pact", base,
 461                              base[0], 1, nstates);
 462   MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
 463
 464   /* Output PGOTO. */
 465   muscle_insert_base_table ("pgoto", base,
 466                              base[nstates], nstates + 1, nvectors);
 467
 468   muscle_insert_base_table ("table", table,
 469                             table[0], 1, high + 1);
 470   MUSCLE_INSERT_INT ("table_ninf", table_ninf);
 471
 472   muscle_insert_base_table ("check", check,
 473                             check[0], 1, high + 1);
 474
 475   /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
 476      YYPACT) so that in states with unresolved conflicts, the default
 477      reduction is not used in the conflicted entries, so that there is
 478      a place to put a conflict pointer.
 479
 480      This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
 481      parser, so we could avoid accidents by not writing them out in
 482      that case.  Nevertheless, it seems even better to be able to use
 483      the GLR skeletons even without the non-deterministic tables.  */
 484   muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
 485                                     conflict_table[0], 1, high + 1);
 486   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
 487                                     0, 1, conflict_list_cnt);
 488 }
 489 \f
 490 /*---------------------------.
 491 | Call the skeleton parser.  |
 492 `---------------------------*/
 493
 494 static void
 495 output_skeleton (void)
 496 {
 497   FILE *in;
 498   FILE *out;
 499   int filter_fd[2];
 500   char const *argv[9];
 501   pid_t pid;
 502
 503   /* Compute the names of the package data dir and skeleton files.  */
 504   char const m4sugar[] = "m4sugar/m4sugar.m4";
 505   char const m4bison[] = "bison.m4";
 506   char *full_m4sugar;
 507   char *full_m4bison;
 508   char *full_skeleton;
 509   char const *p;
 510   char const *m4 = (p = getenv ("M4")) ? p : M4;
 511   char const *pkgdatadir = compute_pkgdatadir ();
 512   size_t skeleton_size = strlen (skeleton) + 1;
 513   size_t pkgdatadirlen = strlen (pkgdatadir);
 514   while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
 515     pkgdatadirlen--;
 516   full_skeleton = xmalloc (pkgdatadirlen + 1
 517                            + (skeleton_size < sizeof m4sugar
 518                               ? sizeof m4sugar : skeleton_size));
 519   strncpy (full_skeleton, pkgdatadir, pkgdatadirlen);
 520   full_skeleton[pkgdatadirlen] = '/';
 521   strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
 522   full_m4sugar = xstrdup (full_skeleton);
 523   strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
 524   full_m4bison = xstrdup (full_skeleton);
 525   if (strchr (skeleton, '/'))
 526     strcpy (full_skeleton, skeleton);
 527   else
 528     strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
 529
 530   /* Test whether m4sugar.m4 is readable, to check for proper
 531      installation.  A faulty installation can cause deadlock, so a
 532      cheap sanity check is worthwhile.  */
 533   xfclose (xfopen (full_m4sugar, "r"));
 534
 535   /* Create an m4 subprocess connected to us via two pipes.  */
 536
 537   if (trace_flag & trace_tools)
 538     fprintf (stderr, "running: %s %s - %s %s\n",
 539              m4, full_m4sugar, full_m4bison, full_skeleton);
 540
 541   /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
 542      position-dependent manner.  Keep it as the first argument so that all
 543      files are traced.
 544
 545      See the thread starting at
 546      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 547      for details.  */
 548   {
 549     int i = 0;
 550     argv[i++] = m4;
 551     argv[i++] = "-I";
 552     argv[i++] = pkgdatadir;
 553     if (trace_flag & trace_m4)
 554       argv[i++] = "-dV";
 555     argv[i++] = full_m4sugar;
 556     argv[i++] = "-";
 557     argv[i++] = full_m4bison;
 558     argv[i++] = full_skeleton;
 559     argv[i++] = NULL;
 560   }
 561   /* When POSIXLY_CORRECT is set, some future versions of GNU M4 (most likely
 562      2.0) may drop some of the GNU extensions that Bison's skeletons depend
 563      upon.  So that the next release of Bison is forward compatible with those
 564      future versions of GNU M4, we unset POSIXLY_CORRECT here.
 565
 566      FIXME: A user might set POSIXLY_CORRECT to affect processes run from
 567      macros like m4_syscmd in a custom skeleton.  For now, Bison makes no
 568      promises about the behavior of custom skeletons, so this scenario is not a
 569      concern.  However, we eventually want to eliminate this shortcoming.  The
 570      next release of GNU M4 (1.4.12 or 1.6) will accept the -g command-line
 571      option as a no-op, and later releases will accept it to indicate that
 572      POSIXLY_CORRECT should be ignored.  Once the GNU M4 versions that accept
 573      -g are pervasive, Bison should use -g instead of unsetting
 574      POSIXLY_CORRECT.
 575
 576      See the thread starting at
 577      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 578      for details.  */
 579   unsetenv ("POSIXLY_CORRECT");
 580   init_subpipe ();
 581   pid = create_subpipe (argv, filter_fd);
 582   free (full_m4sugar);
 583   free (full_m4bison);
 584   free (full_skeleton);
 585
 586   out = fdopen (filter_fd[0], "w");
 587   if (! out)
 588     error (EXIT_FAILURE, get_errno (),
 589            "fdopen");
 590
 591   /* Output the definitions of all the muscles.  */
 592   fputs ("m4_init()\n", out);
 593
 594   type_names_output (out);
 595   user_actions_output (out);
 596   merger_output (out);
 597   token_definitions_output (out);
 598   symbol_code_props_output (out, "destructors", &symbol_destructor_get);
 599   symbol_code_props_output (out, "printers", &symbol_printer_get);
 600
 601   muscles_m4_output (out);
 602   xfclose (out);
 603
 604   /* Read and process m4's output.  */
 605   timevar_push (TV_M4);
 606   end_of_output_subpipe (pid, filter_fd);
 607   in = fdopen (filter_fd[1], "r");
 608   if (! in)
 609     error (EXIT_FAILURE, get_errno (),
 610            "fdopen");
 611   scan_skel (in);
 612   xfclose (in);
 613   reap_subpipe (pid, m4);
 614   timevar_pop (TV_M4);
 615 }
 616
 617 static void
 618 prepare (void)
 619 {
 620   /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
 621      for the user.  */
 622   char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
 623   bool use_push_for_pull_flag = false;
 624   if (use_push_for_pull_env != NULL
 625       && use_push_for_pull_env[0] != '\0'
 626       && 0 != strcmp (use_push_for_pull_env, "0"))
 627     use_push_for_pull_flag = true;
 628
 629   /* Flags. */
 630   MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
 631   MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
 632   MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
 633   MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
 634   MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
 635   MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
 636   MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
 637   MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
 638   MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
 639   MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
 640
 641   /* File names.  */
 642   if (spec_name_prefix)
 643     MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
 644
 645   MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
 646
 647 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
 648   DEFINE (dir_prefix);
 649   DEFINE (parser_file_name);
 650   DEFINE (spec_defines_file);
 651   DEFINE (spec_file_prefix);
 652   DEFINE (spec_graph_file);
 653   DEFINE (spec_name_prefix);
 654   DEFINE (spec_outfile);
 655   DEFINE (spec_verbose_file);
 656 #undef DEFINE
 657
 658   /* Find the right skeleton file, and add muscles about the skeletons.  */
 659   if (skeleton)
 660     MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
 661   else
 662     skeleton = language->skeleton;
 663
 664   /* About the skeletons.  */
 665   {
 666     /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
 667        would never be expanded.  Hopefully no one has M4-special characters in
 668        his Bison installation path.  */
 669     MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
 670   }
 671 }
 672
 673
 674 /*----------------------------------------------------------.
 675 | Output the parsing tables and the parser code to ftable.  |
 676 `----------------------------------------------------------*/
 677
 678 void
 679 output (void)
 680 {
 681   obstack_init (&format_obstack);
 682
 683   prepare_symbols ();
 684   prepare_rules ();
 685   prepare_states ();
 686   prepare_actions ();
 687
 688   prepare ();
 689
 690   /* Process the selected skeleton file.  */
 691   output_skeleton ();
 692
 693   obstack_free (&format_obstack, NULL);
 694 }
 695
 696 char const *
 697 compute_pkgdatadir (void)
 698 {
 699   char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
 700   return pkgdatadir ? pkgdatadir : PKGDATADIR;
 701 }