1 /* Output the generated parsing program for bison,
2 Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
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 ?? */
104 #include "conflicts.h"
105 #include "muscle_tab.h"
107 /* From lib/readpipe.h. */
108 FILE *readpipe
PARAMS ((const char *, ...));
110 /* From src/scan-skel.l. */
111 int skel_lex
PARAMS ((void));
112 extern FILE *skel_in
;
116 static short **froms
= NULL
;
117 static short **tos
= NULL
;
118 static short *tally
= NULL
;
119 static short *width
= NULL
;
120 static short *actrow
= NULL
;
121 static short *state_count
= NULL
;
122 static short *order
= NULL
;
123 static short *base
= NULL
;
124 static short *pos
= NULL
;
126 /* TABLE_SIZE is the allocated size of both TABLE and CHECK.
127 We start with the original hard-coded value: SHRT_MAX
128 (yes, not USHRT_MAX). */
129 static size_t table_size
= SHRT_MAX
;
130 static short *table
= NULL
;
131 static short *check
= NULL
;
135 struct obstack muscle_obstack
;
136 static struct obstack format_obstack
;
138 int error_verbose
= 0;
141 /*----------------------------------------------------------------.
142 | If TABLE (and CHECK) appear to be small to be addressed at |
143 | DESIRED, grow them. Note that TABLE[DESIRED] is to be used, so |
144 | the desired size is at least DESIRED + 1. |
145 `----------------------------------------------------------------*/
148 table_grow (size_t desired
)
150 size_t old_size
= table_size
;
152 while (table_size
<= desired
)
156 fprintf (stderr
, "growing table and check from: %d to %d\n",
157 old_size
, table_size
);
159 table
= XREALLOC (table
, short, table_size
);
160 check
= XREALLOC (check
, short, table_size
);
162 for (/* Nothing. */; old_size
< table_size
; ++old_size
)
165 check
[old_size
] = -1;
170 /*------------------------------------------------------------------.
171 | Create a function NAME which Format the FIRST and then |
172 | TABLE_DATA[BEGIN..END[ (of TYPE) into OOUT, and return the number |
173 | of bits needed for its longuest value. |
174 `------------------------------------------------------------------*/
177 #define GENERATE_OUTPUT_TABLE(Name, Type) \
179 static inline long int \
180 Name (struct obstack *oout, \
186 long int max = first; \
190 obstack_fgrow1 (oout, "%6d", first); \
191 for (i = begin; i < end; ++i) \
193 obstack_1grow (oout, ','); \
196 obstack_sgrow (oout, "\n "); \
201 obstack_fgrow1 (oout, "%6d", table_data[i]); \
202 if (table_data[i] > max) \
203 max = table_data[i]; \
205 obstack_1grow (oout, 0); \
210 GENERATE_OUTPUT_TABLE(output_int_table
, int)
211 GENERATE_OUTPUT_TABLE(output_short_table
, short)
212 GENERATE_OUTPUT_TABLE(output_token_number_table
, token_number_t
)
213 GENERATE_OUTPUT_TABLE(output_item_number_table
, item_number_t
)
216 /*-----------------------------------------------------------------.
217 | Prepare the muscles related to the tokens: translate, tname, and |
219 `-----------------------------------------------------------------*/
222 prepare_tokens (void)
224 long int max
= output_token_number_table (&format_obstack
,
226 0, 1, max_user_token_number
+ 1);
227 muscle_insert ("translate", obstack_finish (&format_obstack
));
228 MUSCLE_INSERT_LONG_INT ("token_number_max", max
);
229 XFREE (token_translations
);
234 for (i
= 0; i
< nsyms
; i
++)
236 /* Be sure not to use twice the same quotearg slot. */
238 quotearg_n_style (1, c_quoting_style
,
239 quotearg_style (escape_quoting_style
,
241 /* Width of the next token, including the two quotes, the coma
243 int strsize
= strlen (cp
) + 2;
245 if (j
+ strsize
> 75)
247 obstack_sgrow (&format_obstack
, "\n ");
251 obstack_sgrow (&format_obstack
, cp
);
252 obstack_sgrow (&format_obstack
, ", ");
255 /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
257 obstack_sgrow (&format_obstack
, "0");
259 /* Finish table and store. */
260 obstack_1grow (&format_obstack
, 0);
261 muscle_insert ("tname", obstack_finish (&format_obstack
));
264 /* Output YYTOKNUM. */
267 short *values
= XCALLOC (short, ntokens
+ 1);
268 for (i
= 0; i
< ntokens
+ 1; ++i
)
269 values
[i
] = symbols
[i
]->user_token_number
;
270 output_short_table (&format_obstack
, values
,
272 muscle_insert ("toknum", obstack_finish (&format_obstack
));
278 /*-------------------------------------------------------------.
279 | Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
281 `-------------------------------------------------------------*/
290 item_number_t
*rhs
= XMALLOC (item_number_t
, nritems
);
291 short *prhs
= XMALLOC (short, nrules
+ 1);
292 token_number_t
*r1
= XMALLOC (token_number_t
, nrules
+ 1);
293 short *r2
= XMALLOC (short, nrules
+ 1);
294 short *rline
= XMALLOC (short, nrules
+ 1);
296 for (r
= 1; r
< nrules
+ 1; ++r
)
298 /* Index of rule R in RHS. */
300 /* RHS of the rule R. */
301 for (rhsp
= rules
[r
].rhs
; *rhsp
>= 0; ++rhsp
)
303 /* LHS of the rule R. */
304 r1
[r
] = rules
[r
].lhs
->number
;
305 /* Length of rule R's RHS. */
307 /* Separator in RHS. */
309 /* Line where rule was defined. */
310 rline
[r
] = rules
[r
].line
;
312 assert (i
== nritems
);
314 max
= output_int_table (&format_obstack
, rhs
, ritem
[0], 1, nritems
);
315 muscle_insert ("rhs", obstack_finish (&format_obstack
));
316 MUSCLE_INSERT_LONG_INT ("rhs_number_max", max
);
318 output_short_table (&format_obstack
, prhs
, 0, 1, nrules
+ 1);
319 muscle_insert ("prhs", obstack_finish (&format_obstack
));
321 output_short_table (&format_obstack
, rline
, 0, 1, nrules
+ 1);
322 muscle_insert ("rline", obstack_finish (&format_obstack
));
324 output_token_number_table (&format_obstack
, r1
, 0, 1, nrules
+ 1);
325 muscle_insert ("r1", obstack_finish (&format_obstack
));
327 output_short_table (&format_obstack
, r2
, 0, 1, nrules
+ 1);
328 muscle_insert ("r2", obstack_finish (&format_obstack
));
335 /*--------------------------------------------.
336 | Prepare the muscles related to the states. |
337 `--------------------------------------------*/
340 prepare_states (void)
343 token_number_t
*values
=
344 (token_number_t
*) alloca (sizeof (token_number_t
) * nstates
);
345 for (i
= 0; i
< nstates
; ++i
)
346 values
[i
] = states
[i
]->accessing_symbol
;
347 output_token_number_table (&format_obstack
, values
,
349 muscle_insert ("stos", obstack_finish (&format_obstack
));
353 /*------------------------------------------------------------------.
354 | Decide what to do for each type of token if seen as the lookahead |
355 | token in specified state. The value returned is used as the |
356 | default action (yydefact) for the state. In addition, actrow is |
357 | filled with what to do for each kind of token, index by symbol |
358 | number, with zero meaning do the default action. The value |
359 | SHRT_MIN, a very negative number, means this situation is an |
360 | error. The parser recognizes this value specially. |
362 | This is where conflicts are resolved. The loop over lookahead |
363 | rules considered lower-numbered rules last, and the last rule |
364 | considered that likes a token gets to handle it. |
365 `------------------------------------------------------------------*/
368 action_row (state_t
*state
)
371 int default_rule
= 0;
372 reductions
*redp
= state
->reductions
;
373 shifts
*shiftp
= state
->shifts
;
374 errs
*errp
= state
->errs
;
375 /* set nonzero to inhibit having any default reduction */
378 for (i
= 0; i
< ntokens
; i
++)
381 if (redp
->nreds
>= 1)
384 /* loop over all the rules available here which require
386 for (i
= state
->nlookaheads
- 1; i
>= 0; --i
)
387 /* and find each token which the rule finds acceptable
389 for (j
= 0; j
< ntokens
; j
++)
390 /* and record this rule as the rule to use if that
392 if (bitset_test (LA
[state
->lookaheadsp
+ i
], j
))
393 actrow
[j
] = -LArule
[state
->lookaheadsp
+ i
]->number
;
396 /* Now see which tokens are allowed for shifts in this state. For
397 them, record the shift as the thing to do. So shift is preferred
399 for (i
= 0; i
< shiftp
->nshifts
; i
++)
401 token_number_t symbol
;
402 int shift_state
= shiftp
->shifts
[i
];
406 symbol
= states
[shift_state
]->accessing_symbol
;
411 actrow
[symbol
] = shift_state
;
413 /* Do not use any default reduction if there is a shift for
415 if (symbol
== errtoken
->number
)
419 /* See which tokens are an explicit error in this state (due to
420 %nonassoc). For them, record SHRT_MIN as the action. */
421 for (i
= 0; i
< errp
->nerrs
; i
++)
423 int symbol
= errp
->errs
[i
];
424 actrow
[symbol
] = SHRT_MIN
;
427 /* Now find the most common reduction and make it the default action
430 if (redp
->nreds
>= 1 && !nodefault
)
432 if (state
->consistent
)
433 default_rule
= redp
->rules
[0];
437 for (i
= 0; i
< state
->nlookaheads
; i
++)
440 int rule
= -LArule
[state
->lookaheadsp
+ i
]->number
;
443 for (j
= 0; j
< ntokens
; j
++)
444 if (actrow
[j
] == rule
)
454 /* actions which match the default are replaced with zero,
455 which means "use the default" */
460 for (j
= 0; j
< ntokens
; j
++)
461 if (actrow
[j
] == default_rule
)
464 default_rule
= -default_rule
;
469 /* If have no default rule, the default is an error.
470 So replace any action which says "error" with "use default". */
472 if (default_rule
== 0)
473 for (i
= 0; i
< ntokens
; i
++)
474 if (actrow
[i
] == SHRT_MIN
)
491 for (i
= 0; i
< ntokens
; i
++)
498 froms
[state
] = sp1
= sp
= XCALLOC (short, count
);
499 tos
[state
] = sp2
= XCALLOC (short, count
);
501 for (i
= 0; i
< ntokens
; i
++)
508 tally
[state
] = count
;
509 width
[state
] = sp1
[-1] - sp
[0] + 1;
513 /*------------------------------------------------------------------.
514 | Figure out the actions for the specified state, indexed by |
515 | lookahead token type. |
517 | The YYDEFACT table is output now. The detailed info is saved for |
518 | putting into YYTABLE later. |
519 `------------------------------------------------------------------*/
525 short *yydefact
= XCALLOC (short, nstates
);
527 actrow
= XCALLOC (short, ntokens
);
528 for (i
= 0; i
< nstates
; ++i
)
530 yydefact
[i
] = action_row (states
[i
]);
534 output_short_table (&format_obstack
, yydefact
,
535 yydefact
[0], 1, nstates
);
536 muscle_insert ("defact", obstack_finish (&format_obstack
));
543 /*-----------------------------.
544 | Output the actions to OOUT. |
545 `-----------------------------*/
548 actions_output (FILE *out
)
551 for (rule
= 1; rule
< nrules
+ 1; ++rule
)
552 if (rules
[rule
].action
)
554 fprintf (out
, " case %d:\n", rule
);
557 fprintf (out
, muscle_find ("linef"),
558 rules
[rule
].action_line
,
559 quotearg_style (c_quoting_style
,
560 muscle_find ("filename")));
561 /* As a Bison extension, add the ending semicolon. Since some
562 Yacc don't do that, help people using bison as a Yacc
563 finding their missing semicolons. */
564 fprintf (out
, "{ %s%s }\n break;\n\n",
566 yacc_flag
? ";" : "");
571 /*---------------------------------------.
572 | Output the tokens definition to OOUT. |
573 `---------------------------------------*/
576 token_definitions_output (FILE *out
)
580 for (i
= 0; i
< ntokens
; ++i
)
582 symbol_t
*symbol
= symbols
[i
];
583 int number
= symbol
->user_token_number
;
585 if (number
== SALIAS
)
587 /* Skip error token. */
588 if (symbol
== errtoken
)
590 if (symbol
->tag
[0] == '\'')
591 continue; /* skip literal character */
592 if (symbol
->tag
[0] == '\"')
594 /* use literal string only if given a symbol with an alias */
596 symbol
= symbol
->alias
;
601 /* Don't #define nonliteral tokens whose names contain periods
602 or '$' (as does the default value of the EOF token). */
603 if (strchr (symbol
->tag
, '.') || strchr (symbol
->tag
, '$'))
606 fprintf (out
, "%s [[[%s]], [%d]]",
607 first
? "" : ",\n", symbol
->tag
, number
);
614 save_column (int symbol
, int default_state
)
621 int symno
= symbol
- ntokens
+ nstates
;
623 short begin
= goto_map
[symbol
];
624 short end
= goto_map
[symbol
+ 1];
627 for (i
= begin
; i
< end
; i
++)
628 if (to_state
[i
] != default_state
)
634 froms
[symno
] = sp1
= sp
= XCALLOC (short, count
);
635 tos
[symno
] = sp2
= XCALLOC (short, count
);
637 for (i
= begin
; i
< end
; i
++)
638 if (to_state
[i
] != default_state
)
640 *sp1
++ = from_state
[i
];
641 *sp2
++ = to_state
[i
];
644 tally
[symno
] = count
;
645 width
[symno
] = sp1
[-1] - sp
[0] + 1;
649 default_goto (int symbol
)
652 size_t m
= goto_map
[symbol
];
653 size_t n
= goto_map
[symbol
+ 1];
654 int default_state
= -1;
660 for (i
= 0; i
< nstates
; i
++)
663 for (i
= m
; i
< n
; i
++)
664 state_count
[to_state
[i
]]++;
666 for (i
= 0; i
< nstates
; i
++)
667 if (state_count
[i
] > max
)
669 max
= state_count
[i
];
673 return default_state
;
677 /*-------------------------------------------------------------------.
678 | Figure out what to do after reducing with each rule, depending on |
679 | the saved state from before the beginning of parsing the data that |
680 | matched this rule. |
682 | The YYDEFGOTO table is output now. The detailed info is saved for |
683 | putting into YYTABLE later. |
684 `-------------------------------------------------------------------*/
690 short *yydefgoto
= XMALLOC (short, nsyms
- ntokens
);
692 state_count
= XCALLOC (short, nstates
);
693 for (i
= ntokens
; i
< nsyms
; ++i
)
695 int default_state
= default_goto (i
);
696 save_column (i
, default_state
);
697 yydefgoto
[i
- ntokens
] = default_state
;
700 output_short_table (&format_obstack
, yydefgoto
,
701 yydefgoto
[0], 1, nsyms
- ntokens
);
702 muscle_insert ("defgoto", obstack_finish (&format_obstack
));
709 /* The next few functions decide how to pack the actions and gotos
710 information into yytable. */
717 order
= XCALLOC (short, nvectors
);
720 for (i
= 0; i
< nvectors
; i
++)
726 int j
= nentries
- 1;
728 while (j
>= 0 && (width
[order
[j
]] < w
))
731 while (j
>= 0 && (width
[order
[j
]] == w
) && (tally
[order
[j
]] < t
))
734 for (k
= nentries
- 1; k
> j
; k
--)
735 order
[k
+ 1] = order
[k
];
744 matching_state (int vector
)
746 int i
= order
[vector
];
751 if (i
>= (int) nstates
)
757 for (prev
= vector
- 1; prev
>= 0; prev
--)
763 if (width
[j
] != w
|| tally
[j
] != t
)
766 for (k
= 0; match
&& k
< t
; k
++)
767 if (tos
[j
][k
] != tos
[i
][k
] || froms
[j
][k
] != froms
[i
][k
])
779 pack_vector (int vector
)
781 int i
= order
[vector
];
785 short *from
= froms
[i
];
790 for (j
= lowzero
- from
[0]; j
< (int) table_size
; j
++)
795 for (k
= 0; ok
&& k
< t
; k
++)
798 if (loc
> (int) table_size
)
805 for (k
= 0; ok
&& k
< vector
; k
++)
811 for (k
= 0; k
< t
; k
++)
815 check
[loc
] = from
[k
];
818 while (table
[lowzero
] != 0)
827 #define pack_vector_succeeded 0
828 assert (pack_vector_succeeded
);
840 base
= XCALLOC (short, nvectors
);
841 pos
= XCALLOC (short, nentries
);
842 table
= XCALLOC (short, table_size
);
843 check
= XCALLOC (short, table_size
);
848 for (i
= 0; i
< nvectors
; i
++)
851 for (i
= 0; i
< (int) table_size
; i
++)
854 for (i
= 0; i
< nentries
; i
++)
856 state
= matching_state (i
);
859 place
= pack_vector (i
);
864 base
[order
[i
]] = place
;
867 for (i
= 0; i
< nvectors
; i
++)
878 /* the following functions output yytable, yycheck
879 and the vectors whose elements index the portion starts */
885 output_short_table (&format_obstack
, base
,
886 base
[0], 1, nstates
);
887 muscle_insert ("pact", obstack_finish (&format_obstack
));
890 output_short_table (&format_obstack
, base
,
891 base
[nstates
], nstates
+ 1, nvectors
);
892 muscle_insert ("pgoto", obstack_finish (&format_obstack
));
901 output_short_table (&format_obstack
, table
,
902 table
[0], 1, high
+ 1);
903 muscle_insert ("table", obstack_finish (&format_obstack
));
911 output_short_table (&format_obstack
, check
,
912 check
[0], 1, high
+ 1);
913 muscle_insert ("check", obstack_finish (&format_obstack
));
917 /*-----------------------------------------------------------------.
918 | Compute and output yydefact, yydefgoto, yypact, yypgoto, yytable |
920 `-----------------------------------------------------------------*/
923 output_actions (void)
926 nvectors
= nstates
+ nvars
;
928 froms
= XCALLOC (short *, nvectors
);
929 tos
= XCALLOC (short *, nvectors
);
930 tally
= XCALLOC (short, nvectors
);
931 width
= XCALLOC (short, nvectors
);
938 XFREE (goto_map
+ ntokens
);
950 for (i
= 0; i
< nstates
; ++i
)
952 free (states
[i
]->shifts
);
953 XFREE (states
[i
]->reductions
);
954 free (states
[i
]->errs
);
961 /*---------------------------.
962 | Call the skeleton parser. |
963 `---------------------------*/
966 output_skeleton (void)
968 /* Store the definition of all the muscles. */
969 const char *tempdir
= getenv ("TMPDIR");
970 char *tempfile
= NULL
;
975 tempdir
= DEFAULT_TMPDIR
;
976 tempfile
= xmalloc (strlen (tempdir
) + 11);
977 sprintf (tempfile
, "%s/bsnXXXXXX", tempdir
);
978 fd
= mkstemp (tempfile
);
980 error (EXIT_FAILURE
, errno
, "%s", tempfile
);
982 out
= fdopen (fd
, "w");
984 error (EXIT_FAILURE
, errno
, "%s", tempfile
);
986 /* There are no comments, especially not `#': we do want M4 expansion
987 after `#': think of CPP macros! */
988 fputs ("m4_changecom()\n", out
);
989 fputs ("m4_init()\n", out
);
991 fputs ("m4_define([b4_actions], \n[[", out
);
992 actions_output (out
);
993 fputs ("]])\n\n", out
);
995 fputs ("m4_define([b4_tokens], \n[", out
);
996 token_definitions_output (out
);
997 fputs ("])\n\n", out
);
999 muscles_m4_output (out
);
1001 fputs ("m4_wrap([m4_divert_pop(0)])\n", out
);
1002 fputs ("m4_divert_push(0)dnl\n", out
);
1005 /* Invoke m4 on the definition of the muscles, and the skeleton. */
1007 const char *bison_pkgdatadir
= getenv ("BISON_PKGDATADIR");
1008 const char *m4
= getenv ("M4");
1011 if (!bison_pkgdatadir
)
1012 bison_pkgdatadir
= PKGDATADIR
;
1015 "running: %s -I %s m4sugar/m4sugar.m4 %s %s\n",
1016 m4
, bison_pkgdatadir
, tempfile
, skeleton
);
1017 skel_in
= readpipe (m4
,
1018 "-I", bison_pkgdatadir
,
1019 "m4sugar/m4sugar.m4",
1024 error (EXIT_FAILURE
, errno
, "cannot run m4");
1027 /* If `debugging', keep this file alive. */
1036 MUSCLE_INSERT_INT ("last", high
);
1037 MUSCLE_INSERT_INT ("flag", SHRT_MIN
);
1038 MUSCLE_INSERT_INT ("pure", pure_parser
);
1039 MUSCLE_INSERT_INT ("nsym", nsyms
);
1040 MUSCLE_INSERT_INT ("debug", debug_flag
);
1041 MUSCLE_INSERT_INT ("final", final_state
);
1042 MUSCLE_INSERT_INT ("undef_token_number", undeftoken
->number
);
1043 MUSCLE_INSERT_INT ("user_token_number_max", max_user_token_number
);
1044 MUSCLE_INSERT_INT ("error_verbose", error_verbose
);
1045 MUSCLE_INSERT_STRING ("prefix", spec_name_prefix
? spec_name_prefix
: "yy");
1047 /* FIXME: This is wrong: the muscles should decide whether they hold
1048 a copy or not, but the situation is too obscure currently. */
1049 MUSCLE_INSERT_STRING ("output_infix", output_infix
? output_infix
: "");
1050 MUSCLE_INSERT_STRING ("output_prefix", short_base_name
);
1051 MUSCLE_INSERT_STRING ("output_parser_name", parser_file_name
);
1052 MUSCLE_INSERT_STRING ("output_header_name", spec_defines_file
);
1054 MUSCLE_INSERT_INT ("nnts", nvars
);
1055 MUSCLE_INSERT_INT ("nrules", nrules
);
1056 MUSCLE_INSERT_INT ("nstates", nstates
);
1057 MUSCLE_INSERT_INT ("ntokens", ntokens
);
1059 MUSCLE_INSERT_INT ("locations_flag", locations_flag
);
1060 MUSCLE_INSERT_INT ("defines_flag", defines_flag
);
1062 /* Copy definitions in directive. */
1063 obstack_1grow (&pre_prologue_obstack
, 0);
1064 obstack_1grow (&post_prologue_obstack
, 0);
1065 muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack
));
1066 muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack
));
1068 /* Find the right skeleton file. */
1070 skeleton
= "bison.simple";
1072 /* Parse the skeleton file and output the needed parsers. */
1073 muscle_insert ("skeleton", skeleton
);
1077 /*----------------------------------------------------------.
1078 | Output the parsing tables and the parser code to ftable. |
1079 `----------------------------------------------------------*/
1084 obstack_init (&format_obstack
);
1093 /* Process the selected skeleton file. */
1096 obstack_free (&muscle_obstack
, NULL
);
1097 obstack_free (&format_obstack
, NULL
);
1098 obstack_free (&action_obstack
, NULL
);
1099 obstack_free (&pre_prologue_obstack
, NULL
);
1100 obstack_free (&post_prologue_obstack
, NULL
);