]>
Commit | Line | Data |
---|---|---|
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 | 46 | static 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 | 59 | static void \ |
9e0876fb | 60 | Name (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 | 104 | GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int) |
12b0043a | 105 | GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int) |
21fd22d6 PE |
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) | |
21fd22d6 | 109 | GENERATE_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 | |
116 | static void | |
05ac60f3 | 117 | escaped_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 | 141 | static void |
39912f52 | 142 | prepare_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 | |
210 | static void | |
211 | prepare_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 | 258 | static void |
b0940840 | 259 | prepare_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 | 279 | static int |
4c3cc7da AD |
280 | symbol_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 | ||
293 | static symbol ** | |
d73e55e0 | 294 | symbols_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 | ||
308 | static void | |
309 | type_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 | |
332 | static void | |
d69c9694 | 333 | symbol_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 | 347 | static void |
c6f1a33c | 348 | user_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 | 369 | static void |
676385e2 PH |
370 | merger_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 | |
393 | static void | |
d73e55e0 | 394 | prepare_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 | 468 | static void |
be2a1a68 | 469 | token_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 | 498 | static void |
c6f1a33c | 499 | prepare_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 | ||
550 | static void | |
551 | muscles_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 | 567 | static void |
1239777d | 568 | output_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 | ||
682 | static void | |
683 | prepare (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 |
740 | void |
741 | output (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 | |
759 | char const * | |
760 | compute_pkgdatadir (void) | |
761 | { | |
762 | char const *pkgdatadir = getenv ("BISON_PKGDATADIR"); | |
763 | return pkgdatadir ? pkgdatadir : PKGDATADIR; | |
764 | } |