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 ("symbols_number", nsyms);
 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: r1, r2, rline, dprec, |
 206 | merger.                                                         |
 207 `----------------------------------------------------------------*/
 208
 209 static void
 210 prepare_rules (void)
 211 {
 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   rule_number r;
 219   for (r = 0; r < nrules; ++r)
 220     {
 221       /* LHS of the rule R. */
 222       r1[r] = rules[r].lhs->number;
 223       /* Length of rule R's RHS. */
 224       r2[r] = rule_rhs_length(&rules[r]);
 225       /* Line where rule was defined. */
 226       rline[r] = rules[r].location.start.line;
 227       /* Dynamic precedence (GLR).  */
 228       dprec[r] = rules[r].dprec;
 229       /* Merger-function index (GLR).  */
 230       merger[r] = rules[r].merger;
 231     }
 232
 233   muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
 234   muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
 235   muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
 236   muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
 237   muscle_insert_int_table ("merger", merger, 0, 0, nrules);
 238
 239   MUSCLE_INSERT_INT ("rules_number", nrules);
 240   MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
 241
 242   free (rline);
 243   free (r1);
 244   free (r2);
 245   free (dprec);
 246   free (merger);
 247 }
 248
 249 /*--------------------------------------------.
 250 | Prepare the muscles related to the states.  |
 251 `--------------------------------------------*/
 252
 253 static void
 254 prepare_states (void)
 255 {
 256   state_number i;
 257   symbol_number *values = xnmalloc (nstates, sizeof *values);
 258   for (i = 0; i < nstates; ++i)
 259     values[i] = states[i]->accessing_symbol;
 260   muscle_insert_symbol_number_table ("stos", values,
 261                                      0, 1, nstates);
 262   free (values);
 263
 264   MUSCLE_INSERT_INT ("last", high);
 265   MUSCLE_INSERT_INT ("final_state_number", final_state->number);
 266   MUSCLE_INSERT_INT ("states_number", nstates);
 267 }
 268
 269
 270 /*-------------------------------------------------------.
 271 | Compare two symbols by type-name, and then by number.  |
 272 `-------------------------------------------------------*/
 273
 274 static int
 275 symbol_type_name_cmp (const symbol **lhs, const symbol **rhs)
 276 {
 277   int res = UNIQSTR_CMP((*lhs)->type_name, (*rhs)->type_name);
 278   if (res)
 279     return res;
 280   return (*lhs)->number - (*rhs)->number;
 281 }
 282
 283
 284 /*----------------------------------------------------------------.
 285 | Return a (malloc'ed) table of the symbols sorted by type-name.  |
 286 `----------------------------------------------------------------*/
 287
 288 static symbol **
 289 symbols_by_type_name (void)
 290 {
 291   typedef int (*qcmp_type) (const void *, const void *);
 292   symbol **res = xmemdup (symbols, nsyms * sizeof *res);
 293   qsort (res, nsyms, sizeof *res, (qcmp_type) &symbol_type_name_cmp);
 294   return res;
 295 }
 296
 297
 298 /*------------------------------------------------------------------.
 299 | Define b4_type_names, which is a list of (lists of the numbers of |
 300 | symbols with same type-name).                                     |
 301 `------------------------------------------------------------------*/
 302
 303 static void
 304 type_names_output (FILE *out)
 305 {
 306   int i;
 307   symbol **syms = symbols_by_type_name ();
 308   fputs ("m4_define([b4_type_names],\n[", out);
 309   for (i = 0; i < nsyms; /* nothing */)
 310     {
 311       // The index of the first symbol of the current type-name.
 312       int i0 = i;
 313       fputs (i ? ",\n[" : "[", out);
 314       for (; i < nsyms && syms[i]->type_name == syms[i0]->type_name; ++i)
 315         fprintf (out, "%s%d", i != i0 ? ", " : "", syms[i]->number);
 316       fputs ("]", out);
 317     }
 318   fputs ("])\n\n", out);
 319   free (syms);
 320 }
 321
 322
 323 /*-------------------------------------.
 324 | The list of all the symbol numbers.  |
 325 `-------------------------------------*/
 326
 327 static void
 328 symbol_numbers_output (FILE *out)
 329 {
 330   int i;
 331   fputs ("m4_define([b4_symbol_numbers],\n[", out);
 332   for (i = 0; i < nsyms; ++i)
 333     fprintf (out, "%s[%d]", i ? ", " : "", i);
 334   fputs ("])\n\n", out);
 335 }
 336
 337
 338 /*---------------------------------.
 339 | Output the user actions to OUT.  |
 340 `---------------------------------*/
 341
 342 static void
 343 user_actions_output (FILE *out)
 344 {
 345   rule_number r;
 346
 347   fputs ("m4_define([b4_actions], \n[", out);
 348   for (r = 0; r < nrules; ++r)
 349     if (rules[r].action)
 350       {
 351         fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
 352                  rules[r].action_location.start.line);
 353         escaped_output (out, rules[r].action_location.start.file);
 354         fprintf (out, ")\n[    %s]])\n\n", rules[r].action);
 355       }
 356   fputs ("])\n\n", out);
 357 }
 358
 359 /*------------------------------------.
 360 | Output the merge functions to OUT.  |
 361 `------------------------------------*/
 362
 363 static void
 364 merger_output (FILE *out)
 365 {
 366   int n;
 367   merger_list* p;
 368
 369   fputs ("m4_define([b4_mergers], \n[[", out);
 370   for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
 371     {
 372       if (p->type[0] == '\0')
 373         fprintf (out, "  case %d: *yy0 = %s (*yy0, *yy1); break;\n",
 374                  n, p->name);
 375       else
 376         fprintf (out, "  case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
 377                  n, p->type, p->name);
 378     }
 379   fputs ("]])\n\n", out);
 380 }
 381
 382
 383 /*---------------------------------------------.
 384 | Prepare the muscles for symbol definitions.  |
 385 `---------------------------------------------*/
 386
 387 static void
 388 prepare_symbol_definitions (void)
 389 {
 390   int i;
 391   for (i = 0; i < nsyms; ++i)
 392     {
 393       symbol *sym = symbols[i];
 394       const char *key;
 395       const char *value;
 396
 397 #define SET_KEY(Entry)                                                  \
 398       obstack_fgrow2 (&format_obstack, "symbol(%d, %s)", i, Entry);     \
 399       obstack_1grow (&format_obstack, 0);                               \
 400       key = obstack_finish (&format_obstack);
 401
 402       // Whether the symbol has an identifier.
 403       value = symbol_id_get (sym);
 404       SET_KEY("has_id");
 405       MUSCLE_INSERT_INT (key, !!value);
 406
 407       // Its identifier.
 408       SET_KEY("id");
 409       MUSCLE_INSERT_STRING (key, value ? value : "");
 410
 411       // Its tag.  Typically for documentation purpose.
 412       SET_KEY("tag");
 413       MUSCLE_INSERT_STRING (key, sym->tag);
 414
 415       SET_KEY("user_number");
 416       MUSCLE_INSERT_INT (key, sym->user_token_number);
 417
 418       SET_KEY("is_token");
 419       MUSCLE_INSERT_INT (key,
 420                          i < ntokens && sym != errtoken && sym != undeftoken);
 421
 422       SET_KEY("number");
 423       MUSCLE_INSERT_INT (key, sym->number);
 424
 425       SET_KEY("has_type");
 426       MUSCLE_INSERT_INT (key, !!sym->type_name);
 427
 428       SET_KEY("type");
 429       MUSCLE_INSERT_STRING (key, sym->type_name ? sym->type_name : "");
 430
 431 #undef SET_KEY
 432     }
 433 }
 434
 435
 436 /*--------------------------------------.
 437 | Output the tokens definition to OUT.  |
 438 `--------------------------------------*/
 439
 440 static void
 441 token_definitions_output (FILE *out)
 442 {
 443   int i;
 444   char const *sep = "";
 445
 446   fputs ("m4_define([b4_tokens], \n[", out);
 447   for (i = 0; i < ntokens; ++i)
 448     {
 449       symbol *sym = symbols[i];
 450       int number = sym->user_token_number;
 451
 452       /* At this stage, if there are literal aliases, they are part of
 453          SYMBOLS, so we should not find symbols which are the aliases
 454          here.  */
 455       aver (number != USER_NUMBER_ALIAS);
 456
 457       /* Skip error token.  */
 458       if (sym == errtoken)
 459         continue;
 460
 461       /* If this string has an alias, then it is necessarily the alias
 462          which is to be output.  */
 463       if (sym->alias)
 464         sym = sym->alias;
 465
 466       /* Don't output literal chars or strings (when defined only as a
 467          string).  Note that must be done after the alias resolution:
 468          think about `%token 'f' "f"'.  */
 469       if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
 470         continue;
 471
 472       /* Don't #define nonliteral tokens whose names contain periods
 473          or '$' (as does the default value of the EOF token).  */
 474       if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))
 475         continue;
 476
 477       fprintf (out, "%s[[[%s]], %d]",
 478                sep, sym->tag, number);
 479       sep = ",\n";
 480     }
 481   fputs ("])\n\n", out);
 482 }
 483
 484
 485 /*---------------------------------------------------.
 486 | Output the symbol destructors or printers to OUT.  |
 487 `---------------------------------------------------*/
 488
 489 static void
 490 symbol_code_props_output (FILE *out, char const *what,
 491                           code_props const *(*get)(symbol const *))
 492 {
 493   int i;
 494   char const *sep = "";
 495
 496   fputs ("m4_define([b4_symbol_", out);
 497   fputs (what, out);
 498   fputs ("], \n[", out);
 499   for (i = 0; i < nsyms; ++i)
 500     {
 501       symbol *sym = symbols[i];
 502       char const *code = (*get) (sym)->code;
 503       if (code)
 504         {
 505           location loc = (*get) (sym)->location;
 506           /* Filename, lineno,
 507              Symbol-name, Symbol-number,
 508              code, optional typename.  */
 509           fprintf (out, "%s[", sep);
 510           sep = ",\n";
 511           escaped_output (out, loc.start.file);
 512           fprintf (out, ", %d, ", loc.start.line);
 513           escaped_output (out, sym->tag);
 514           fprintf (out, ", %d, [[%s]]", sym->number, code);
 515           if (sym->type_name)
 516             fprintf (out, ", [[%s]]", sym->type_name);
 517           fputc (']', out);
 518         }
 519     }
 520   fputs ("])\n\n", out);
 521 }
 522
 523
 524 static void
 525 prepare_actions (void)
 526 {
 527   /* Figure out the actions for the specified state, indexed by
 528      lookahead token type.  */
 529
 530   muscle_insert_rule_number_table ("defact", yydefact,
 531                                    yydefact[0], 1, nstates);
 532
 533   /* Figure out what to do after reducing with each rule, depending on
 534      the saved state from before the beginning of parsing the data
 535      that matched this rule.  */
 536   muscle_insert_state_number_table ("defgoto", yydefgoto,
 537                                     yydefgoto[0], 1, nsyms - ntokens);
 538
 539
 540   /* Output PACT. */
 541   muscle_insert_base_table ("pact", base,
 542                              base[0], 1, nstates);
 543   MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
 544
 545   /* Output PGOTO. */
 546   muscle_insert_base_table ("pgoto", base,
 547                              base[nstates], nstates + 1, nvectors);
 548
 549   muscle_insert_base_table ("table", table,
 550                             table[0], 1, high + 1);
 551   MUSCLE_INSERT_INT ("table_ninf", table_ninf);
 552
 553   muscle_insert_base_table ("check", check,
 554                             check[0], 1, high + 1);
 555
 556   /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
 557      YYPACT) so that in states with unresolved conflicts, the default
 558      reduction is not used in the conflicted entries, so that there is
 559      a place to put a conflict pointer.
 560
 561      This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
 562      parser, so we could avoid accidents by not writing them out in
 563      that case.  Nevertheless, it seems even better to be able to use
 564      the GLR skeletons even without the non-deterministic tables.  */
 565   muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
 566                                     conflict_table[0], 1, high + 1);
 567   muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
 568                                     0, 1, conflict_list_cnt);
 569 }
 570
 571
 572 /*--------------------------------------------.
 573 | Output the definitions of all the muscles.  |
 574 `--------------------------------------------*/
 575
 576 static void
 577 muscles_output (FILE *out)
 578 {
 579   fputs ("m4_init()\n", out);
 580   merger_output (out);
 581   symbol_code_props_output (out, "destructors", &symbol_destructor_get);
 582   symbol_code_props_output (out, "printers", &symbol_printer_get);
 583   symbol_numbers_output (out);
 584   token_definitions_output (out);
 585   type_names_output (out);
 586   user_actions_output (out);
 587   // Must be last.
 588   muscles_m4_output (out);
 589 }
 590 \f
 591 /*---------------------------.
 592 | Call the skeleton parser.  |
 593 `---------------------------*/
 594
 595 static void
 596 output_skeleton (void)
 597 {
 598   FILE *in;
 599   int filter_fd[2];
 600   char const *argv[9];
 601   pid_t pid;
 602
 603   /* Compute the names of the package data dir and skeleton files.  */
 604   char const m4sugar[] = "m4sugar/m4sugar.m4";
 605   char const m4bison[] = "bison.m4";
 606   char *full_m4sugar;
 607   char *full_m4bison;
 608   char *full_skeleton;
 609   char const *p;
 610   char const *m4 = (p = getenv ("M4")) ? p : M4;
 611   char const *pkgdatadir = compute_pkgdatadir ();
 612   size_t skeleton_size = strlen (skeleton) + 1;
 613   size_t pkgdatadirlen = strlen (pkgdatadir);
 614   while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
 615     pkgdatadirlen--;
 616   full_skeleton = xmalloc (pkgdatadirlen + 1
 617                            + (skeleton_size < sizeof m4sugar
 618                               ? sizeof m4sugar : skeleton_size));
 619   strncpy (full_skeleton, pkgdatadir, pkgdatadirlen);
 620   full_skeleton[pkgdatadirlen] = '/';
 621   strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
 622   full_m4sugar = xstrdup (full_skeleton);
 623   strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
 624   full_m4bison = xstrdup (full_skeleton);
 625   if (strchr (skeleton, '/'))
 626     strcpy (full_skeleton, skeleton);
 627   else
 628     strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
 629
 630   /* Test whether m4sugar.m4 is readable, to check for proper
 631      installation.  A faulty installation can cause deadlock, so a
 632      cheap sanity check is worthwhile.  */
 633   xfclose (xfopen (full_m4sugar, "r"));
 634
 635   /* Create an m4 subprocess connected to us via two pipes.  */
 636
 637   if (trace_flag & trace_tools)
 638     fprintf (stderr, "running: %s %s - %s %s\n",
 639              m4, full_m4sugar, full_m4bison, full_skeleton);
 640
 641   /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
 642      position-dependent manner.  Keep it as the first argument so that all
 643      files are traced.
 644
 645      See the thread starting at
 646      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 647      for details.  */
 648   {
 649     int i = 0;
 650     argv[i++] = m4;
 651     argv[i++] = "-I";
 652     argv[i++] = pkgdatadir;
 653     if (trace_flag & trace_m4)
 654       argv[i++] = "-dV";
 655     argv[i++] = full_m4sugar;
 656     argv[i++] = "-";
 657     argv[i++] = full_m4bison;
 658     argv[i++] = full_skeleton;
 659     argv[i++] = NULL;
 660   }
 661   /* When POSIXLY_CORRECT is set, some future versions of GNU M4 (most likely
 662      2.0) may drop some of the GNU extensions that Bison's skeletons depend
 663      upon.  So that the next release of Bison is forward compatible with those
 664      future versions of GNU M4, we unset POSIXLY_CORRECT here.
 665
 666      FIXME: A user might set POSIXLY_CORRECT to affect processes run from
 667      macros like m4_syscmd in a custom skeleton.  For now, Bison makes no
 668      promises about the behavior of custom skeletons, so this scenario is not a
 669      concern.  However, we eventually want to eliminate this shortcoming.  The
 670      next release of GNU M4 (1.4.12 or 1.6) will accept the -g command-line
 671      option as a no-op, and later releases will accept it to indicate that
 672      POSIXLY_CORRECT should be ignored.  Once the GNU M4 versions that accept
 673      -g are pervasive, Bison should use -g instead of unsetting
 674      POSIXLY_CORRECT.
 675
 676      See the thread starting at
 677      <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
 678      for details.  */
 679   unsetenv ("POSIXLY_CORRECT");
 680   init_subpipe ();
 681   pid = create_subpipe (argv, filter_fd);
 682   free (full_m4sugar);
 683   free (full_m4bison);
 684   free (full_skeleton);
 685
 686   if (trace_flag & trace_muscles)
 687     muscles_output (stderr);
 688   {
 689     FILE *out = fdopen (filter_fd[0], "w");
 690     if (! out)
 691       error (EXIT_FAILURE, get_errno (),
 692              "fdopen");
 693     muscles_output (out);
 694     xfclose (out);
 695   }
 696
 697   /* Read and process m4's output.  */
 698   timevar_push (TV_M4);
 699   end_of_output_subpipe (pid, filter_fd);
 700   in = fdopen (filter_fd[1], "r");
 701   if (! in)
 702     error (EXIT_FAILURE, get_errno (),
 703            "fdopen");
 704   scan_skel (in);
 705   xfclose (in);
 706   reap_subpipe (pid, m4);
 707   timevar_pop (TV_M4);
 708 }
 709
 710 static void
 711 prepare (void)
 712 {
 713   /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
 714      for the user.  */
 715   char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
 716   bool use_push_for_pull_flag = false;
 717   if (use_push_for_pull_env != NULL
 718       && use_push_for_pull_env[0] != '\0'
 719       && 0 != strcmp (use_push_for_pull_env, "0"))
 720     use_push_for_pull_flag = true;
 721
 722   /* Flags. */
 723   MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
 724   MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
 725   MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
 726   MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
 727   MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
 728   MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
 729   MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
 730   MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
 731   MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
 732   MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
 733
 734   /* File names.  */
 735   if (spec_name_prefix)
 736     MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
 737
 738   MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
 739
 740 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
 741   DEFINE (dir_prefix);
 742   DEFINE (parser_file_name);
 743   DEFINE (spec_defines_file);
 744   DEFINE (spec_file_prefix);
 745   DEFINE (spec_graph_file);
 746   DEFINE (spec_name_prefix);
 747   DEFINE (spec_outfile);
 748   DEFINE (spec_verbose_file);
 749 #undef DEFINE
 750
 751   /* Find the right skeleton file, and add muscles about the skeletons.  */
 752   if (skeleton)
 753     MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
 754   else
 755     skeleton = language->skeleton;
 756
 757   /* About the skeletons.  */
 758   {
 759     /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
 760        would never be expanded.  Hopefully no one has M4-special characters in
 761        his Bison installation path.  */
 762     MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
 763   }
 764 }
 765
 766
 767 /*----------------------------------------------------------.
 768 | Output the parsing tables and the parser code to ftable.  |
 769 `----------------------------------------------------------*/
 770
 771 void
 772 output (void)
 773 {
 774   obstack_init (&format_obstack);
 775
 776   prepare_symbols ();
 777   prepare_rules ();
 778   prepare_states ();
 779   prepare_actions ();
 780   prepare_symbol_definitions ();
 781
 782   prepare ();
 783
 784   /* Process the selected skeleton file.  */
 785   output_skeleton ();
 786
 787   obstack_free (&format_obstack, NULL);
 788 }
 789
 790 char const *
 791 compute_pkgdatadir (void)
 792 {
 793   char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
 794   return pkgdatadir ? pkgdatadir : PKGDATADIR;
 795 }