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