]> git.saurik.com Git - bison.git/blob - src/output.c
534d82af08f1d6d44e6d85c5e763af841a838cd2
[bison.git] / src / output.c
1 /* Output the generated parsing program for Bison.
2
3 Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006 Free Software Foundation, Inc.
5
6 This file is part of Bison, the GNU Compiler Compiler.
7
8 Bison is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 Bison is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Bison; see the file COPYING. If not, write to the Free
20 Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 #include <config.h>
24 #include "system.h"
25
26 #include <error.h>
27 #include <get-errno.h>
28 #include <quotearg.h>
29 #include <subpipe.h>
30 #include <timevar.h>
31
32 #include "complain.h"
33 #include "files.h"
34 #include "getargs.h"
35 #include "gram.h"
36 #include "muscle_tab.h"
37 #include "output.h"
38 #include "reader.h"
39 #include "scan-code.h" /* max_left_semantic_context */
40 #include "scan-skel.h"
41 #include "symtab.h"
42 #include "tables.h"
43
44
45 static struct obstack format_obstack;
46
47
48 /*-------------------------------------------------------------------.
49 | Create a function NAME which associates to the muscle NAME the |
50 | result of formatting the FIRST and then TABLE_DATA[BEGIN..END[ (of |
51 | TYPE), and to the muscle NAME_max, the max value of the |
52 | TABLE_DATA. |
53 `-------------------------------------------------------------------*/
54
55
56 #define GENERATE_MUSCLE_INSERT_TABLE(Name, Type) \
57 \
58 static void \
59 Name (char const *name, \
60 Type *table_data, \
61 Type first, \
62 int begin, \
63 int end) \
64 { \
65 Type min = first; \
66 Type max = first; \
67 long int lmin; \
68 long int lmax; \
69 int i; \
70 int j = 1; \
71 \
72 obstack_fgrow1 (&format_obstack, "%6d", first); \
73 for (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_fgrow1 (&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 obstack_1grow (&format_obstack, 0); \
90 muscle_insert (name, obstack_finish (&format_obstack)); \
91 \
92 lmin = min; \
93 lmax = max; \
94 /* Build `NAME_min' and `NAME_max' in the obstack. */ \
95 obstack_fgrow1 (&format_obstack, "%s_min", name); \
96 obstack_1grow (&format_obstack, 0); \
97 MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin); \
98 obstack_fgrow1 (&format_obstack, "%s_max", name); \
99 obstack_1grow (&format_obstack, 0); \
100 MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax); \
101 }
102
103 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
104 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)
105 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
106 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
107 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
108 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number)
109 GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
110
111
112 /*--------------------------------------------------------------------.
113 | Print to OUT a representation of STRING escaped both for C and M4. |
114 `--------------------------------------------------------------------*/
115
116 static void
117 escaped_output (FILE *out, char const *string)
118 {
119 char const *p;
120 fprintf (out, "[[");
121
122 for (p = quotearg_style (c_quoting_style, string); *p; p++)
123 switch (*p)
124 {
125 case '$': fputs ("$][", out); break;
126 case '@': fputs ("@@", out); break;
127 case '[': fputs ("@{", out); break;
128 case ']': fputs ("@}", out); break;
129 default: fputc (*p, out); break;
130 }
131
132 fprintf (out, "]]");
133 }
134
135
136 /*------------------------------------------------------------------.
137 | Prepare the muscles related to the symbols: translate, tname, and |
138 | toknum. |
139 `------------------------------------------------------------------*/
140
141 static void
142 prepare_symbols (void)
143 {
144 MUSCLE_INSERT_BOOL ("token_table", token_table_flag);
145 MUSCLE_INSERT_INT ("tokens_number", ntokens);
146 MUSCLE_INSERT_INT ("nterms_number", nvars);
147 MUSCLE_INSERT_INT ("undef_token_number", undeftoken->number);
148 MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number);
149
150 muscle_insert_symbol_number_table ("translate",
151 token_translations,
152 token_translations[0],
153 1, max_user_token_number + 1);
154
155 /* tname -- token names. */
156 {
157 int i;
158 /* We assume that the table will be output starting at column 2. */
159 int j = 2;
160 for (i = 0; i < nsyms; i++)
161 {
162 char const *cp = quotearg_style (c_quoting_style, symbols[i]->tag);
163 /* Width of the next token, including the two quotes, the
164 comma and the space. */
165 int width = strlen (cp) + 2;
166
167 if (j + width > 75)
168 {
169 obstack_sgrow (&format_obstack, "\n ");
170 j = 1;
171 }
172
173 if (i)
174 obstack_1grow (&format_obstack, ' ');
175 MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
176 obstack_1grow (&format_obstack, ',');
177 j += width;
178 }
179 /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
180 defined). */
181 obstack_sgrow (&format_obstack, " 0");
182
183 /* Finish table and store. */
184 obstack_1grow (&format_obstack, 0);
185 muscle_insert ("tname", obstack_finish (&format_obstack));
186 }
187
188 /* Output YYTOKNUM. */
189 {
190 int i;
191 int *values = xnmalloc (ntokens, sizeof *values);
192 for (i = 0; i < ntokens; ++i)
193 values[i] = symbols[i]->user_token_number;
194 muscle_insert_int_table ("toknum", values,
195 values[0], 1, ntokens);
196 free (values);
197 }
198 }
199
200
201 /*-------------------------------------------------------------.
202 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
203 | rline, dprec, merger. |
204 `-------------------------------------------------------------*/
205
206 static void
207 prepare_rules (void)
208 {
209 rule_number r;
210 unsigned int i = 0;
211 item_number *rhs = xnmalloc (nritems, sizeof *rhs);
212 unsigned int *prhs = xnmalloc (nrules, sizeof *prhs);
213 unsigned int *rline = xnmalloc (nrules, sizeof *rline);
214 symbol_number *r1 = xnmalloc (nrules, sizeof *r1);
215 unsigned int *r2 = xnmalloc (nrules, sizeof *r2);
216 int *dprec = xnmalloc (nrules, sizeof *dprec);
217 int *merger = xnmalloc (nrules, sizeof *merger);
218
219 for (r = 0; r < nrules; ++r)
220 {
221 item_number *rhsp = NULL;
222 /* Index of rule R in RHS. */
223 prhs[r] = i;
224 /* RHS of the rule R. */
225 for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
226 rhs[i++] = *rhsp;
227 /* LHS of the rule R. */
228 r1[r] = rules[r].lhs->number;
229 /* Length of rule R's RHS. */
230 r2[r] = i - prhs[r];
231 /* Separator in RHS. */
232 rhs[i++] = -1;
233 /* Line where rule was defined. */
234 rline[r] = rules[r].location.start.line;
235 /* Dynamic precedence (GLR). */
236 dprec[r] = rules[r].dprec;
237 /* Merger-function index (GLR). */
238 merger[r] = rules[r].merger;
239 }
240 assert (i == nritems);
241
242 muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
243 muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
244 muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
245 muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
246 muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
247 muscle_insert_int_table ("dprec", dprec, 0, 0, nrules);
248 muscle_insert_int_table ("merger", merger, 0, 0, nrules);
249
250 MUSCLE_INSERT_INT ("rules_number", nrules);
251 MUSCLE_INSERT_INT ("max_left_semantic_context", max_left_semantic_context);
252
253 free (rhs);
254 free (prhs);
255 free (rline);
256 free (r1);
257 free (r2);
258 free (dprec);
259 free (merger);
260 }
261
262 /*--------------------------------------------.
263 | Prepare the muscles related to the states. |
264 `--------------------------------------------*/
265
266 static void
267 prepare_states (void)
268 {
269 state_number i;
270 symbol_number *values = xnmalloc (nstates, sizeof *values);
271 for (i = 0; i < nstates; ++i)
272 values[i] = states[i]->accessing_symbol;
273 muscle_insert_symbol_number_table ("stos", values,
274 0, 1, nstates);
275 free (values);
276
277 MUSCLE_INSERT_INT ("last", high);
278 MUSCLE_INSERT_INT ("final_state_number", final_state->number);
279 MUSCLE_INSERT_INT ("states_number", nstates);
280 }
281
282
283
284 /*---------------------------------.
285 | Output the user actions to OUT. |
286 `---------------------------------*/
287
288 static void
289 user_actions_output (FILE *out)
290 {
291 rule_number r;
292
293 fputs ("m4_define([b4_actions], \n[[", out);
294 for (r = 0; r < nrules; ++r)
295 if (rules[r].action)
296 {
297 fprintf (out, " case %d:\n", r + 1);
298
299 fprintf (out, "]b4_syncline(%d, ",
300 rules[r].action_location.start.line);
301 escaped_output (out, rules[r].action_location.start.file);
302 fprintf (out, ")[\n");
303 fprintf (out, " %s\n break;\n\n",
304 rules[r].action);
305 }
306 fputs ("]])\n\n", out);
307 }
308
309 /*--------------------------------------.
310 | Output the merge functions to OUT. |
311 `--------------------------------------*/
312
313 static void
314 merger_output (FILE *out)
315 {
316 int n;
317 merger_list* p;
318
319 fputs ("m4_define([b4_mergers], \n[[", out);
320 for (n = 1, p = merge_functions; p != NULL; n += 1, p = p->next)
321 {
322 if (p->type[0] == '\0')
323 fprintf (out, " case %d: *yy0 = %s (*yy0, *yy1); break;\n",
324 n, p->name);
325 else
326 fprintf (out, " case %d: yy0->%s = %s (*yy0, *yy1); break;\n",
327 n, p->type, p->name);
328 }
329 fputs ("]])\n\n", out);
330 }
331
332 /*--------------------------------------.
333 | Output the tokens definition to OUT. |
334 `--------------------------------------*/
335
336 static void
337 token_definitions_output (FILE *out)
338 {
339 int i;
340 char const *sep = "";
341
342 fputs ("m4_define([b4_tokens], \n[", out);
343 for (i = 0; i < ntokens; ++i)
344 {
345 symbol *sym = symbols[i];
346 int number = sym->user_token_number;
347
348 /* At this stage, if there are literal aliases, they are part of
349 SYMBOLS, so we should not find symbols which are the aliases
350 here. */
351 assert (number != USER_NUMBER_ALIAS);
352
353 /* Skip error token. */
354 if (sym == errtoken)
355 continue;
356
357 /* If this string has an alias, then it is necessarily the alias
358 which is to be output. */
359 if (sym->alias)
360 sym = sym->alias;
361
362 /* Don't output literal chars or strings (when defined only as a
363 string). Note that must be done after the alias resolution:
364 think about `%token 'f' "f"'. */
365 if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
366 continue;
367
368 /* Don't #define nonliteral tokens whose names contain periods
369 or '$' (as does the default value of the EOF token). */
370 if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))
371 continue;
372
373 fprintf (out, "%s[[[%s]], %d]",
374 sep, sym->tag, number);
375 sep = ",\n";
376 }
377 fputs ("])\n\n", out);
378 }
379
380
381 /*---------------------------------------.
382 | Output the symbol destructors to OUT. |
383 `---------------------------------------*/
384
385 static void
386 symbol_destructors_output (FILE *out)
387 {
388 int i;
389 char const *sep = "";
390
391 fputs ("m4_define([b4_symbol_destructors], \n[", out);
392 for (i = 0; i < nsyms; ++i)
393 if (symbols[i]->destructor)
394 {
395 symbol *sym = symbols[i];
396
397 /* Filename, lineno,
398 Symbol-name, Symbol-number,
399 destructor, optional typename. */
400 fprintf (out, "%s[", sep);
401 sep = ",\n";
402 escaped_output (out, sym->destructor_location.start.file);
403 fprintf (out, ", %d, ", sym->destructor_location.start.line);
404 escaped_output (out, sym->tag);
405 fprintf (out, ", %d, [[%s]]", sym->number, sym->destructor);
406 if (sym->type_name)
407 fprintf (out, ", [[%s]]", sym->type_name);
408 fputc (']', out);
409 }
410 fputs ("])\n\n", out);
411 }
412
413
414 /*------------------------------------.
415 | Output the symbol printers to OUT. |
416 `------------------------------------*/
417
418 static void
419 symbol_printers_output (FILE *out)
420 {
421 int i;
422 char const *sep = "";
423
424 fputs ("m4_define([b4_symbol_printers], \n[", out);
425 for (i = 0; i < nsyms; ++i)
426 if (symbols[i]->printer)
427 {
428 symbol *sym = symbols[i];
429
430 /* Filename, lineno,
431 Symbol-name, Symbol-number,
432 printer, optional typename. */
433 fprintf (out, "%s[", sep);
434 sep = ",\n";
435 escaped_output (out, sym->printer_location.start.file);
436 fprintf (out, ", %d, ", sym->printer_location.start.line);
437 escaped_output (out, sym->tag);
438 fprintf (out, ", %d, [[%s]]", sym->number, sym->printer);
439 if (sym->type_name)
440 fprintf (out, ", [[%s]]", sym->type_name);
441 fputc (']', out);
442 }
443 fputs ("])\n\n", out);
444 }
445
446
447 static void
448 prepare_actions (void)
449 {
450 /* Figure out the actions for the specified state, indexed by
451 lookahead token type. */
452
453 muscle_insert_rule_number_table ("defact", yydefact,
454 yydefact[0], 1, nstates);
455
456 /* Figure out what to do after reducing with each rule, depending on
457 the saved state from before the beginning of parsing the data
458 that matched this rule. */
459 muscle_insert_state_number_table ("defgoto", yydefgoto,
460 yydefgoto[0], 1, nsyms - ntokens);
461
462
463 /* Output PACT. */
464 muscle_insert_base_table ("pact", base,
465 base[0], 1, nstates);
466 MUSCLE_INSERT_INT ("pact_ninf", base_ninf);
467
468 /* Output PGOTO. */
469 muscle_insert_base_table ("pgoto", base,
470 base[nstates], nstates + 1, nvectors);
471
472 muscle_insert_base_table ("table", table,
473 table[0], 1, high + 1);
474 MUSCLE_INSERT_INT ("table_ninf", table_ninf);
475
476 muscle_insert_base_table ("check", check,
477 check[0], 1, high + 1);
478
479 /* GLR parsing slightly modifies YYTABLE and YYCHECK (and thus
480 YYPACT) so that in states with unresolved conflicts, the default
481 reduction is not used in the conflicted entries, so that there is
482 a place to put a conflict pointer.
483
484 This means that YYCONFLP and YYCONFL are nonsense for a non-GLR
485 parser, so we could avoid accidents by not writing them out in
486 that case. Nevertheless, it seems even better to be able to use
487 the GLR skeletons even without the non-deterministic tables. */
488 muscle_insert_unsigned_int_table ("conflict_list_heads", conflict_table,
489 conflict_table[0], 1, high + 1);
490 muscle_insert_unsigned_int_table ("conflicting_rules", conflict_list,
491 0, 1, conflict_list_cnt);
492 }
493
494 \f
495 /*---------------------------.
496 | Call the skeleton parser. |
497 `---------------------------*/
498
499 static void
500 output_skeleton (void)
501 {
502 FILE *in;
503 FILE *out;
504 int filter_fd[2];
505 char const *argv[6];
506 pid_t pid;
507
508 /* Compute the names of the package data dir and skeleton file.
509 Test whether m4sugar.m4 is readable, to check for proper
510 installation. A faulty installation can cause deadlock, so a
511 cheap sanity check is worthwhile. */
512 char const m4sugar[] = "m4sugar/m4sugar.m4";
513 char *full_m4sugar;
514 char *full_skeleton;
515 char const *p;
516 char const *m4 = (p = getenv ("M4")) ? p : M4;
517 char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : 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 strcpy (full_skeleton, pkgdatadir);
526 full_skeleton[pkgdatadirlen] = '/';
527 strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
528 full_m4sugar = xstrdup (full_skeleton);
529 strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
530 xfclose (xfopen (full_m4sugar, "r"));
531
532 /* Create an m4 subprocess connected to us via two pipes. */
533
534 if (trace_flag & trace_tools)
535 fprintf (stderr, "running: %s %s - %s\n",
536 m4, full_m4sugar, full_skeleton);
537
538 argv[0] = m4;
539 argv[1] = full_m4sugar;
540 argv[2] = "-";
541 argv[3] = full_skeleton;
542 argv[4] = trace_flag & trace_m4 ? "-dV" : NULL;
543 argv[5] = NULL;
544
545 init_subpipe ();
546 pid = create_subpipe (argv, filter_fd);
547 free (full_m4sugar);
548 free (full_skeleton);
549
550 out = fdopen (filter_fd[0], "w");
551 if (! out)
552 error (EXIT_FAILURE, get_errno (),
553 "fdopen");
554
555 /* Output the definitions of all the muscles. */
556 fputs ("m4_init()\n", out);
557
558 user_actions_output (out);
559 merger_output (out);
560 token_definitions_output (out);
561 symbol_destructors_output (out);
562 symbol_printers_output (out);
563
564 muscles_m4_output (out);
565
566 fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
567 fputs ("m4_divert_push(0)dnl\n", out);
568 xfclose (out);
569
570 /* Read and process m4's output. */
571 timevar_push (TV_M4);
572 end_of_output_subpipe (pid, filter_fd);
573 in = fdopen (filter_fd[1], "r");
574 if (! in)
575 error (EXIT_FAILURE, get_errno (),
576 "fdopen");
577 scan_skel (in);
578 xfclose (in);
579 reap_subpipe (pid, m4);
580 timevar_pop (TV_M4);
581 }
582
583 static void
584 prepare (void)
585 {
586 /* Flags. */
587 MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);
588 MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);
589 MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);
590 MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);
591 MUSCLE_INSERT_BOOL ("pure_flag", pure_parser);
592 MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);
593 MUSCLE_INSERT_BOOL ("tag_seen_flag", tag_seen);
594 MUSCLE_INSERT_BOOL ("yacc_flag", yacc_flag);
595
596 /* File names. */
597 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
598 #define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")
599 DEFINE (dir_prefix);
600 DEFINE (parser_file_name);
601 DEFINE (spec_defines_file);
602 DEFINE (spec_file_prefix);
603 DEFINE (spec_graph_file);
604 DEFINE (spec_name_prefix);
605 DEFINE (spec_outfile);
606 DEFINE (spec_verbose_file);
607 #undef DEFINE
608
609 /* User Code. */
610 obstack_1grow (&pre_prologue_obstack, 0);
611 obstack_1grow (&post_prologue_obstack, 0);
612 muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));
613 muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack));
614
615 /* Find the right skeleton file. */
616 if (!skeleton)
617 {
618 if (glr_parser || nondeterministic_parser)
619 skeleton = "glr.c";
620 else
621 skeleton = "yacc.c";
622 }
623
624 /* About the skeletons. */
625 {
626 char const *pkgdatadir = getenv ("BISON_PKGDATADIR");
627 MUSCLE_INSERT_STRING ("pkgdatadir", pkgdatadir ? pkgdatadir : PKGDATADIR);
628 MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
629 }
630 }
631
632
633 /*----------------------------------------------------------.
634 | Output the parsing tables and the parser code to ftable. |
635 `----------------------------------------------------------*/
636
637 void
638 output (void)
639 {
640 obstack_init (&format_obstack);
641
642 prepare_symbols ();
643 prepare_rules ();
644 prepare_states ();
645 prepare_actions ();
646
647 prepare ();
648
649 /* Process the selected skeleton file. */
650 output_skeleton ();
651
652 obstack_free (&format_obstack, NULL);
653 obstack_free (&pre_prologue_obstack, NULL);
654 obstack_free (&post_prologue_obstack, NULL);
655 }