]> git.saurik.com Git - bison.git/blame - src/output.c
maint: re-anchor all .gitignore entries.
[bison.git] / src / output.c
CommitLineData
a932883e 1/* Output the generated parsing program for Bison.
87ceef73 2
7d424de1
PE
3 Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
c3e23647 5
9ee3c97b 6 This file is part of Bison, the GNU Compiler Compiler.
c3e23647 7
f16b0819
PE
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.
c3e23647 12
f16b0819
PE
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.
c3e23647 17
9ee3c97b 18 You should have received a copy of the GNU General Public License
f16b0819 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c3e23647 20
2cec9080 21#include <config.h>
c3e23647 22#include "system.h"
21fd22d6 23
3b2942e6 24#include <configmake.h>
21fd22d6
PE
25#include <error.h>
26#include <get-errno.h>
f39ab286 27#include <pipe.h>
21fd22d6 28#include <quotearg.h>
21fd22d6 29#include <timevar.h>
f39ab286 30#include <wait-process.h>
21fd22d6
PE
31
32#include "complain.h"
c3e23647 33#include "files.h"
21fd22d6 34#include "getargs.h"
c3e23647 35#include "gram.h"
00f5d575 36#include "muscle-tab.h"
6c89f1c1 37#include "output.h"
a70083a3 38#include "reader.h"
e9071366 39#include "scan-code.h" /* max_left_semantic_context */
04098407 40#include "scan-skel.h"
ad949da9 41#include "symtab.h"
c6f1a33c 42#include "tables.h"
be2a1a68 43
b0778bdd 44# define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
12b0043a 45
f87685c3 46static struct obstack format_obstack;
c3e23647 47
133c20e2 48
5372019f
AD
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`-------------------------------------------------------------------*/
62a3e4f0 55
62a3e4f0 56
5372019f 57#define GENERATE_MUSCLE_INSERT_TABLE(Name, Type) \
5fbb0954 58 \
5372019f 59static void \
9e0876fb 60Name (char const *name, \
5fbb0954
AD
61 Type *table_data, \
62 Type first, \
63 int begin, \
64 int end) \
65{ \
12b0043a 66 Type min = first; \
0c2d3f4c 67 Type max = first; \
87ceef73
PE
68 long int lmin; \
69 long int lmax; \
5fbb0954
AD
70 int i; \
71 int j = 1; \
72 \
5372019f 73 obstack_fgrow1 (&format_obstack, "%6d", first); \
5fbb0954
AD
74 for (i = begin; i < end; ++i) \
75 { \
5372019f 76 obstack_1grow (&format_obstack, ','); \
5fbb0954
AD
77 if (j >= 10) \
78 { \
5372019f 79 obstack_sgrow (&format_obstack, "\n "); \
5fbb0954
AD
80 j = 1; \
81 } \
82 else \
83 ++j; \
5372019f 84 obstack_fgrow1 (&format_obstack, "%6d", table_data[i]); \
12b0043a
AD
85 if (table_data[i] < min) \
86 min = table_data[i]; \
87 if (max < table_data[i]) \
5fbb0954
AD
88 max = table_data[i]; \
89 } \
5372019f
AD
90 obstack_1grow (&format_obstack, 0); \
91 muscle_insert (name, obstack_finish (&format_obstack)); \
5fbb0954 92 \
87ceef73
PE
93 lmin = min; \
94 lmax = max; \
12b0043a
AD
95 /* Build `NAME_min' and `NAME_max' in the obstack. */ \
96 obstack_fgrow1 (&format_obstack, "%s_min", name); \
97 obstack_1grow (&format_obstack, 0); \
87ceef73 98 MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin); \
5372019f
AD
99 obstack_fgrow1 (&format_obstack, "%s_max", name); \
100 obstack_1grow (&format_obstack, 0); \
87ceef73 101 MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax); \
62a3e4f0
AD
102}
103
5372019f 104GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
12b0043a 105GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)
21fd22d6
PE
106GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
107GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
108GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
21fd22d6 109GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
c3e23647
RS
110
111
05ac60f3
PE
112/*--------------------------------------------------------------------.
113| Print to OUT a representation of STRING escaped both for C and M4. |
114`--------------------------------------------------------------------*/
3813e141
PE
115
116static void
05ac60f3 117escaped_output (FILE *out, char const *string)
3813e141
PE
118{
119 char const *p;
2f4f028d 120 fprintf (out, "[[");
3813e141 121
05ac60f3 122 for (p = quotearg_style (c_quoting_style, string); *p; p++)
3813e141
PE
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
2f4f028d 132 fprintf (out, "]]");
3813e141
PE
133}
134
135
39912f52
AD
136/*------------------------------------------------------------------.
137| Prepare the muscles related to the symbols: translate, tname, and |
138| toknum. |
139`------------------------------------------------------------------*/
b0940840 140
4a120d45 141static void
39912f52 142prepare_symbols (void)
c3e23647 143{
141f5793 144 MUSCLE_INSERT_BOOL ("token_table", token_table_flag);
39912f52
AD
145 MUSCLE_INSERT_INT ("tokens_number", ntokens);
146 MUSCLE_INSERT_INT ("nterms_number", nvars);
d69c9694 147 MUSCLE_INSERT_INT ("symbols_number", nsyms);
39912f52
AD
148 MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
149 MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
150
a49aecd5 151 muscle_insert_symbol_number_table ("translate",
fc5734fe
AD
152 token_translations,
153 token_translations[0],
154 1, max_user_token_number + 1);
c3e23647 155
39912f52 156 /* tname -- token names. */
b0940840
AD
157 {
158 int i;
d423d460
AD
159 /* We assume that the table will be output starting at column 2. */
160 int j = 2;
1cfe6375
JD
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);
b0940840
AD
164 for (i = 0; i < nsyms; i++)
165 {
1cfe6375 166 char *cp = quotearg_alloc (symbols[i]->tag, -1, qo);
d423d460
AD
167 /* Width of the next token, including the two quotes, the
168 comma and the space. */
21fd22d6 169 int width = strlen (cp) + 2;
b0940840 170
21fd22d6 171 if (j + width > 75)
b0940840 172 {
d423d460
AD
173 obstack_sgrow (&format_obstack, "\n ");
174 j = 1;
b0940840
AD
175 }
176
d423d460
AD
177 if (i)
178 obstack_1grow (&format_obstack, ' ');
3813e141 179 MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
1cfe6375 180 free (cp);
d423d460 181 obstack_1grow (&format_obstack, ',');
21fd22d6 182 j += width;
b0940840 183 }
1cfe6375 184 free (qo);
8e1687ae 185 obstack_sgrow (&format_obstack, " ]b4_null[");
c3e23647 186
b0940840
AD
187 /* Finish table and store. */
188 obstack_1grow (&format_obstack, 0);
189 muscle_insert ("tname", obstack_finish (&format_obstack));
190 }
191
12b0043a 192 /* Output YYTOKNUM. */
b2ed6e58
AD
193 {
194 int i;
da2a7671 195 int *values = xnmalloc (ntokens, sizeof *values);
3650b4b8 196 for (i = 0; i < ntokens; ++i)
b0940840 197 values[i] = symbols[i]->user_token_number;
12b0043a 198 muscle_insert_int_table ("toknum", values,
3650b4b8 199 values[0], 1, ntokens);
b0940840 200 free (values);
b2ed6e58 201 }
b0940840 202}
b2ed6e58 203
b0940840 204
3d3bc1fe
AD
205/*----------------------------------------------------------------.
206| Prepare the muscles related to the rules: r1, r2, rline, dprec, |
ca2a6d15 207| merger, immediate. |
3d3bc1fe 208`----------------------------------------------------------------*/
b0940840
AD
209
210static void
211prepare_rules (void)
212{
da2a7671
PE
213 unsigned int *rline = xnmalloc (nrules, sizeof *rline);
214 symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
215 unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
f6fbd3da
PE
216 int *dprec = xnmalloc (nrules, sizeof *dprec);
217 int *merger = xnmalloc (nrules, sizeof *merger);
ca2a6d15 218 int *immediate = xnmalloc (nrules, sizeof *immediate);
4b3d3a8e 219
3d3bc1fe 220 rule_number r;
4b3d3a8e 221 for (r = 0; r < nrules; ++r)
b0940840 222 {
b0940840
AD
223 /* LHS of the rule R. */
224 r1[r] = rules[r].lhs->number;
225 /* Length of rule R's RHS. */
3d3bc1fe 226 r2[r] = rule_rhs_length(&rules[r]);
b0940840 227 /* Line where rule was defined. */
2073702c 228 rline[r] = rules[r].location.start.line;
95612cfa 229 /* Dynamic precedence (GLR). */
676385e2 230 dprec[r] = rules[r].dprec;
95612cfa 231 /* Merger-function index (GLR). */
676385e2 232 merger[r] = rules[r].merger;
ca2a6d15
PH
233 /* Immediate reduction flags (GLR). */
234 immediate[r] = rules[r].is_predicate;
b0940840 235 }
b0940840 236
4b3d3a8e
AD
237 muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
238 muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
239 muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
f6fbd3da
PE
240 muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
241 muscle_insert_int_table ("merger", merger, 0, 0, nrules);
ca2a6d15 242 muscle_insert_int_table ("immediate", immediate, 0, 0, nrules);
796d61fb 243
39912f52 244 MUSCLE_INSERT_INT ("rules_number", nrules);
25005f6a 245 MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
39912f52 246
5df5f6d5
AD
247 free (rline);
248 free (r1);
b0940840 249 free (r2);
676385e2
PH
250 free (dprec);
251 free (merger);
c3e23647
RS
252}
253
b0940840
AD
254/*--------------------------------------------.
255| Prepare the muscles related to the states. |
256`--------------------------------------------*/
c3e23647 257
4a120d45 258static void
b0940840 259prepare_states (void)
c3e23647 260{
21fd22d6 261 state_number i;
da2a7671 262 symbol_number *values = xnmalloc (nstates, sizeof *values);
9703cc49 263 for (i = 0; i < nstates; ++i)
29e88316 264 values[i] = states[i]->accessing_symbol;
a49aecd5 265 muscle_insert_symbol_number_table ("stos", values,
d57650a5 266 0, 1, nstates);
87ceef73 267 free (values);
39912f52
AD
268
269 MUSCLE_INSERT_INT ("last", high);
270 MUSCLE_INSERT_INT ("final_state_number", final_state->number);
271 MUSCLE_INSERT_INT ("states_number", nstates);
c3e23647
RS
272}
273
274
4c3cc7da
AD
275/*-------------------------------------------------------.
276| Compare two symbols by type-name, and then by number. |
277`-------------------------------------------------------*/
278
d73e55e0 279static int
4c3cc7da
AD
280symbol_type_name_cmp (const symbol **lhs, const symbol **rhs)
281{
282 int res = UNIQSTR_CMP((*lhs)->type_name, (*rhs)->type_name);
283 if (res)
284 return res;
285 return (*lhs)->number - (*rhs)->number;
286}
287
288
289/*----------------------------------------------------------------.
290| Return a (malloc'ed) table of the symbols sorted by type-name. |
291`----------------------------------------------------------------*/
292
293static symbol **
d73e55e0 294symbols_by_type_name (void)
4c3cc7da
AD
295{
296 typedef int (*qcmp_type) (const void *, const void *);
297 symbol **res = xmemdup (symbols, nsyms * sizeof *res);
298 qsort (res, nsyms, sizeof *res, (qcmp_type) &symbol_type_name_cmp);
299 return res;
300}
301
302
303/*------------------------------------------------------------------.
304| Define b4_type_names, which is a list of (lists of the numbers of |
305| symbols with same type-name). |
306`------------------------------------------------------------------*/
307
308static void
309type_names_output (FILE *out)
310{
311 int i;
4c3cc7da
AD
312 symbol **syms = symbols_by_type_name ();
313 fputs ("m4_define([b4_type_names],\n[", out);
5d731440
AD
314 for (i = 0; i < nsyms; /* nothing */)
315 {
316 // The index of the first symbol of the current type-name.
317 int i0 = i;
318 fputs (i ? ",\n[" : "[", out);
319 for (; i < nsyms && syms[i]->type_name == syms[i0]->type_name; ++i)
320 fprintf (out, "%s%d", i != i0 ? ", " : "", syms[i]->number);
321 fputs ("]", out);
322 }
4c3cc7da
AD
323 fputs ("])\n\n", out);
324 free (syms);
325}
326
c3e23647 327
d69c9694
AD
328/*-------------------------------------.
329| The list of all the symbol numbers. |
330`-------------------------------------*/
5ab8c47b
AD
331
332static void
d69c9694 333symbol_numbers_output (FILE *out)
5ab8c47b
AD
334{
335 int i;
d69c9694 336 fputs ("m4_define([b4_symbol_numbers],\n[", out);
5ab8c47b 337 for (i = 0; i < nsyms; ++i)
d69c9694 338 fprintf (out, "%s[%d]", i ? ", " : "", i);
5ab8c47b
AD
339 fputs ("])\n\n", out);
340}
341
342
bb33f19a
PE
343/*---------------------------------.
344| Output the user actions to OUT. |
345`---------------------------------*/
12b0043a 346
4a120d45 347static void
c6f1a33c 348user_actions_output (FILE *out)
3f96f4dc 349{
21fd22d6 350 rule_number r;
dafdc66f 351
8e1687ae 352 fputs ("m4_define([b4_actions], \n[", out);
4b3d3a8e 353 for (r = 0; r < nrules; ++r)
9222837b 354 if (rules[r].action)
3f96f4dc 355 {
ca2a6d15
PH
356 fprintf (out, "b4_%scase(%d, [b4_syncline(%d, ",
357 rules[r].is_predicate ? "predicate_" : "",
358 r + 1, rules[r].action_location.start.line);
05ac60f3 359 escaped_output (out, rules[r].action_location.start.file);
8e1687ae 360 fprintf (out, ")\n[ %s]])\n\n", rules[r].action);
3f96f4dc 361 }
8e1687ae 362 fputs ("])\n\n", out);
3f96f4dc
AD
363}
364
1de69d6a
AD
365/*------------------------------------.
366| Output the merge functions to OUT. |
367`------------------------------------*/
676385e2 368
41442480 369static void
676385e2
PH
370merger_output (FILE *out)
371{
372 int n;
373 merger_list* p;
374
375 fputs ("m4_define([b4_mergers], \n[[", out);
e0e5bf84 376 for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
676385e2 377 {
e0e5bf84 378 if (p->type[0] == '\0')
16caa4f4 379 fprintf (out, " case %d: *yy0 = %s (*yy0, *yy1); break;\n",
676385e2
PH
380 n, p->name);
381 else
16caa4f4 382 fprintf (out, " case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
676385e2
PH
383 n, p->type, p->name);
384 }
385 fputs ("]])\n\n", out);
386}
3f96f4dc 387
d69c9694 388
d73e55e0
DJ
389/*---------------------------------------------.
390| Prepare the muscles for symbol definitions. |
391`---------------------------------------------*/
d69c9694
AD
392
393static void
d73e55e0 394prepare_symbol_definitions (void)
d69c9694
AD
395{
396 int i;
397 for (i = 0; i < nsyms; ++i)
398 {
399 symbol *sym = symbols[i];
400 const char *key;
aea10ef4 401 const char *value;
d69c9694
AD
402
403#define SET_KEY(Entry) \
404 obstack_fgrow2 (&format_obstack, "symbol(%d, %s)", i, Entry); \
405 obstack_1grow (&format_obstack, 0); \
406 key = obstack_finish (&format_obstack);
407
aea10ef4
AD
408 // Whether the symbol has an identifier.
409 value = symbol_id_get (sym);
410 SET_KEY("has_id");
411 MUSCLE_INSERT_INT (key, !!value);
412
413 // Its identifier.
414 SET_KEY("id");
415 MUSCLE_INSERT_STRING (key, value ? value : "");
8be046d7 416
aea10ef4 417 // Its tag. Typically for documentation purpose.
d69c9694
AD
418 SET_KEY("tag");
419 MUSCLE_INSERT_STRING (key, sym->tag);
420
421 SET_KEY("user_number");
422 MUSCLE_INSERT_INT (key, sym->user_token_number);
423
5d731440
AD
424 SET_KEY("is_token");
425 MUSCLE_INSERT_INT (key,
426 i < ntokens && sym != errtoken && sym != undeftoken);
427
d69c9694
AD
428 SET_KEY("number");
429 MUSCLE_INSERT_INT (key, sym->number);
430
6659366c 431 SET_KEY("has_type");
5d731440
AD
432 MUSCLE_INSERT_INT (key, !!sym->type_name);
433
6659366c 434 SET_KEY("type");
d69c9694
AD
435 MUSCLE_INSERT_STRING (key, sym->type_name ? sym->type_name : "");
436
2bde9113
AD
437#define CODE_PROP(PropName) \
438 do { \
439 code_props const *p = symbol_ ## PropName ## _get (sym); \
440 SET_KEY("has_" #PropName); \
441 MUSCLE_INSERT_INT (key, !!p->code); \
442 \
443 if (p->code) \
444 { \
445 SET_KEY(#PropName "_file"); \
446 MUSCLE_INSERT_STRING (key, p->location.start.file); \
447 \
448 SET_KEY(#PropName "_line"); \
449 MUSCLE_INSERT_INT (key, p->location.start.line); \
450 \
451 SET_KEY(#PropName); \
452 MUSCLE_INSERT_STRING_RAW (key, p->code); \
453 } \
454 } while (0)
455
456 CODE_PROP(destructor);
457 CODE_PROP(printer);
458#undef CODE_PROP
d69c9694
AD
459#undef SET_KEY
460 }
461}
462
463
ae7453f2
AD
464/*--------------------------------------.
465| Output the tokens definition to OUT. |
466`--------------------------------------*/
091e20bb 467
c6f1a33c 468static void
be2a1a68 469token_definitions_output (FILE *out)
091e20bb
AD
470{
471 int i;
d0829076 472 char const *sep = "";
dafdc66f
AD
473
474 fputs ("m4_define([b4_tokens], \n[", out);
091e20bb
AD
475 for (i = 0; i < ntokens; ++i)
476 {
21fd22d6
PE
477 symbol *sym = symbols[i];
478 int number = sym->user_token_number;
90462b8d 479 uniqstr id = symbol_id_get (sym);
091e20bb 480
dfaa4860
JD
481 /* At this stage, if there are literal string aliases, they are
482 part of SYMBOLS, so we should not find their aliased symbols
483 here. */
484 aver (number != USER_NUMBER_HAS_STRING_ALIAS);
b87f8b21 485
90462b8d
AD
486 /* Skip error token and tokens without identifier. */
487 if (sym != errtoken && id)
488 {
489 fprintf (out, "%s[[[%s]], %d]",
490 sep, id, number);
491 sep = ",\n";
492 }
091e20bb 493 }
dafdc66f 494 fputs ("])\n\n", out);
091e20bb
AD
495}
496
497
4a120d45 498static void
c6f1a33c 499prepare_actions (void)
6c89f1c1 500{
c6f1a33c 501 /* Figure out the actions for the specified state, indexed by
742e4900 502 lookahead token type. */
bbb5bcc6 503
c6f1a33c
AD
504 muscle_insert_rule_number_table ("defact", yydefact,
505 yydefact[0], 1, nstates);
6c89f1c1 506
c6f1a33c
AD
507 /* Figure out what to do after reducing with each rule, depending on
508 the saved state from before the beginning of parsing the data
509 that matched this rule. */
d57650a5
AD
510 muscle_insert_state_number_table ("defgoto", yydefgoto,
511 yydefgoto[0], 1, nsyms - ntokens);
12b0043a 512
12b0043a 513
12b0043a
AD
514 /* Output PACT. */
515 muscle_insert_base_table ("pact", base,
5372019f 516 base[0], 1, nstates);
12b0043a 517 MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
c3e23647 518
12b0043a
AD
519 /* Output PGOTO. */
520 muscle_insert_base_table ("pgoto", base,
5372019f 521 base[nstates], nstates + 1, nvectors);
c3e23647 522
12b0043a
AD
523 muscle_insert_base_table ("table", table,
524 table[0], 1, high + 1);
525 MUSCLE_INSERT_INT ("table_ninf", table_ninf);
676385e2 526
12b0043a
AD
527 muscle_insert_base_table ("check", check,
528 check[0], 1, high + 1);
c3e23647 529
ea99527d
AD
530 /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
531 YYPACT) so that in states with unresolved conflicts, the default
532 reduction is not used in the conflicted entries, so that there is
533 a place to put a conflict pointer.
534
535 This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
536 parser, so we could avoid accidents by not writing them out in
537 that case. Nevertheless, it seems even better to be able to use
538 the GLR skeletons even without the non-deterministic tables. */
539 muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
39912f52 540 conflict_table[0], 1, high + 1);
ea99527d 541 muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
da2a7671 542 0, 1, conflict_list_cnt);
6c89f1c1 543}
4175f6bb
AD
544
545
546/*--------------------------------------------.
547| Output the definitions of all the muscles. |
548`--------------------------------------------*/
549
550static void
551muscles_output (FILE *out)
552{
553 fputs ("m4_init()\n", out);
4175f6bb 554 merger_output (out);
d69c9694
AD
555 symbol_numbers_output (out);
556 token_definitions_output (out);
4c3cc7da 557 type_names_output (out);
d69c9694 558 user_actions_output (out);
4c3cc7da 559 // Must be last.
4175f6bb
AD
560 muscles_m4_output (out);
561}
652def80 562\f
1239777d
AD
563/*---------------------------.
564| Call the skeleton parser. |
565`---------------------------*/
c3e23647 566
4a120d45 567static void
1239777d 568output_skeleton (void)
9b3add5b 569{
573312ac 570 FILE *in;
573312ac 571 int filter_fd[2];
d8911864 572 char const *argv[10];
573312ac
PE
573 pid_t pid;
574
a9fc7990 575 /* Compute the names of the package data dir and skeleton files. */
573312ac 576 char const m4sugar[] = "m4sugar/m4sugar.m4";
90b9908d 577 char const m4bison[] = "bison.m4";
2fd4e131 578 char *full_m4sugar;
90b9908d 579 char *full_m4bison;
eecf08fe 580 char *full_skeleton;
573312ac
PE
581 char const *p;
582 char const *m4 = (p = getenv ("M4")) ? p : M4;
d4bd2295 583 char const *pkgdatadir = compute_pkgdatadir ();
573312ac
PE
584 size_t skeleton_size = strlen (skeleton) + 1;
585 size_t pkgdatadirlen = strlen (pkgdatadir);
586 while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
587 pkgdatadirlen--;
eecf08fe
PE
588 full_skeleton = xmalloc (pkgdatadirlen + 1
589 + (skeleton_size < sizeof m4sugar
590 ? sizeof m4sugar : skeleton_size));
a7867f53 591 strncpy (full_skeleton, pkgdatadir, pkgdatadirlen);
eecf08fe
PE
592 full_skeleton[pkgdatadirlen] = '/';
593 strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
594 full_m4sugar = xstrdup (full_skeleton);
90b9908d
PB
595 strcpy (full_skeleton + pkgdatadirlen + 1, m4bison);
596 full_m4bison = xstrdup (full_skeleton);
a7867f53
JD
597 if (strchr (skeleton, '/'))
598 strcpy (full_skeleton, skeleton);
599 else
600 strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
a9fc7990
JD
601
602 /* Test whether m4sugar.m4 is readable, to check for proper
603 installation. A faulty installation can cause deadlock, so a
604 cheap sanity check is worthwhile. */
2fd4e131 605 xfclose (xfopen (full_m4sugar, "r"));
573312ac
PE
606
607 /* Create an m4 subprocess connected to us via two pipes. */
608
609 if (trace_flag & trace_tools)
90b9908d 610 fprintf (stderr, "running: %s %s - %s %s\n",
a9fc7990 611 m4, full_m4sugar, full_m4bison, full_skeleton);
573312ac 612
a9fc7990
JD
613 /* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
614 position-dependent manner. Keep it as the first argument so that all
615 files are traced.
573312ac 616
a9fc7990
JD
617 See the thread starting at
618 <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
619 for details. */
620 {
621 int i = 0;
622 argv[i++] = m4;
d8911864
EB
623
624 /* When POSIXLY_CORRECT is set, GNU M4 1.6 and later disable GNU
625 extensions, which Bison's skeletons depend on. With older M4,
626 it has no effect. M4 1.4.12 added a -g/--gnu command-line
627 option to make it explicit that a program wants GNU M4
628 extensions even when POSIXLY_CORRECT is set.
629
630 See the thread starting at
631 <http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
632 for details. */
633 if (*M4_GNU_OPTION)
634 argv[i++] = M4_GNU_OPTION;
635
d67c52e8
EB
636 argv[i++] = "-I";
637 argv[i++] = pkgdatadir;
a9fc7990
JD
638 if (trace_flag & trace_m4)
639 argv[i++] = "-dV";
640 argv[i++] = full_m4sugar;
641 argv[i++] = "-";
642 argv[i++] = full_m4bison;
643 argv[i++] = full_skeleton;
644 argv[i++] = NULL;
9789acf0 645 aver (i <= ARRAY_CARDINALITY (argv));
a9fc7990 646 }
a9fc7990 647
f39ab286
JD
648 /* The ugly cast is because gnulib gets the const-ness wrong. */
649 pid = create_pipe_bidi ("m4", m4, (char **)(void*)argv, false, true,
650 true, filter_fd);
2fd4e131 651 free (full_m4sugar);
a9fc7990 652 free (full_m4bison);
eecf08fe 653 free (full_skeleton);
573312ac 654
5263bea9
AD
655 if (trace_flag & trace_muscles)
656 muscles_output (stderr);
657 {
f39ab286 658 FILE *out = fdopen (filter_fd[1], "w");
5263bea9
AD
659 if (! out)
660 error (EXIT_FAILURE, get_errno (),
661 "fdopen");
662 muscles_output (out);
663 xfclose (out);
664 }
be2a1a68 665
573312ac 666 /* Read and process m4's output. */
1509d42f 667 timevar_push (TV_M4);
f39ab286 668 in = fdopen (filter_fd[0], "r");
573312ac 669 if (! in)
04098407
PE
670 error (EXIT_FAILURE, get_errno (),
671 "fdopen");
573312ac 672 scan_skel (in);
f39ab286
JD
673 /* scan_skel should have read all of M4's output. Otherwise, when we
674 close the pipe, we risk letting M4 report a broken-pipe to the
675 Bison user. */
676 aver (feof (in));
573312ac 677 xfclose (in);
f39ab286 678 wait_subprocess (pid, "m4", false, false, true, true, NULL);
1509d42f 679 timevar_pop (TV_M4);
26f609ff
RA
680}
681
682static void
683prepare (void)
684{
945e396c
JD
685 /* BISON_USE_PUSH_FOR_PULL is for the test suite and should not be documented
686 for the user. */
687 char const *use_push_for_pull_env = getenv ("BISON_USE_PUSH_FOR_PULL");
688 bool use_push_for_pull_flag = false;
689 if (use_push_for_pull_env != NULL
690 && use_push_for_pull_env[0] != '\0'
691 && 0 != strcmp (use_push_for_pull_env, "0"))
692 use_push_for_pull_flag = true;
693
7db2ed2d 694 /* Flags. */
d0829076 695 MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
90b9908d 696 MUSCLE_INSERT_BOOL ("glr_flag", glr_parser);
90b9908d 697 MUSCLE_INSERT_BOOL ("nondeterministic_flag", nondeterministic_parser);
d0829076 698 MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
ddc8ede1 699 MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
95021767 700 MUSCLE_INSERT_BOOL ("use_push_for_pull_flag", use_push_for_pull_flag);
b931235e 701 MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
11d82f03 702
573a6cd3 703 /* File names. */
90b9908d
PB
704 if (spec_name_prefix)
705 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
706
bd9d212b
JD
707 MUSCLE_INSERT_STRING ("file_name_all_but_ext", all_but_ext);
708
2b81e969
AD
709#define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
710 DEFINE (dir_prefix);
711 DEFINE (parser_file_name);
712 DEFINE (spec_defines_file);
713 DEFINE (spec_file_prefix);
714 DEFINE (spec_graph_file);
715 DEFINE (spec_name_prefix);
716 DEFINE (spec_outfile);
717 DEFINE (spec_verbose_file);
718#undef DEFINE
b85810ae 719
0e021770
PE
720 /* Find the right skeleton file, and add muscles about the skeletons. */
721 if (skeleton)
722 MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
723 else
724 skeleton = language->skeleton;
381fb12e 725
0e021770 726 /* About the skeletons. */
cf147260 727 {
bd9d212b
JD
728 /* b4_pkgdatadir is used inside m4_include in the skeletons, so digraphs
729 would never be expanded. Hopefully no one has M4-special characters in
730 his Bison installation path. */
d4bd2295 731 MUSCLE_INSERT_STRING_RAW ("pkgdatadir", compute_pkgdatadir ());
cf147260 732 }
26f609ff 733}
c3e23647 734
93ede233 735
6c89f1c1
AD
736/*----------------------------------------------------------.
737| Output the parsing tables and the parser code to ftable. |
738`----------------------------------------------------------*/
c3e23647 739
6c89f1c1
AD
740void
741output (void)
742{
f87685c3 743 obstack_init (&format_obstack);
dd60faec 744
39912f52 745 prepare_symbols ();
b0940840
AD
746 prepare_rules ();
747 prepare_states ();
536545f3 748 prepare_actions ();
d73e55e0 749 prepare_symbol_definitions ();
342b8b6e 750
26f609ff 751 prepare ();
652def80 752
9b3add5b
RA
753 /* Process the selected skeleton file. */
754 output_skeleton ();
755
f499b062 756 obstack_free (&format_obstack, NULL);
c3e23647 757}
d4bd2295
JD
758
759char const *
760compute_pkgdatadir (void)
761{
762 char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
763 return pkgdatadir ? pkgdatadir : PKGDATADIR;
764}