]> git.saurik.com Git - bison.git/blob - src/output.c
projects / bison.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Make previous patch more robust.
[bison.git] / 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, 2009 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 <assert.h>
25 #include <configmake.h>
26 #include <error.h>
27 #include <get-errno.h>
28 #include <quotearg.h>
29 #include <subpipe.h>
30 #include <timevar.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_state_number_table, state_number)
110
111
112 /*--------------------------------------------------------------------.
113 | Print to OUT a representation of STRING escaped both for C and M4. |
114 `--------------------------------------------------------------------*/
115
116 static void
117 escaped_output (FILE *out, char const *string)
118 {
119 char const *p;
120 fprintf (out, "[[");
121
122 for (p = quotearg_style (c_quoting_style, string); *p; p++)
123 switch (*p)
124 {
125 case '$': fputs ("$][", out); break;
126 case '@': fputs ("@@", out); break;
127 case '[': fputs ("@{", out); break;
128 case ']': fputs ("@}", out); break;
129 default: fputc (*p, out); break;
130 }
131
132 fprintf (out, "]]");
133 }
134
135
136 /*------------------------------------------------------------------.
137 | Prepare the muscles related to the symbols: translate, tname, and |
138 | toknum. |
139 `------------------------------------------------------------------*/
140
141 static void
142 prepare_symbols (void)
143 {
144 MUSCLE_INSERT_BOOL ("token_table", token_table_flag);
145 MUSCLE_INSERT_INT ("tokens_number", ntokens);
146 MUSCLE_INSERT_INT ("nterms_number", nvars);
147 MUSCLE_INSERT_INT ("symbols_number", nsyms);
148 MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
149 MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
150
151 muscle_insert_symbol_number_table ("translate",
152 token_translations,
153 token_translations[0],
154 1, max_user_token_number + 1);
155
156 /* tname -- token names. */
157 {
158 int i;
159 /* We assume that the table will be output starting at column 2. */
160 int j = 2;
161 struct quoting_options *qo = clone_quoting_options (0);
162 set_quoting_style (qo, c_quoting_style);
163 set_quoting_flags (qo, QA_SPLIT_TRIGRAPHS);
164 for (i = 0; i < nsyms; i++)
165 {
166 char *cp = quotearg_alloc (symbols[i]->tag, -1, qo);
167 /* Width of the next token, including the two quotes, the
168 comma and the space. */
169 int width = strlen (cp) + 2;
170
171 if (j + width > 75)
172 {
173 obstack_sgrow (&format_obstack, "\n ");
174 j = 1;
175 }
176
177 if (i)
178 obstack_1grow (&format_obstack, ' ');
179 MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
180 free (cp);
181 obstack_1grow (&format_obstack, ',');
182 j += width;
183 }
184 free (qo);
185 obstack_sgrow (&format_obstack, " ]b4_null[");
186
187 /* Finish table and store. */
188 obstack_1grow (&format_obstack, 0);
189 muscle_insert ("tname", obstack_finish (&format_obstack));
190 }
191
192 /* Output YYTOKNUM. */
193 {
194 int i;
195 int *values = xnmalloc (ntokens, sizeof *values);
196 for (i = 0; i < ntokens; ++i)
197 values[i] = symbols[i]->user_token_number;
198 muscle_insert_int_table ("toknum", values,
199 values[0], 1, ntokens);
200 free (values);
201 }
202 }
203
204
205 /*----------------------------------------------------------------.
206 | Prepare the muscles related to the rules: r1, r2, rline, dprec, |
207 | merger. |
208 `----------------------------------------------------------------*/
209
210 static void
211 prepare_rules (void)
212 {
213 unsigned int *rline = xnmalloc (nrules, sizeof *rline);
214 symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
215 unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
216 int *dprec = xnmalloc (nrules, sizeof *dprec);
217 int *merger = xnmalloc (nrules, sizeof *merger);
218
219 rule_number r;
220 for (r = 0; r < nrules; ++r)
221 {
222 /* LHS of the rule R. */
223 r1[r] = rules[r].lhs->number;
224 /* Length of rule R's RHS. */
225 r2[r] = rule_rhs_length(&rules[r]);
226 /* Line where rule was defined. */
227 rline[r] = rules[r].location.start.line;
228 /* Dynamic precedence (GLR). */
229 dprec[r] = rules[r].dprec;
230 /* Merger-function index (GLR). */
231 merger[r] = rules[r].merger;
232 }
233
234 muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
235 muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
236 muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
237 muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
238 muscle_insert_int_table ("merger", merger, 0, 0, nrules);
239
240 MUSCLE_INSERT_INT ("rules_number", nrules);
241 MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
242
243 free (rline);
244 free (r1);
245 free (r2);
246 free (dprec);
247 free (merger);
248 }
249
250 /*--------------------------------------------.
251 | Prepare the muscles related to the states. |
252 `--------------------------------------------*/
253
254 static void
255 prepare_states (void)
256 {
257 state_number i;
258 symbol_number *values = xnmalloc (nstates, sizeof *values);
259 for (i = 0; i < nstates; ++i)
260 values[i] = states[i]->accessing_symbol;
261 muscle_insert_symbol_number_table ("stos", values,
262 0, 1, nstates);
263 free (values);
264
265 MUSCLE_INSERT_INT ("last", high);
266 MUSCLE_INSERT_INT ("final_state_number", final_state->number);
267 MUSCLE_INSERT_INT ("states_number", nstates);
268 }
269
270
271 /*-------------------------------------------------------.
272 | Compare two symbols by type-name, and then by number. |
273 `-------------------------------------------------------*/
274
275 static int
276 symbol_type_name_cmp (const symbol **lhs, const symbol **rhs)
277 {
278 int res = UNIQSTR_CMP((*lhs)->type_name, (*rhs)->type_name);
279 if (res)
280 return res;
281 return (*lhs)->number - (*rhs)->number;
282 }
283
284
285 /*----------------------------------------------------------------.
286 | Return a (malloc'ed) table of the symbols sorted by type-name. |
287 `----------------------------------------------------------------*/
288
289 static symbol **
290 symbols_by_type_name (void)
291 {
292 typedef int (*qcmp_type) (const void *, const void *);
293 symbol **res = xmemdup (symbols, nsyms * sizeof *res);
294 qsort (res, nsyms, sizeof *res, (qcmp_type) &symbol_type_name_cmp);
295 return res;
296 }
297
298
299 /*------------------------------------------------------------------.
300 | Define b4_type_names, which is a list of (lists of the numbers of |
301 | symbols with same type-name). |
302 `------------------------------------------------------------------*/
303
304 static void
305 type_names_output (FILE *out)
306 {
307 int i;
308 symbol **syms = symbols_by_type_name ();
309 fputs ("m4_define([b4_type_names],\n[", out);
310 for (i = 0; i < nsyms; /* nothing */)
311 {
312 // The index of the first symbol of the current type-name.
313 int i0 = i;
314 fputs (i ? ",\n[" : "[", out);
315 for (; i < nsyms && syms[i]->type_name == syms[i0]->type_name; ++i)
316 fprintf (out, "%s%d", i != i0 ? ", " : "", syms[i]->number);
317 fputs ("]", out);
318 }
319 fputs ("])\n\n", out);
320 free (syms);
321 }
322
323
324 /*-------------------------------------.
325 | The list of all the symbol numbers. |
326 `-------------------------------------*/
327
328 static void
329 symbol_numbers_output (FILE *out)
330 {
331 int i;
332 fputs ("m4_define([b4_symbol_numbers],\n[", out);
333 for (i = 0; i < nsyms; ++i)
334 fprintf (out, "%s[%d]", i ? ", " : "", i);
335 fputs ("])\n\n", out);
336 }
337
338
339 /*---------------------------------.
340 | Output the user actions to OUT. |
341 `---------------------------------*/
342
343 static void
344 user_actions_output (FILE *out)
345 {
346 rule_number r;
347
348 fputs ("m4_define([b4_actions], \n[", out);
349 for (r = 0; r < nrules; ++r)
350 if (rules[r].action)
351 {
352 fprintf (out, "b4_case(%d, [b4_syncline(%d, ", r + 1,
353 rules[r].action_location.start.line);
354 escaped_output (out, rules[r].action_location.start.file);
355 fprintf (out, ")\n[ %s]])\n\n", rules[r].action);
356 }
357 fputs ("])\n\n", out);
358 }
359
360 /*------------------------------------.
361 | Output the merge functions to OUT. |
362 `------------------------------------*/
363
364 static void
365 merger_output (FILE *out)
366 {
367 int n;
368 merger_list* p;
369
370 fputs ("m4_define([b4_mergers], \n[[", out);
371 for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
372 {
373 if (p->type[0] == '\0')
374 fprintf (out, " case %d: *yy0 = %s (*yy0, *yy1); break;\n",
375 n, p->name);
376 else
377 fprintf (out, " case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
378 n, p->type, p->name);
379 }
380 fputs ("]])\n\n", out);
381 }
382
383
384 /*---------------------------------------------.
385 | Prepare the muscles for symbol definitions. |
386 `---------------------------------------------*/
387
388 static void
389 prepare_symbol_definitions (void)
390 {
391 int i;
392 for (i = 0; i < nsyms; ++i)
393 {
394 symbol *sym = symbols[i];
395 const char *key;
396 const char *value;
397
398 #define SET_KEY(Entry) \
399 obstack_fgrow2 (&format_obstack, "symbol(%d, %s)", i, Entry); \
400 obstack_1grow (&format_obstack, 0); \
401 key = obstack_finish (&format_obstack);
402
403 // Whether the symbol has an identifier.
404 value = symbol_id_get (sym);
405 SET_KEY("has_id");
406 MUSCLE_INSERT_INT (key, !!value);
407
408 // Its identifier.
409 SET_KEY("id");
410 MUSCLE_INSERT_STRING (key, value ? value : "");
411
412 // Its tag. Typically for documentation purpose.
413 SET_KEY("tag");
414 MUSCLE_INSERT_STRING (key, sym->tag);
415
416 SET_KEY("user_number");
417 MUSCLE_INSERT_INT (key, sym->user_token_number);
418
419 SET_KEY("is_token");
420 MUSCLE_INSERT_INT (key,
421 i < ntokens && sym != errtoken && sym != undeftoken);
422
423 SET_KEY("number");
424 MUSCLE_INSERT_INT (key, sym->number);
425
426 SET_KEY("has_type");
427 MUSCLE_INSERT_INT (key, !!sym->type_name);
428
429 SET_KEY("type");
430 MUSCLE_INSERT_STRING (key, sym->type_name ? sym->type_name : "");
431
432 #define CODE_PROP(PropName) \
433 do { \
434 code_props const *p = symbol_ ## PropName ## _get (sym); \
435 SET_KEY("has_" #PropName); \
436 MUSCLE_INSERT_INT (key, !!p->code); \
437 \
438 if (p->code) \
439 { \
440 SET_KEY(#PropName "_file"); \
441 MUSCLE_INSERT_STRING (key, p->location.start.file); \
442 \
443 SET_KEY(#PropName "_line"); \
444 MUSCLE_INSERT_INT (key, p->location.start.line); \
445 \
446 SET_KEY(#PropName); \
447 MUSCLE_INSERT_STRING_RAW (key, p->code); \
448 } \
449 } while (0)
450
451 CODE_PROP(destructor);
452 CODE_PROP(printer);
453 #undef CODE_PROP
454 #undef SET_KEY
455 }
456 }
457
458
459 /*--------------------------------------.
460 | Output the tokens definition to OUT. |
461 `--------------------------------------*/
462
463 static void
464 token_definitions_output (FILE *out)
465 {
466 int i;
467 char const *sep = "";
468
469 fputs ("m4_define([b4_tokens], \n[", out);
470 for (i = 0; i < ntokens; ++i)
471 {
472 symbol *sym = symbols[i];
473 int number = sym->user_token_number;
474 uniqstr id = symbol_id_get (sym);
475
476 /* At this stage, if there are literal string aliases, they are
477 part of SYMBOLS, so we should not find their aliased symbols
478 here. */
479 aver (number != USER_NUMBER_HAS_STRING_ALIAS);
480
481 /* Skip error token and tokens without identifier. */
482 if (sym != errtoken && id)
483 {
484 fprintf (out, "%s[[[%s]], %d]",
485 sep, id, number);
486 sep = ",\n";
487 }
488 }
489 fputs ("])\n\n", out);
490 }
491
492
493 static void
494 prepare_actions (void)
495 {
496 /* Figure out the actions for the specified state, indexed by
497 lookahead token type. */
498
499 muscle_insert_rule_number_table ("defact", yydefact,
500 yydefact[0], 1, nstates);
501
502 /* Figure out what to do after reducing with each rule, depending on
503 the saved state from before the beginning of parsing the data
504 that matched this rule. */
505 muscle_insert_state_number_table ("defgoto", yydefgoto,
506 yydefgoto[0], 1, nsyms - ntokens);
507
508
509 /* Output PACT. */
510 muscle_insert_base_table ("pact", base,
511 base[0], 1, nstates);
512 MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
513
514 /* Output PGOTO. */
515 muscle_insert_base_table ("pgoto", base,
516 base[nstates], nstates + 1, nvectors);
517
518 muscle_insert_base_table ("table", table,
519 table[0], 1, high + 1);
520 MUSCLE_INSERT_INT ("table_ninf", table_ninf);
521
522 muscle_insert_base_table ("check", check,
523 check[0], 1, high + 1);
524
525 /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
526 YYPACT) so that in states with unresolved conflicts, the default
527 reduction is not used in the conflicted entries, so that there is
528 a place to put a conflict pointer.
529
530 This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
531 parser, so we could avoid accidents by not writing them out in
532 that case. Nevertheless, it seems even better to be able to use
533 the GLR skeletons even without the non-deterministic tables. */
534 muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
535 conflict_table[0], 1, high + 1);
536 muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
537 0, 1, conflict_list_cnt);
538 }
539
540
541 /*--------------------------------------------.
542 | Output the definitions of all the muscles. |
543 `--------------------------------------------*/
544
545 static void
546 muscles_output (FILE *out)
547 {
548 fputs ("m4_init()\n", out);
549 merger_output (out);
550 symbol_numbers_output (out);
551 token_definitions_output (out);
552 type_names_output (out);
553 user_actions_output (out);
554 // Must be last.
555 muscles_m4_output (out);
556 }
557 \f
558 /*---------------------------.
559 | Call the skeleton parser. |
560 `---------------------------*/
561
562 static void
563 output_skeleton (void)
564 {
565 FILE *in;
566 int filter_fd[2];
567 char const *argv[10];
568 pid_t pid;
569
570 /* Compute the names of the package data dir and skeleton files. */
571 char const m4sugar[] = "m4sugar/m4sugar.m4";
572 char const m4bison[] = "bison.m4";
573 char *full_m4sugar;
574 char *full_m4bison;
575 char *full_skeleton;
576 char const *p;
577 char const *m4 = (p = getenv ("M4")) ? p : M4;
578 char const *pkgdatadir = compute_pkgdatadir ();
579 size_t skeleton_size = strlen (skeleton) + 1;
580 size_t pkgdatadirlen = strlen (pkgdatadir);
581 while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
582 pkgdatadirlen--;
583 full_skeleton = xmalloc (pkgdatadirlen + 1
584 + (skeleton_size < sizeof m4sugar
585 ? sizeof m4sugar : skeleton_size));
586 strncpy (full_skeleton, pkgdatadir, pkgdatadirlen);
587 full_skeleton[pkgdatadirlen] = '/';
588 strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
589 full_m4sugar = xstrdup (full_skeleton);
590 strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
591 full_m4bison = xstrdup (full_skeleton);
592 if (strchr (skeleton, '/'))
593 strcpy (full_skeleton, skeleton);
594 else
595 strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
596
597 /* Test whether m4sugar.m4 is readable, to check for proper
598 installation. A faulty installation can cause deadlock, so a
599 cheap sanity check is worthwhile. */
600 xfclose (xfopen (full_m4sugar, "r"));
601
602 /* Create an m4 subprocess connected to us via two pipes. */
603
604 if (trace_flag & trace_tools)
605 fprintf (stderr, "running: %s %s - %s %s\n",
606 m4, full_m4sugar, full_m4bison, full_skeleton);
607
608 /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
609 position-dependent manner. Keep it as the first argument so that all
610 files are traced.
611
612 See the thread starting at
613 <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
614 for details. */
615 {
616 int i = 0;
617 argv[i++] = m4;
618
619 /* When POSIXLY_CORRECT is set, GNU M4 1.6 and later disable GNU
620 extensions, which Bison's skeletons depend on. With older M4,
621 it has no effect. M4 1.4.12 added a -g/--gnu command-line
622 option to make it explicit that a program wants GNU M4
623 extensions even when POSIXLY_CORRECT is set.
624
625 See the thread starting at
626 <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
627 for details. */
628 if (*M4_GNU_OPTION)
629 argv[i++] = M4_GNU_OPTION;
630
631 argv[i++] = "-I";
632 argv[i++] = pkgdatadir;
633 if (trace_flag & trace_m4)
634 argv[i++] = "-dV";
635 argv[i++] = full_m4sugar;
636 argv[i++] = "-";
637 argv[i++] = full_m4bison;
638 argv[i++] = full_skeleton;
639 argv[i++] = NULL;
640 assert (i <= ARRAY_CARDINALITY (argv));
641 }
642
643 init_subpipe ();
644 pid = create_subpipe (argv, filter_fd);
645 free (full_m4sugar);
646 free (full_m4bison);
647 free (full_skeleton);
648
649 if (trace_flag & trace_muscles)
650 muscles_output (stderr);
651 {
652 FILE *out = fdopen (filter_fd[0], "w");
653 if (! out)
654 error (EXIT_FAILURE, get_errno (),
655 "fdopen");
656 muscles_output (out);
657 xfclose (out);
658 }
659
660 /* Read and process m4's output. */
661 timevar_push (TV_M4);
662 end_of_output_subpipe (pid, filter_fd);
663 in = fdopen (filter_fd[1], "r");
664 if (! in)
665 error (EXIT_FAILURE, get_errno (),
666 "fdopen");
667 scan_skel (in);
668 xfclose (in);
669 reap_subpipe (pid, m4);
670 timevar_pop (TV_M4);
671 }
672
673 static void
674 prepare (void)
675 {
676 /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
677 for the user. */
678 char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
679 bool use_push_for_pull_flag = false;
680 if (use_push_for_pull_env != NULL
681 && use_push_for_pull_env[0] != '\0'
682 && 0 != strcmp (use_push_for_pull_env, "0"))
683 use_push_for_pull_flag = true;
684
685 /* Flags. */
686 MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
687 MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
688 MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
689 MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
690 MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
691 MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
692 MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
693
694 /* File names. */
695 if (spec_name_prefix)
696 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
697
698 MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
699
700 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
701 DEFINE (dir_prefix);
702 DEFINE (parser_file_name);
703 DEFINE (spec_defines_file);
704 DEFINE (spec_file_prefix);
705 DEFINE (spec_graph_file);
706 DEFINE (spec_name_prefix);
707 DEFINE (spec_outfile);
708 DEFINE (spec_verbose_file);
709 #undef DEFINE
710
711 /* Find the right skeleton file, and add muscles about the skeletons. */
712 if (skeleton)
713 MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
714 else
715 skeleton = language->skeleton;
716
717 /* About the skeletons. */
718 {
719 /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
720 would never be expanded. Hopefully no one has M4-special characters in
721 his Bison installation path. */
722 MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
723 }
724 }
725
726
727 /*----------------------------------------------------------.
728 | Output the parsing tables and the parser code to ftable. |
729 `----------------------------------------------------------*/
730
731 void
732 output (void)
733 {
734 obstack_init (&format_obstack);
735
736 prepare_symbols ();
737 prepare_rules ();
738 prepare_states ();
739 prepare_actions ();
740 prepare_symbol_definitions ();
741
742 prepare ();
743
744 /* Process the selected skeleton file. */
745 output_skeleton ();
746
747 obstack_free (&format_obstack, NULL);
748 }
749
750 char const *
751 compute_pkgdatadir (void)
752 {
753 char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
754 return pkgdatadir ? pkgdatadir : PKGDATADIR;
755 }
bison