1 /* Output the generated parsing program for Bison.
2
3 Copyright (C) 1984, 1986, 1989, 1992, 2000-2015, 2018-2021 Free
4 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 <https://www.gnu.org/licenses/>. */
20
21 #include <config.h>
22 #include "system.h"
23
24 #include <filename.h> /* IS_PATH_WITH_DIR */
25 #include <get-errno.h>
26 #include <mbswidth.h>
27 #include <path-join.h>
28 #include <quotearg.h>
29 #include <spawn-pipe.h>
30 #include <timevar.h>
31 #include <wait-process.h>
32
33 #include "complain.h"
34 #include "files.h"
35 #include "getargs.h"
36 #include "gram.h"
37 #include "muscle-tab.h"
38 #include "output.h"
39 #include "reader.h"
40 #include "reduce.h"
41 #include "scan-code.h" /* max_left_semantic_context */
42 #include "scan-skel.h"
43 #include "symtab.h"
44 #include "tables.h"
45 #include "strversion.h"
46
47 static struct obstack format_obstack;
48
49
50 /*-------------------------------------------------------------------.
51 | Create a function NAME which associates to the muscle NAME the |
52 | result of formatting the FIRST and then TABLE_DATA[BEGIN..END[ (of |
53 | TYPE), and to the muscle NAME_max, the max value of the |
54 | TABLE_DATA. |
55 | |
56 | For the typical case of outputting a complete table from 0, pass |
57 | TABLE[0] as FIRST, and 1 as BEGIN. For instance |
58 | muscle_insert_base_table ("pact", base, base[0], 1, nstates); |
59 `-------------------------------------------------------------------*/
60
61
62 #define GENERATE_MUSCLE_INSERT_TABLE(Name, Type) \
63 \
64 static void \
65 Name (char const *name, Type *table_data, Type first, \
66 int begin, int end) \
67 { \
68 Type min = first; \
69 Type max = first; \
70 int j = 1; \
71 \
72 obstack_printf (&format_obstack, "%6d", first); \
73 for (int i = begin; i < end; ++i) \
74 { \
75 obstack_1grow (&format_obstack, ','); \
76 if (j >= 10) \
77 { \
78 obstack_sgrow (&format_obstack, "\n "); \
79 j = 1; \
80 } \
81 else \
82 ++j; \
83 obstack_printf (&format_obstack, "%6d", table_data[i]); \
84 if (table_data[i] < min) \
85 min = table_data[i]; \
86 if (max < table_data[i]) \
87 max = table_data[i]; \
88 } \
89 muscle_insert (name, obstack_finish0 (&format_obstack)); \
90 \
91 long lmin = min; \
92 long lmax = max; \
93 /* Build 'NAME_min' and 'NAME_max' in the obstack. */ \
94 obstack_printf (&format_obstack, "%s_min", name); \
95 MUSCLE_INSERT_LONG_INT (obstack_finish0 (&format_obstack), lmin); \
96 obstack_printf (&format_obstack, "%s_max", name); \
97 MUSCLE_INSERT_LONG_INT (obstack_finish0 (&format_obstack), lmax); \
98 }
99
100 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_int_table, int)
101 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_base_table, base_number)
102 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_rule_number_table, rule_number)
103 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_symbol_number_table, symbol_number)
104 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_item_number_table, item_number)
105 GENERATE_MUSCLE_INSERT_TABLE (muscle_insert_state_number_table, state_number)
106
107 /*----------------------------------------------------------------.
108 | Print to OUT a representation of CP quoted and escaped for M4. |
109 `----------------------------------------------------------------*/
110
111 static void
112 output_escaped (FILE *out, const char *cp)
113 {
114 for (; *cp; cp++)
115 switch (*cp)
116 {
117 case '$': fputs ("$][", out); break;
118 case '@': fputs ("@@", out); break;
119 case '[': fputs ("@{", out); break;
120 case ']': fputs ("@}", out); break;
121 default: fputc (*cp, out); break;
122 }
123 }
124
125 static void
126 output_quoted (FILE *out, char const *cp)
127 {
128 fprintf (out, "[[");
129 output_escaped (out, cp);
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
139 string_output (FILE *out, char const *string)
140 {
141 output_quoted (out, quotearg_style (c_quoting_style, string));
142 }
143
144
145 /* Store in BUFFER a copy of SRC where trigraphs are escaped, return
146 the size of the result (including the final NUL). If called with
147 BUFFERSIZE = 0, returns the needed size for BUFFER. */
148 static ptrdiff_t
149 escape_trigraphs (char *buffer, ptrdiff_t buffersize, const char *src)
150 {
151 #define STORE(c) \
152 do \
153 { \
154 if (res < buffersize) \
155 buffer[res] = (c); \
156 ++res; \
157 } \
158 while (0)
159 ptrdiff_t res = 0;
160 for (ptrdiff_t i = 0, len = strlen (src); i < len; ++i)
161 {
162 if (i + 2 < len
163 && src[i] == '?' && src[i+1] == '?')
164 {
165 switch (src[i+2])
166 {
167 case '!': case '\'':
168 case '(': case ')': case '-': case '/':
169 case '<': case '=': case '>':
170 i += 1;
171 STORE ('?');
172 STORE ('"');
173 STORE ('"');
174 STORE ('?');
175 continue;
176 }
177 }
178 STORE (src[i]);
179 }
180 STORE ('\0');
181 #undef STORE
182 return res;
183 }
184
185 /* Same as xstrdup, except that trigraphs are escaped. */
186 static char *
187 xescape_trigraphs (const char *src)
188 {
189 ptrdiff_t bufsize = escape_trigraphs (NULL, 0, src);
190 char *buf = xcharalloc (bufsize);
191 escape_trigraphs (buf, bufsize, src);
192 return buf;
193 }
194
195 /* The tag to show in the generated parsers. Use "end of file" rather
196 than "$end". But keep "$end" in the reports, it's shorter and more
197 consistent. Support i18n if the user already uses it. */
198 static const char *
199 symbol_tag (const symbol *sym)
200 {
201 const bool eof_is_user_defined
202 = !eoftoken->alias || STRNEQ (eoftoken->alias->tag, "$end");
203
204 if (!eof_is_user_defined && sym->content == eoftoken->content)
205 return "\"end of file\"";
206 else if (sym->content == undeftoken->content)
207 return "\"invalid token\"";
208 else
209 return sym->tag;
210 }
211
212 /* Generate the b4_<MUSCLE_NAME> (e.g., b4_tname) table with the
213 symbol names (aka tags). */
214
215 static void
216 prepare_symbol_names (char const *muscle_name)
217 {
218 // Whether to add a pair of quotes around the name.
219 const bool quote = STREQ (muscle_name, "tname");
220 bool has_translations = false;
221
222 /* We assume that the table will be output starting at column 2. */
223 int col = 2;
224 struct quoting_options *qo = clone_quoting_options (0);
225 set_quoting_style (qo, c_quoting_style);
226 set_quoting_flags (qo, QA_SPLIT_TRIGRAPHS);
227 for (int i = 0; i < nsyms; i++)
228 {
229 const char *tag = symbol_tag (symbols[i]);
230 bool translatable = !quote && symbols[i]->translatable;
231 if (translatable)
232 has_translations = true;
233
234 char *cp
235 = tag[0] == '"' && !quote
236 ? xescape_trigraphs (tag)
237 : quotearg_alloc (tag, -1, qo);
238 /* Width of the next token, including the two quotes, the
239 comma and the space. */
240 int width
241 = mbswidth (cp, 0) + 2
242 + (translatable ? strlen ("N_()") : 0);
243
244 if (col + width > 75)
245 {
246 obstack_sgrow (&format_obstack, "\n ");
247 col = 1;
248 }
249
250 if (i)
251 obstack_1grow (&format_obstack, ' ');
252 if (translatable)
253 obstack_sgrow (&format_obstack, "]b4_symbol_translate""([");
254 obstack_escape (&format_obstack, cp);
255 if (translatable)
256 obstack_sgrow (&format_obstack, "])[");
257 free (cp);
258 obstack_1grow (&format_obstack, ',');
259 col += width;
260 }
261 free (qo);
262 obstack_sgrow (&format_obstack, " ]b4_null[");
263
264 /* Finish table and store. */
265 muscle_insert (muscle_name, obstack_finish0 (&format_obstack));
266
267 /* Announce whether translation support is needed. */
268 MUSCLE_INSERT_BOOL ("has_translations_flag", has_translations);
269 }
270
271
272 /*------------------------------------------------------------------.
273 | Prepare the muscles related to the symbols: translate, tname, and |
274 | toknum. |
275 `------------------------------------------------------------------*/
276
277 static void
278 prepare_symbols (void)
279 {
280 MUSCLE_INSERT_INT ("tokens_number", ntokens);
281 MUSCLE_INSERT_INT ("nterms_number", nnterms);
282 MUSCLE_INSERT_INT ("symbols_number", nsyms);
283 MUSCLE_INSERT_INT ("code_max", max_code);
284
285 muscle_insert_symbol_number_table ("translate",
286 token_translations,
287 token_translations[0],
288 1, max_code + 1);
289
290 /* tname -- token names. */
291 prepare_symbol_names ("tname");
292 prepare_symbol_names ("symbol_names");
293
294 /* translatable -- whether a token is translatable. */
295 {
296 bool translatable = false;
297 for (int i = 0; i < ntokens; ++i)
298 if (symbols[i]->translatable)
299 {
300 translatable = true;
301 break;
302 }
303 if (translatable)
304 {
305 int *values = xnmalloc (nsyms, sizeof *values);
306 for (int i = 0; i < ntokens; ++i)
307 values[i] = symbols[i]->translatable;
308 muscle_insert_int_table ("translatable", values,
309 values[0], 1, ntokens);
310 free (values);
311 }
312 }
313
314 /* Output YYTOKNUM. */
315 {
316 int *values = xnmalloc (ntokens, sizeof *values);
317 for (int i = 0; i < ntokens; ++i)
318 values[i] = symbols[i]->content->code;
319 muscle_insert_int_table ("toknum", values,
320 values[0], 1, ntokens);
321 free (values);
322 }
323 }
324
325
326 /*-------------------------------------------------------------.
327 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
328 | rline, dprec, merger, immediate. |
329 `-------------------------------------------------------------*/
330
331 static void
332 prepare_rules (void)
333 {
334 int *prhs = xnmalloc (nrules, sizeof *prhs);
335 item_number *rhs = xnmalloc (nritems, sizeof *rhs);
336 int *rline = xnmalloc (nrules, sizeof *rline);
337 symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
338 int *r2 = xnmalloc (nrules, sizeof *r2);
339 int *dprec = xnmalloc (nrules, sizeof *dprec);
340 int *merger = xnmalloc (nrules, sizeof *merger);
341 int *immediate = xnmalloc (nrules, sizeof *immediate);
342
343 /* Index in RHS. */
344 int i = 0;
345 for (rule_number r = 0; r < nrules; ++r)
346 {
347 /* Index of rule R in RHS. */
348 prhs[r] = i;
349 /* RHS of the rule R. */
350 for (item_number *rhsp = rules[r].rhs; 0 <= *rhsp; ++rhsp)
351 rhs[i++] = *rhsp;
352 /* Separator in RHS. */
353 rhs[i++] = -1;
354
355 /* Line where rule was defined. */
356 rline[r] = rules[r].location.start.line;
357 /* LHS of the rule R. */
358 r1[r] = rules[r].lhs->number;
359 /* Length of rule R's RHS. */
360 r2[r] = rule_rhs_length (&rules[r]);
361 /* Dynamic precedence (GLR). */
362 dprec[r] = rules[r].dprec;
363 /* Merger-function index (GLR). */
364 merger[r] = rules[r].merger;
365 /* Immediate reduction flags (GLR). */
366 immediate[r] = rules[r].is_predicate;
367 }
368 aver (i == nritems);
369
370 muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
371 muscle_insert_int_table ("prhs", prhs, 0, 0, nrules);
372 muscle_insert_int_table ("rline", rline, 0, 0, nrules);
373 muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
374 muscle_insert_int_table ("r2", r2, 0, 0, nrules);
375 muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
376 muscle_insert_int_table ("merger", merger, 0, 0, nrules);
377 muscle_insert_int_table ("immediate", immediate, 0, 0, nrules);
378
379 MUSCLE_INSERT_INT ("rules_number", nrules);
380 MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
381
382 free (prhs);
383 free (rhs);
384 free (rline);
385 free (r1);
386 free (r2);
387 free (dprec);
388 free (merger);
389 free (immediate);
390 }
391
392 /*--------------------------------------------.
393 | Prepare the muscles related to the states. |
394 `--------------------------------------------*/
395
396 static void
397 prepare_states (void)
398 {
399 symbol_number *values = xnmalloc (nstates, sizeof *values);
400 for (state_number i = 0; i < nstates; ++i)
401 values[i] = states[i]->accessing_symbol;
402 muscle_insert_symbol_number_table ("stos", values,
403 0, 1, nstates);
404 free (values);
405
406 MUSCLE_INSERT_INT ("last", high);
407 MUSCLE_INSERT_INT ("final_state_number", final_state->number);
408 MUSCLE_INSERT_INT ("states_number", nstates);
409 }
410
411
412 /*-------------------------------------------------------.
413 | Compare two symbols by type-name, and then by number. |
414 `-------------------------------------------------------*/
415
416 static int
417 symbol_type_name_cmp (const symbol **lhs, const symbol **rhs)
418 {
419 int res = uniqstr_cmp ((*lhs)->content->type_name, (*rhs)->content->type_name);
420 if (!res)
421 res = (*lhs)->content->number - (*rhs)->content->number;
422 return res;
423 }
424
425
426 /*----------------------------------------------------------------.
427 | Return a (malloc'ed) table of the symbols sorted by type-name. |
428 `----------------------------------------------------------------*/
429
430 static symbol **
431 symbols_by_type_name (void)
432 {
433 typedef int (*qcmp_type) (const void *, const void *);
434 symbol **res = xmemdup (symbols, nsyms * sizeof *res);
435 qsort (res, nsyms, sizeof *res, (qcmp_type) &symbol_type_name_cmp);
436 return res;
437 }
438
439
440 /*------------------------------------------------------------------.
441 | Define b4_type_names, which is a list of (lists of the numbers of |
442 | symbols with same type-name). |
443 `------------------------------------------------------------------*/
444
445 static void
446 type_names_output (FILE *out)
447 {
448 symbol **syms = symbols_by_type_name ();
449 fputs ("m4_define([b4_type_names],\n[", out);
450 for (int i = 0; i < nsyms; /* nothing */)
451 {
452 /* The index of the first symbol of the current type-name. */
453 int i0 = i;
454 fputs (i ? ",\n[" : "[", out);
455 for (; i < nsyms
456 && syms[i]->content->type_name == syms[i0]->content->type_name; ++i)
457 fprintf (out, "%s%d", i != i0 ? ", " : "", syms[i]->content->number);
458 fputs ("]", out);
459 }
460 fputs ("])\n\n", out);
461 free (syms);
462 }
463
464
465 /* Define the list of start symbols *if* there are several. Define
466 them by pairs: [START-SYMBOL-NUM, SWITCHING-TOKEN-SYMBOL-NUM]. */
467 static void
468 start_symbols_output (FILE *out)
469 {
470 if (start_symbols && start_symbols->next)
471 {
472 fputs ("m4_define([b4_start_symbols],\n[", out);
473 for (symbol_list *list = start_symbols; list; list = list->next)
474 {
475 const symbol *start = list->content.sym;
476 const symbol *swtok = switching_token (start);
477 fprintf (out, "%s[%d, %d]",
478 list == start_symbols ? "" : ", ",
479 start->content->number, swtok->content->number);
480 }
481 fputs ("])\n\n", out);
482 }
483 }
484
485
486 /*-------------------------------------.
487 | The list of all the symbol numbers. |
488 `-------------------------------------*/
489
490 static void
491 symbol_numbers_output (FILE *out)
492 {
493 fputs ("m4_define([b4_symbol_numbers],\n[", out);
494 for (int i = 0; i < nsyms; ++i)
495 fprintf (out, "%s[%d]", i ? ", " : "", i);
496 fputs ("])\n\n", out);
497 }
498
499
500 /*-------------------------------------------.
501 | Output the user reduction actions to OUT. |
502 `-------------------------------------------*/
503
504 static void
505 rule_output (const rule *r, FILE *out)
506 {
507 output_escaped (out, r->lhs->symbol->tag);
508 fputc (':', out);
509 if (0 <= *r->rhs)
510 for (item_number *rhsp = r->rhs; 0 <= *rhsp; ++rhsp)
511 {
512 fputc (' ', out);
513 output_escaped (out, symbols[*rhsp]->tag);
514 }
515 else
516 fputs (" %empty", out);
517 }
518
519 static void
520 user_actions_output (FILE *out)
521 {
522 fputs ("m4_define([b4_actions], \n[", out);
523 for (rule_number r = 0; r < nrules; ++r)
524 if (rules[r].action)
525 {
526 /* The useless "" is there to pacify syntax-check. */
527 fprintf (out, "%s""(%d, [",
528 rules[r].is_predicate ? "b4_predicate_case" : "b4_case",
529 r + 1);
530 if (!no_lines_flag)
531 {
532 fprintf (out, "b4_syncline(%d, ",
533 rules[r].action_loc.start.line);
534 string_output (out, map_file_name (rules[r].action_loc.start.file));
535 fprintf (out, ")dnl\n");
536 }
537 fprintf (out, "[%*s%s]],\n[[",
538 rules[r].action_loc.start.column - 1, "",
539 rules[r].action);
540 rule_output (&rules[r], out);
541 fprintf (out, "]])\n\n");
542 }
543 fputs ("])\n\n", out);
544 }
545
546 /*------------------------------------.
547 | Output the merge functions to OUT. |
548 `------------------------------------*/
549
550 static void
551 merger_output (FILE *out)
552 {
553 fputs ("m4_define([b4_mergers], \n[[", out);
554 int n;
555 merger_list* p;
556 for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
557 fprintf (out, "]b4_call_merger""([%d], [%s], [%d])[\n",
558 n, p->name, p->sym->content->number);
559 fputs ("]])\n\n", out);
560 }
561
562
563 /*---------------------------------------------.
564 | Prepare the muscles for symbol definitions. |
565 `---------------------------------------------*/
566
567 static void
568 prepare_symbol_definitions (void)
569 {
570 /* Map "orig NUM" to new numbers. See data/README. */
571 for (symbol_number i = ntokens; i < nsyms + nuseless_nonterminals; ++i)
572 {
573 obstack_printf (&format_obstack, "symbol""(orig %d, number)", i);
574 const char *key = obstack_finish0 (&format_obstack);
575 MUSCLE_INSERT_INT (key, nterm_map ? nterm_map[i - ntokens] : i);
576 }
577
578 for (int i = 0; i < nsyms; ++i)
579 {
580 symbol *sym = symbols[i];
581 const char *key;
582
583 #define SET_KEY(Entry) \
584 obstack_printf (&format_obstack, "symbol""(%d, %s)", \
585 i, Entry); \
586 key = obstack_finish0 (&format_obstack);
587
588 #define SET_KEY2(Entry, Suffix) \
589 obstack_printf (&format_obstack, "symbol""(%d, %s_%s)", \
590 i, Entry, Suffix); \
591 key = obstack_finish0 (&format_obstack);
592
593 /* Whether the symbol has an identifier. */
594 const char *id = symbol_id_get (sym);
595 SET_KEY ("has_id");
596 MUSCLE_INSERT_INT (key, !!id);
597
598 /* Its identifier. */
599 SET_KEY ("id");
600 MUSCLE_INSERT_STRING (key, id ? id : "");
601
602 /* Its tag. Typically for documentation purpose. */
603 SET_KEY ("tag");
604 MUSCLE_INSERT_STRING (key, symbol_tag (sym));
605
606 SET_KEY ("code");
607 MUSCLE_INSERT_INT (key, sym->content->code);
608
609 SET_KEY ("is_token");
610 MUSCLE_INSERT_INT (key, i < ntokens);
611
612 SET_KEY ("number");
613 MUSCLE_INSERT_INT (key, sym->content->number);
614
615 SET_KEY ("has_type");
616 MUSCLE_INSERT_INT (key, !!sym->content->type_name);
617
618 SET_KEY ("type");
619 MUSCLE_INSERT_STRING (key, sym->content->type_name
620 ? sym->content->type_name : "");
621
622 for (int j = 0; j < CODE_PROPS_SIZE; ++j)
623 {
624 /* "printer", not "%printer". */
625 char const *pname = code_props_type_string (j) + 1;
626 code_props const *p = symbol_code_props_get (sym, j);
627 SET_KEY2 ("has", pname);
628 MUSCLE_INSERT_INT (key, !!p->code);
629
630 if (p->code)
631 {
632 SET_KEY2 (pname, "file");
633 MUSCLE_INSERT_C_STRING (key, map_file_name (p->location.start.file));
634
635 SET_KEY2 (pname, "line");
636 MUSCLE_INSERT_INT (key, p->location.start.line);
637
638 SET_KEY2 (pname, "loc");
639 muscle_location_grow (key, p->location);
640
641 SET_KEY (pname);
642 obstack_printf (&muscle_obstack,
643 "%*s%s", p->location.start.column - 1, "", p->code);
644 muscle_insert (key, obstack_finish0 (&muscle_obstack));
645 }
646 }
647 #undef SET_KEY2
648 #undef SET_KEY
649 }
650 }
651
652
653 static void
654 prepare_actions (void)
655 {
656 /* Figure out the actions for the specified state. */
657 muscle_insert_rule_number_table ("defact", yydefact,
658 yydefact[0], 1, nstates);
659
660 /* Figure out what to do after reducing with each rule, depending on
661 the saved state from before the beginning of parsing the data
662 that matched this rule. */
663 muscle_insert_state_number_table ("defgoto", yydefgoto,
664 yydefgoto[0], 1, nsyms - ntokens);
665
666
667 /* Output PACT. */
668 muscle_insert_base_table ("pact", base,
669 base[0], 1, nstates);
670 MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
671
672 /* Output PGOTO. */
673 muscle_insert_base_table ("pgoto", base,
674 base[nstates], nstates + 1, nvectors);
675
676 muscle_insert_base_table ("table", table,
677 table[0], 1, high + 1);
678 MUSCLE_INSERT_INT ("table_ninf", table_ninf);
679
680 muscle_insert_base_table ("check", check,
681 check[0], 1, high + 1);
682
683 /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
684 YYPACT) so that in states with unresolved conflicts, the default
685 reduction is not used in the conflicted entries, so that there is
686 a place to put a conflict pointer.
687
688 This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
689 parser, so we could avoid accidents by not writing them out in
690 that case. Nevertheless, it seems even better to be able to use
691 the GLR skeletons even without the non-deterministic tables. */
692 muscle_insert_int_table ("conflict_list_heads", conflict_table,
693 conflict_table[0], 1, high + 1);
694 muscle_insert_int_table ("conflicting_rules", conflict_list,
695 0, 1, conflict_list_cnt);
696 }
697
698
699 /*--------------------------------------------.
700 | Output the definitions of all the muscles. |
701 `--------------------------------------------*/
702
703 static void
704 muscles_output (FILE *out)
705 {
706 fputs ("m4_init()\n", out);
707 merger_output (out);
708 symbol_numbers_output (out);
709 type_names_output (out);
710 start_symbols_output (out);
711 user_actions_output (out);
712 /* Must be last. */
713 muscles_m4_output (out);
714 }
715
716 /*---------------------------.
717 | Call the skeleton parser. |
718 `---------------------------*/
719
720 static void
721 output_skeleton (void)
722 {
723 /* Compute the names of the package data dir and skeleton files. */
724 char const *m4 = m4path ();
725 char const *datadir = pkgdatadir ();
726 char *skeldir = xpath_join (datadir, "skeletons");
727 char *m4sugar = xpath_join (datadir, "m4sugar/m4sugar.m4");
728 char *m4bison = xpath_join (skeldir, "bison.m4");
729 char *traceon = xpath_join (skeldir, "traceon.m4");
730 char *skel = (IS_PATH_WITH_DIR (skeleton)
731 ? xstrdup (skeleton)
732 : xpath_join (skeldir, skeleton));
733
734 /* Test whether m4sugar.m4 is readable, to check for proper
735 installation. A faulty installation can cause deadlock, so a
736 cheap sanity check is worthwhile. */
737 xfclose (xfopen (m4sugar, "r"));
738
739 /* Create an m4 subprocess connected to us via two pipes. */
740
741 int filter_fd[2];
742 pid_t pid;
743 {
744 char const *argv[11];
745 int i = 0;
746 argv[i++] = m4;
747
748 /* When POSIXLY_CORRECT is set, GNU M4 1.6 and later disable GNU
749 extensions, which Bison's skeletons depend on. With older M4,
750 it has no effect. M4 1.4.12 added a -g/--gnu command-line
751 option to make it explicit that a program wants GNU M4
752 extensions even when POSIXLY_CORRECT is set.
753
754 See the thread starting at
755 <https://lists.gnu.org/r/bug-bison/2008-07/msg00000.html>
756 for details. */
757 if (*M4_GNU_OPTION)
758 argv[i++] = M4_GNU_OPTION;
759
760 argv[i++] = "-I";
761 argv[i++] = datadir;
762 /* Some future version of GNU M4 (most likely 1.6) may treat the
763 -dV in a position-dependent manner. See the thread starting at
764 <https://lists.gnu.org/r/bug-bison/2008-07/msg00000.html>
765 for details. */
766 if (trace_flag & trace_m4_early)
767 argv[i++] = "-dV";
768 argv[i++] = m4sugar;
769 argv[i++] = "-";
770 argv[i++] = m4bison;
771 if (trace_flag & trace_m4)
772 argv[i++] = traceon;
773 argv[i++] = skel;
774 argv[i++] = NULL;
775 aver (i <= ARRAY_CARDINALITY (argv));
776
777 if (trace_flag & trace_tools)
778 {
779 fputs ("running:", stderr);
780 for (int j = 0; argv[j]; ++j)
781 fprintf (stderr, " %s", argv[j]);
782 fputc ('\n', stderr);
783 }
784
785 pid = create_pipe_bidi ("m4", m4, argv,
786 /* directory */ NULL,
787 /* null_stderr */ false,
788 /* slave_process */ true,
789 /* exit_on_error */ true,
790 filter_fd);
791 }
792
793 free (skeldir);
794 free (m4sugar);
795 free (m4bison);
796 free (traceon);
797 free (skel);
798
799 if (trace_flag & trace_muscles)
800 muscles_output (stderr);
801 {
802 FILE *out = xfdopen (filter_fd[1], "w");
803 muscles_output (out);
804 xfclose (out);
805 }
806
807 /* Read and process m4's output. */
808 timevar_push (tv_m4);
809 {
810 FILE *in = xfdopen (filter_fd[0], "r");
811 scan_skel (in);
812 /* scan_skel should have read all of M4's output. Otherwise, when we
813 close the pipe, we risk letting M4 report a broken-pipe to the
814 Bison user. */
815 aver (feof (in));
816 xfclose (in);
817 }
818 wait_subprocess (pid, "m4", false, false, true, true, NULL);
819 timevar_pop (tv_m4);
820 }
821
822 static void
823 prepare (void)
824 {
825 /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be
826 documented for the user. */
827 char const *cp = getenv ("BISON_USE_PUSH_FOR_PULL");
828 bool use_push_for_pull_flag = cp && *cp && strtol (cp, 0, 10);
829
830 /* Versions. */
831 MUSCLE_INSERT_STRING ("version_string", VERSION);
832 MUSCLE_INSERT_INT ("version", strversion_to_int (VERSION));
833 MUSCLE_INSERT_INT ("required_version", required_version);
834
835 /* Flags. */
836 MUSCLE_INSERT_BOOL ("header_flag", header_flag);
837 MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
838 MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
839 MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
840 MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
841 MUSCLE_INSERT_BOOL ("token_table_flag", token_table_flag);
842 MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
843 MUSCLE_INSERT_BOOL ("yacc_flag", !location_empty (yacc_loc));
844
845 /* File names. */
846 if (spec_name_prefix)
847 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
848
849 MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
850
851 const char *spec_mapped_header_file = map_file_name (spec_header_file);
852 const char *mapped_dir_prefix = map_file_name (dir_prefix);
853
854 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
855 DEFINE (dir_prefix);
856 DEFINE (mapped_dir_prefix);
857 DEFINE (parser_file_name);
858 DEFINE (spec_header_file);
859 DEFINE (spec_mapped_header_file);
860 DEFINE (spec_file_prefix);
861 DEFINE (spec_graph_file);
862 DEFINE (spec_name_prefix);
863 DEFINE (spec_outfile);
864 DEFINE (spec_verbose_file);
865 #undef DEFINE
866
867 /* Find the right skeleton file, and add muscles about the skeletons. */
868 if (skeleton)
869 MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
870 else
871 skeleton = language->skeleton;
872
873 /* About the skeletons. */
874 {
875 /* b4_skeletonsdir is used inside m4_include in the skeletons, so digraphs
876 would never be expanded. Hopefully no one has M4-special characters in
877 his Bison installation path. */
878 char *skeldir = xpath_join (pkgdatadir (), "skeletons");
879 MUSCLE_INSERT_STRING_RAW ("skeletonsdir", skeldir);
880 free (skeldir);
881 }
882 }
883
884
885 /*----------------------------------------------------------.
886 | Output the parsing tables and the parser code to ftable. |
887 `----------------------------------------------------------*/
888
889 void
890 output (void)
891 {
892 obstack_init (&format_obstack);
893
894 prepare_symbols ();
895 prepare_rules ();
896 prepare_states ();
897 prepare_actions ();
898 prepare_symbol_definitions ();
899
900 prepare ();
901
902 /* Process the selected skeleton file. */
903 output_skeleton ();
904
905 /* If late errors were generated, destroy the generated source
906 files. */
907 if (complaint_status)
908 unlink_generated_sources ();
909
910 obstack_free (&format_obstack, NULL);
911 }