]>
git.saurik.com Git - bison.git/blob - src/output.c
fe029d41622f33e0cc25f1fd243477e40df13e7a
1 /* Output the generated parsing program for bison,
2 Copyright 1984, 1986, 1989, 1992, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of Bison, the GNU Compiler Compiler.
7 Bison is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 Bison is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bison; see the file COPYING. If not, write to the Free
19 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 /* The parser tables consist of these tables. Marked ones needed only
24 for the semantic parser. Double marked are output only if switches
27 YYTRANSLATE = vector mapping yylex's token numbers into bison's
30 ++ YYTNAME = vector of string-names indexed by bison token number.
32 ++ YYTOKNUM = vector of yylex token numbers corresponding to
35 YYRLINE = vector of line-numbers of all rules. For yydebug
38 YYRHS = vector of items of all rules. This is exactly what RITEMS
39 contains. For yydebug and for semantic parser.
41 YYPRHS[R] = index in YYRHS of first item for rule R.
43 YYR1[R] = symbol number of symbol that rule R derives.
45 YYR2[R] = number of symbols composing right hand side of rule R.
47 + YYSTOS[S] = the symbol number of the symbol that leads to state
50 YYDEFACT[S] = default rule to reduce with in state s, when YYTABLE
51 doesn't specify something else to do. Zero means the default is an
54 YYDEFGOTO[I] = default state to go to after a reduction of a rule
55 that generates variable NTOKENS + I, except when YYTABLE specifies
58 YYPACT[S] = index in YYTABLE of the portion describing state S.
59 The lookahead token's type is used to index that portion to find
62 If the value in YYTABLE is positive, we shift the token and go to
65 If the value is negative, it is minus a rule number to reduce by.
67 If the value is zero, the default action from YYDEFACT[S] is used.
69 YYPGOTO[I] = the index in YYTABLE of the portion describing what to
70 do after reducing a rule that derives variable I + NTOKENS. This
71 portion is indexed by the parser state number, S, as of before the
72 text for this nonterminal was read. The value from YYTABLE is the
73 state to go to if the corresponding value in YYCHECK is S.
75 YYTABLE = a vector filled with portions for different uses, found
76 via YYPACT and YYPGOTO.
78 YYCHECK = a vector indexed in parallel with YYTABLE. It indicates,
79 in a roundabout way, the bounds of the portion you are trying to
82 Suppose that the portion of yytable starts at index P and the index
83 to be examined within the portion is I. Then if YYCHECK[P+I] != I,
84 I is outside the bounds of what is actually allocated, and the
85 default (from YYDEFACT or YYDEFGOTO) should be used. Otherwise,
86 YYTABLE[P+I] should be used.
88 YYFINAL = the state number of the termination state. YYFLAG = most
89 negative short int. Used to flag ?? */
102 #include "conflicts.h"
103 #include "muscle_tab.h"
108 static short **froms
= NULL
;
109 static short **tos
= NULL
;
110 static short *tally
= NULL
;
111 static short *width
= NULL
;
112 static short *actrow
= NULL
;
113 static short *state_count
= NULL
;
114 static short *order
= NULL
;
115 static short *base
= NULL
;
116 static short *pos
= NULL
;
117 static short *table
= NULL
;
118 static short *check
= NULL
;
122 struct obstack muscle_obstack
;
123 static struct obstack format_obstack
;
125 int error_verbose
= 0;
127 /* Returns the number of lines of S. */
129 get_lines_number (const char *s
)
134 for (i
= 0; s
[i
]; ++i
)
145 output_table_data (struct obstack
*oout
,
154 obstack_fgrow1 (oout
, "%6d", first
);
155 for (i
= begin
; i
< end
; ++i
)
157 obstack_1grow (oout
, ',');
160 obstack_sgrow (oout
, "\n ");
165 obstack_fgrow1 (oout
, "%6d", table_data
[i
]);
167 obstack_1grow (oout
, 0);
172 output_token_translations (void)
174 output_table_data (&format_obstack
, token_translations
,
175 0, 1, max_user_token_number
+ 1);
176 muscle_insert ("translate", obstack_finish (&format_obstack
));
177 XFREE (token_translations
);
186 short *values
= XCALLOC (short, nrules
+ 1);
187 for (i
= 0; i
< nrules
+ 1; ++i
)
188 values
[i
] = rule_table
[i
].rhs
;
189 output_table_data (&format_obstack
, values
,
194 muscle_insert ("prhs", obstack_finish (&format_obstack
));
200 yyrhs
= XMALLOC (short, nritems
);
202 for (i
= 1; i
< nritems
; ++i
)
203 yyrhs
[i
] = ritem
[i
] >= 0 ? ritem
[i
] : -1;
205 output_table_data (&format_obstack
, yyrhs
,
206 ritem
[0], 1, nritems
);
207 muscle_insert ("rhs", obstack_finish (&format_obstack
));
213 if (!semantic_parser
)
214 obstack_sgrow (&table_obstack
, "\n#endif\n");
223 short *values
= (short *) alloca (sizeof (short) * nstates
);
224 for (i
= 0; i
< nstates
; ++i
)
225 values
[i
] = state_table
[i
]->accessing_symbol
;
226 output_table_data (&format_obstack
, values
,
228 muscle_insert ("stos", obstack_finish (&format_obstack
));
233 output_rule_data (void)
237 short *short_tab
= NULL
;
240 short *values
= XCALLOC (short, nrules
+ 1);
241 for (i
= 0; i
< nrules
+ 1; ++i
)
242 values
[i
] = rule_table
[i
].line
;
243 output_table_data (&format_obstack
, values
,
245 muscle_insert ("rline", obstack_finish (&format_obstack
));
251 for (i
= 0; i
< nsyms
; i
++)
253 /* Be sure not to use twice the same quotearg slot. */
255 quotearg_n_style (1, c_quoting_style
,
256 quotearg_style (escape_quoting_style
, symbols
[i
]->tag
));
257 /* Width of the next token, including the two quotes, the coma
259 int strsize
= strlen (cp
) + 2;
261 if (j
+ strsize
> 75)
263 obstack_sgrow (&format_obstack
, "\n ");
267 obstack_sgrow (&format_obstack
, cp
);
268 obstack_sgrow (&format_obstack
, ", ");
271 /* add a NULL entry to list of tokens */
272 obstack_sgrow (&format_obstack
, "NULL");
274 /* Finish table and store. */
275 obstack_1grow (&format_obstack
, 0);
276 muscle_insert ("tname", obstack_finish (&format_obstack
));
278 /* Output YYTOKNUM. */
279 output_table_data (&format_obstack
, user_toknums
,
281 muscle_insert ("toknum", obstack_finish (&format_obstack
));
285 short *values
= XCALLOC (short, nrules
+ 1);
286 for (i
= 0; i
< nrules
+ 1; ++i
)
287 values
[i
] = rule_table
[i
].lhs
;
288 output_table_data (&format_obstack
, values
,
290 muscle_insert ("r1", obstack_finish (&format_obstack
));
295 short_tab
= XMALLOC (short, nrules
+ 1);
296 for (i
= 1; i
< nrules
; i
++)
297 short_tab
[i
] = rule_table
[i
+ 1].rhs
- rule_table
[i
].rhs
- 1;
298 short_tab
[nrules
] = nritems
- rule_table
[nrules
].rhs
- 1;
299 output_table_data (&format_obstack
, short_tab
,
301 muscle_insert ("r2", obstack_finish (&format_obstack
));
305 /*------------------------------------------------------------------.
306 | Decide what to do for each type of token if seen as the lookahead |
307 | token in specified state. The value returned is used as the |
308 | default action (yydefact) for the state. In addition, actrow is |
309 | filled with what to do for each kind of token, index by symbol |
310 | number, with zero meaning do the default action. The value |
311 | MINSHORT, a very negative number, means this situation is an |
312 | error. The parser recognizes this value specially. |
314 | This is where conflicts are resolved. The loop over lookahead |
315 | rules considered lower-numbered rules last, and the last rule |
316 | considered that likes a token gets to handle it. |
317 `------------------------------------------------------------------*/
320 action_row (state_t
*state
)
323 int default_rule
= 0;
324 reductions
*redp
= state
->reductions
;
325 shifts
*shiftp
= state
->shifts
;
326 errs
*errp
= state
->errs
;
327 /* set nonzero to inhibit having any default reduction */
330 for (i
= 0; i
< ntokens
; i
++)
333 if (redp
->nreds
>= 1)
336 /* loop over all the rules available here which require
338 for (i
= state
->nlookaheads
- 1; i
>= 0; --i
)
339 /* and find each token which the rule finds acceptable
341 for (j
= 0; j
< ntokens
; j
++)
342 /* and record this rule as the rule to use if that
344 if (BITISSET (LA (state
->lookaheadsp
+ i
), j
))
345 actrow
[j
] = -LAruleno
[state
->lookaheadsp
+ i
];
348 /* Now see which tokens are allowed for shifts in this state. For
349 them, record the shift as the thing to do. So shift is preferred
351 for (i
= 0; i
< shiftp
->nshifts
; i
++)
354 int shift_state
= shiftp
->shifts
[i
];
358 symbol
= state_table
[shift_state
]->accessing_symbol
;
363 actrow
[symbol
] = shift_state
;
365 /* Do not use any default reduction if there is a shift for
367 if (symbol
== error_token_number
)
371 /* See which tokens are an explicit error in this state (due to
372 %nonassoc). For them, record MINSHORT as the action. */
373 for (i
= 0; i
< errp
->nerrs
; i
++)
375 int symbol
= errp
->errs
[i
];
376 actrow
[symbol
] = MINSHORT
;
379 /* Now find the most common reduction and make it the default action
382 if (redp
->nreds
>= 1 && !nodefault
)
384 if (state
->consistent
)
385 default_rule
= redp
->rules
[0];
389 for (i
= 0; i
< state
->nlookaheads
; i
++)
392 int rule
= -LAruleno
[state
->lookaheadsp
+ i
];
395 for (j
= 0; j
< ntokens
; j
++)
396 if (actrow
[j
] == rule
)
406 /* actions which match the default are replaced with zero,
407 which means "use the default" */
412 for (j
= 0; j
< ntokens
; j
++)
413 if (actrow
[j
] == default_rule
)
416 default_rule
= -default_rule
;
421 /* If have no default rule, the default is an error.
422 So replace any action which says "error" with "use default". */
424 if (default_rule
== 0)
425 for (i
= 0; i
< ntokens
; i
++)
426 if (actrow
[i
] == MINSHORT
)
443 for (i
= 0; i
< ntokens
; i
++)
450 froms
[state
] = sp1
= sp
= XCALLOC (short, count
);
451 tos
[state
] = sp2
= XCALLOC (short, count
);
453 for (i
= 0; i
< ntokens
; i
++)
460 tally
[state
] = count
;
461 width
[state
] = sp1
[-1] - sp
[0] + 1;
465 /*------------------------------------------------------------------.
466 | Figure out the actions for the specified state, indexed by |
467 | lookahead token type. |
469 | The YYDEFACT table is output now. The detailed info is saved for |
470 | putting into YYTABLE later. |
471 `------------------------------------------------------------------*/
477 short *yydefact
= XCALLOC (short, nstates
);
479 actrow
= XCALLOC (short, ntokens
);
480 for (i
= 0; i
< nstates
; ++i
)
482 yydefact
[i
] = action_row (state_table
[i
]);
486 output_table_data (&format_obstack
, yydefact
,
487 yydefact
[0], 1, nstates
);
488 muscle_insert ("defact", obstack_finish (&format_obstack
));
495 /*-----------------------------.
496 | Output the actions to OOUT. |
497 `-----------------------------*/
500 actions_output (FILE *out
, size_t *line
)
503 for (rule
= 1; rule
< nrules
+ 1; ++rule
)
504 if (rule_table
[rule
].action
)
506 fprintf (out
, " case %d:\n", rule
);
509 fprintf (out
, muscle_find ("linef"),
510 rule_table
[rule
].action_line
,
511 quotearg_style (c_quoting_style
,
512 muscle_find ("filename")));
513 /* As a Bison extension, add the ending semicolon. Since some
514 Yacc don't do that, help people using bison as a Yacc
515 finding their missing semicolons. */
516 fprintf (out
, "{ %s%s }\n break;\n\n",
517 rule_table
[rule
].action
,
518 yacc_flag
? ";" : "");
520 /* We always output 4 '\n' per action. */
522 /* Plus one if !no_lines_flag. */
525 /* Get the number of lines written by the user. */
526 *line
+= get_lines_number (rule_table
[rule
].action
);
531 /*----------------------------.
532 | Output the guards to OOUT. |
533 `----------------------------*/
536 guards_output (FILE *out
, size_t *line
)
539 for (rule
= 1; rule
< nrules
+ 1; ++rule
)
540 if (rule_table
[rule
].action
)
542 fprintf (out
, " case %d:\n", rule
);
545 fprintf (out
, muscle_find ("linef"),
546 rule_table
[rule
].guard_line
,
547 quotearg_style (c_quoting_style
,
548 muscle_find ("filename")));
549 fprintf (out
, "{ %s; }\n break;\n\n",
550 rule_table
[rule
].guard
);
552 /* We always output 4 '\n' per action. */
554 /* Plus one if !no_lines_flag. */
557 /* Get the number of lines written by the user. */
558 *line
+= get_lines_number (rule_table
[rule
].guard
);
564 save_column (int symbol
, int default_state
)
571 int symno
= symbol
- ntokens
+ nstates
;
573 short begin
= goto_map
[symbol
];
574 short end
= goto_map
[symbol
+ 1];
577 for (i
= begin
; i
< end
; i
++)
578 if (to_state
[i
] != default_state
)
584 froms
[symno
] = sp1
= sp
= XCALLOC (short, count
);
585 tos
[symno
] = sp2
= XCALLOC (short, count
);
587 for (i
= begin
; i
< end
; i
++)
588 if (to_state
[i
] != default_state
)
590 *sp1
++ = from_state
[i
];
591 *sp2
++ = to_state
[i
];
594 tally
[symno
] = count
;
595 width
[symno
] = sp1
[-1] - sp
[0] + 1;
599 default_goto (int symbol
)
602 int m
= goto_map
[symbol
];
603 int n
= goto_map
[symbol
+ 1];
604 int default_state
= -1;
610 for (i
= 0; i
< nstates
; i
++)
613 for (i
= m
; i
< n
; i
++)
614 state_count
[to_state
[i
]]++;
616 for (i
= 0; i
< nstates
; i
++)
617 if (state_count
[i
] > max
)
619 max
= state_count
[i
];
623 return default_state
;
627 /*-------------------------------------------------------------------.
628 | Figure out what to do after reducing with each rule, depending on |
629 | the saved state from before the beginning of parsing the data that |
630 | matched this rule. |
632 | The YYDEFGOTO table is output now. The detailed info is saved for |
633 | putting into YYTABLE later. |
634 `-------------------------------------------------------------------*/
640 short *yydefgoto
= XMALLOC (short, nsyms
- ntokens
);
642 state_count
= XCALLOC (short, nstates
);
643 for (i
= ntokens
; i
< nsyms
; ++i
)
645 int default_state
= default_goto (i
);
646 save_column (i
, default_state
);
647 yydefgoto
[i
- ntokens
] = default_state
;
650 output_table_data (&format_obstack
, yydefgoto
,
651 yydefgoto
[0], 1, nsyms
- ntokens
);
652 muscle_insert ("defgoto", obstack_finish (&format_obstack
));
659 /* The next few functions decide how to pack the actions and gotos
660 information into yytable. */
667 order
= XCALLOC (short, nvectors
);
670 for (i
= 0; i
< nvectors
; i
++)
676 int j
= nentries
- 1;
678 while (j
>= 0 && (width
[order
[j
]] < w
))
681 while (j
>= 0 && (width
[order
[j
]] == w
) && (tally
[order
[j
]] < t
))
684 for (k
= nentries
- 1; k
> j
; k
--)
685 order
[k
+ 1] = order
[k
];
694 matching_state (int vector
)
696 int i
= order
[vector
];
707 for (prev
= vector
- 1; prev
>= 0; prev
--)
713 if (width
[j
] != w
|| tally
[j
] != t
)
716 for (k
= 0; match
&& k
< t
; k
++)
717 if (tos
[j
][k
] != tos
[i
][k
] || froms
[j
][k
] != froms
[i
][k
])
729 pack_vector (int vector
)
731 int i
= order
[vector
];
735 short *from
= froms
[i
];
740 for (j
= lowzero
- from
[0]; j
< MAXTABLE
; j
++)
745 for (k
= 0; ok
&& k
< t
; k
++)
749 fatal (_("maximum table size (%d) exceeded"), MAXTABLE
);
755 for (k
= 0; ok
&& k
< vector
; k
++)
761 for (k
= 0; k
< t
; k
++)
765 check
[loc
] = from
[k
];
768 while (table
[lowzero
] != 0)
777 #define pack_vector_succeeded 0
778 assert (pack_vector_succeeded
);
790 base
= XCALLOC (short, nvectors
);
791 pos
= XCALLOC (short, nentries
);
792 table
= XCALLOC (short, MAXTABLE
);
793 check
= XCALLOC (short, MAXTABLE
);
798 for (i
= 0; i
< nvectors
; i
++)
801 for (i
= 0; i
< MAXTABLE
; i
++)
804 for (i
= 0; i
< nentries
; i
++)
806 state
= matching_state (i
);
809 place
= pack_vector (i
);
814 base
[order
[i
]] = place
;
817 for (i
= 0; i
< nvectors
; i
++)
828 /* the following functions output yytable, yycheck
829 and the vectors whose elements index the portion starts */
835 output_table_data (&format_obstack
, base
,
836 base
[0], 1, nstates
);
837 muscle_insert ("pact", obstack_finish (&format_obstack
));
840 output_table_data (&format_obstack
, base
,
841 base
[nstates
], nstates
+ 1, nvectors
);
842 muscle_insert ("pgoto", obstack_finish (&format_obstack
));
851 output_table_data (&format_obstack
, table
,
852 table
[0], 1, high
+ 1);
853 muscle_insert ("table", obstack_finish (&format_obstack
));
861 output_table_data (&format_obstack
, check
,
862 check
[0], 1, high
+ 1);
863 muscle_insert ("check", obstack_finish (&format_obstack
));
867 /* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable
871 output_actions (void)
874 nvectors
= nstates
+ nvars
;
876 froms
= XCALLOC (short *, nvectors
);
877 tos
= XCALLOC (short *, nvectors
);
878 tally
= XCALLOC (short, nvectors
);
879 width
= XCALLOC (short, nvectors
);
886 XFREE (goto_map
+ ntokens
);
898 for (i
= 0; i
< nstates
; ++i
)
900 free (state_table
[i
]->shifts
);
901 XFREE (state_table
[i
]->reductions
);
902 free (state_table
[i
]->errs
);
903 free (state_table
[i
]);
909 /*------------------------------------------------------------.
910 | Copy the parser code from SKEL_FILENAME into OOUT obstack. |
911 | and do the muscle substitution. |
912 `------------------------------------------------------------*/
915 output_parser (const char *skel_filename
, FILE *out
)
920 size_t skeleton_line
;
922 fskel
= xfopen (skel_filename
, "r");
924 /* New output code. */
940 else if ((c
= getc (fskel
)) == '%')
942 /* Read the muscle. */
943 const char *muscle_key
= 0;
944 const char *muscle_value
= 0;
946 while (isalnum (c
= getc (fskel
)) || c
== '-')
947 obstack_1grow (&muscle_obstack
, c
);
948 obstack_1grow (&muscle_obstack
, 0);
950 /* Output the right value, or see if it's something special. */
951 muscle_key
= obstack_finish (&muscle_obstack
);
952 muscle_value
= muscle_find (muscle_key
);
953 if (!strcmp (muscle_key
, "actions"))
954 actions_output (out
, &output_line
);
955 else if (!strcmp (muscle_key
, "guards"))
956 guards_output (out
, &output_line
);
957 else if (!strcmp (muscle_key
, "line"))
958 fprintf (out
, "%d", output_line
);
959 else if (!strcmp (muscle_key
, "skeleton-line"))
960 fprintf (out
, "%d", skeleton_line
);
961 else if (muscle_value
)
963 fputs (muscle_value
, out
);
964 output_line
+= get_lines_number (muscle_value
);
969 fputs (muscle_key
, out
);
980 /*----------------------------------------.
981 | Prepare the master parser to be output |
982 `----------------------------------------*/
985 output_master_parser (void)
987 FILE *parser
= xfopen (parser_file_name
, "w");
991 skeleton
= skeleton_find ("BISON_HAIRY", BISON_HAIRY
);
993 skeleton
= skeleton_find ("BISON_SIMPLE", BISON_SIMPLE
);
995 muscle_insert ("skeleton", skeleton
);
996 muscle_insert ("parser-file-name", parser_file_name
);
998 output_parser (skeleton
, parser
);
1005 #define MUSCLE_INSERT_INT(Key, Value) \
1007 obstack_fgrow1 (&muscle_obstack, "%d", Value); \
1008 obstack_1grow (&muscle_obstack, 0); \
1009 muscle_insert (Key, obstack_finish (&muscle_obstack)); \
1012 #define MUSCLE_INSERT_STRING(Key, Value) \
1014 obstack_sgrow (&muscle_obstack, Value); \
1015 obstack_1grow (&muscle_obstack, 0); \
1016 muscle_insert (Key, obstack_finish (&muscle_obstack)); \
1019 #define MUSCLE_INSERT_PREFIX(Key, Value) \
1021 obstack_fgrow2 (&muscle_obstack, "%s%s", spec_name_prefix, Value); \
1022 obstack_1grow (&muscle_obstack, 0); \
1023 muscle_insert (Key, obstack_finish (&muscle_obstack)); \
1029 MUSCLE_INSERT_INT ("last", high
);
1030 MUSCLE_INSERT_INT ("flag", MINSHORT
);
1031 MUSCLE_INSERT_INT ("pure", pure_parser
);
1032 MUSCLE_INSERT_INT ("nsym", nsyms
);
1033 MUSCLE_INSERT_INT ("debug", debug_flag
);
1034 MUSCLE_INSERT_INT ("final", final_state
);
1035 MUSCLE_INSERT_INT ("maxtok", max_user_token_number
);
1036 MUSCLE_INSERT_INT ("error-verbose", error_verbose
);
1037 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix
);
1039 MUSCLE_INSERT_INT ("nnts", nvars
);
1040 MUSCLE_INSERT_INT ("nrules", nrules
);
1041 MUSCLE_INSERT_INT ("nstates", nstates
);
1042 MUSCLE_INSERT_INT ("ntokens", ntokens
);
1044 MUSCLE_INSERT_INT ("locations-flag", locations_flag
);
1048 /*-------------------------.
1049 | Output the header file. |
1050 `-------------------------*/
1053 header_output (void)
1055 FILE *out
= xfopen (spec_defines_file
, "w");
1056 char *macro_name
= compute_header_macro ();
1058 fprintf (out
, "#ifndef %s\n", macro_name
);
1059 fprintf (out
, "# define %s\n\n", macro_name
);
1061 fputs (muscle_find ("tokendef"), out
);
1066 # define YYSTYPE yystype\n\
1068 muscle_find ("stype"));
1071 fprintf (out
, "\nextern YYSTYPE %slval;\n",
1073 if (semantic_parser
)
1077 for (i
= ntokens
; i
< nsyms
; i
++)
1078 /* don't make these for dummy nonterminals made by gensym. */
1079 if (*symbols
[i
]->tag
!= '@')
1080 fprintf (out
, "# define NT%s\t%d\n", symbols
[i
]->tag
, i
);
1083 fprintf (out
, "\n#endif /* not %s */\n", macro_name
);
1089 /*----------------------------------------------------------.
1090 | Output the parsing tables and the parser code to ftable. |
1091 `----------------------------------------------------------*/
1096 obstack_init (&format_obstack
);
1098 output_token_translations ();
1102 if (semantic_parser
)
1104 output_rule_data ();
1105 XFREE (user_toknums
);
1109 /* Copy definitions in directive. */
1110 obstack_1grow (&attrs_obstack
, 0);
1111 muscle_insert ("prologue", obstack_finish (&attrs_obstack
));
1113 /* Output the parser. */
1114 output_master_parser ();
1115 /* Output the header if needed. */
1119 free (rule_table
+ 1);
1120 obstack_free (&muscle_obstack
, NULL
);
1121 obstack_free (&format_obstack
, NULL
);
1122 obstack_free (&action_obstack
, NULL
);
1123 obstack_free (&attrs_obstack
, NULL
);