-/* Output the generated parsing program for bison,
+/* Output the generated parsing program for Bison.
Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
Free Software Foundation, Inc.
#include "system.h"
-#include "quotearg.h"
-#include "error.h"
-#include "subpipe.h"
-#include "getargs.h"
+
+#include <error.h>
+#include <get-errno.h>
+#include <quotearg.h>
+#include <subpipe.h>
+#include <timevar.h>
+
+#include "complain.h"
#include "files.h"
+#include "getargs.h"
#include "gram.h"
-#include "complain.h"
+#include "muscle_tab.h"
#include "output.h"
#include "reader.h"
#include "symtab.h"
#include "tables.h"
-#include "muscle_tab.h"
/* From src/scan-skel.l. */
void scan_skel (FILE *);
GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int)
GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_int_table, int)
GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_t)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number_t)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number_t)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number_t)
-GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number_t)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_base_table, base_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_rule_number_table, rule_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number)
+GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_state_number_table, state_number)
+
+
+/*----------------------------------------------------------------------.
+| Print to OUT a representation of FILENAME escaped both for C and M4. |
+`----------------------------------------------------------------------*/
+
+static void
+escaped_file_name_output (FILE *out, char const *filename)
+{
+ char const *p;
+ fprintf (out, "[[");
+
+ for (p = quotearg_style (c_quoting_style, filename); *p; p++)
+ switch (*p)
+ {
+ case '$': fputs ("$][", out); break;
+ case '@': fputs ("@@", out); break;
+ case '[': fputs ("@{", out); break;
+ case ']': fputs ("@}", out); break;
+ default: fputc (*p, out); break;
+ }
+
+ fprintf (out, "]]");
+}
/*------------------------------------------------------------------.
const char *cp =
quotearg_n_style (1, c_quoting_style,
symbols[i]->tag);
- /* Width of the next token, including the two quotes, the coma
+ /* Width of the next token, including the two quotes, the comma
and the space. */
- int strsize = strlen (cp) + 2;
+ int width = strlen (cp) + 2;
- if (j + strsize > 75)
+ if (j + width > 75)
{
obstack_sgrow (&format_obstack, "\n ");
j = 2;
}
- obstack_sgrow (&format_obstack, cp);
+ MUSCLE_OBSTACK_SGROW (&format_obstack, cp);
obstack_sgrow (&format_obstack, ", ");
- j += strsize;
+ j += width;
}
/* Add a NULL entry to list of tokens (well, 0, as NULL might not be
defined). */
/*-------------------------------------------------------------.
| Prepare the muscles related to the rules: rhs, prhs, r1, r2, |
-| rline, dprec, merger |
+| rline, dprec, merger. |
`-------------------------------------------------------------*/
static void
prepare_rules (void)
{
- rule_number_t r;
+ rule_number r;
unsigned int i = 0;
- item_number_t *rhs = XMALLOC (item_number_t, nritems);
+ item_number *rhs = XMALLOC (item_number, nritems);
unsigned int *prhs = XMALLOC (unsigned int, nrules);
unsigned int *rline = XMALLOC (unsigned int, nrules);
- symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules);
+ symbol_number *r1 = XMALLOC (symbol_number, nrules);
unsigned int *r2 = XMALLOC (unsigned int, nrules);
short *dprec = XMALLOC (short, nrules);
short *merger = XMALLOC (short, nrules);
for (r = 0; r < nrules; ++r)
{
- item_number_t *rhsp = NULL;
+ item_number *rhsp = NULL;
/* Index of rule R in RHS. */
prhs[r] = i;
/* RHS of the rule R. */
/* Separator in RHS. */
rhs[i++] = -1;
/* Line where rule was defined. */
- rline[r] = rules[r].location.first_line;
- /* Dynamic precedence (GLR) */
+ rline[r] = rules[r].location.start.line;
+ /* Dynamic precedence (GLR). */
dprec[r] = rules[r].dprec;
- /* Merger-function index (GLR) */
+ /* Merger-function index (GLR). */
merger[r] = rules[r].merger;
}
- assert (i == nritems);
+ if (i != nritems)
+ abort ();
muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
static void
prepare_states (void)
{
- state_number_t i;
- symbol_number_t *values =
- (symbol_number_t *) alloca (sizeof (symbol_number_t) * nstates);
+ state_number i;
+ symbol_number *values =
+ (symbol_number *) alloca (sizeof (symbol_number) * nstates);
for (i = 0; i < nstates; ++i)
values[i] = states[i]->accessing_symbol;
muscle_insert_symbol_number_table ("stos", values,
static void
user_actions_output (FILE *out)
{
- rule_number_t r;
+ rule_number r;
fputs ("m4_define([b4_actions], \n[[", out);
for (r = 0; r < nrules; ++r)
{
fprintf (out, " case %d:\n", r + 1);
- if (!no_lines_flag)
- fprintf (out, muscle_find ("linef"),
- rules[r].action_location.first_line,
- quotearg_style (c_quoting_style,
- muscle_find ("filename")));
+ fprintf (out, "]b4_syncline([[%d]], ",
+ rules[r].action_location.start.line);
+ escaped_file_name_output (out, rules[r].action_location.start.file);
+ fprintf (out, ")[\n");
fprintf (out, " %s\n break;\n\n",
rules[r].action);
}
fputs ("m4_define([b4_tokens], \n[", out);
for (i = 0; i < ntokens; ++i)
{
- symbol_t *symbol = symbols[i];
- int number = symbol->user_token_number;
+ symbol *sym = symbols[i];
+ int number = sym->user_token_number;
/* At this stage, if there are literal aliases, they are part of
SYMBOLS, so we should not find symbols which are the aliases
here. */
- assert (number != USER_NUMBER_ALIAS);
+ if (number == USER_NUMBER_ALIAS)
+ abort ();
/* Skip error token. */
- if (symbol == errtoken)
+ if (sym == errtoken)
continue;
/* If this string has an alias, then it is necessarily the alias
which is to be output. */
- if (symbol->alias)
- symbol = symbol->alias;
+ if (sym->alias)
+ sym = sym->alias;
/* Don't output literal chars or strings (when defined only as a
string). Note that must be done after the alias resolution:
think about `%token 'f' "f"'. */
- if (symbol->tag[0] == '\'' || symbol->tag[0] == '\"')
+ if (sym->tag[0] == '\'' || sym->tag[0] == '\"')
continue;
/* Don't #define nonliteral tokens whose names contain periods
or '$' (as does the default value of the EOF token). */
- if (strchr (symbol->tag, '.') || strchr (symbol->tag, '$'))
+ if (strchr (sym->tag, '.') || strchr (sym->tag, '$'))
continue;
fprintf (out, "%s[[[%s]], [%d]]",
- first ? "" : ",\n", symbol->tag, number);
+ first ? "" : ",\n", sym->tag, number);
first = 0;
}
for (i = 0; i < nsyms; ++i)
if (symbols[i]->destructor)
{
- symbol_t *symbol = symbols[i];
+ symbol *sym = symbols[i];
/* Filename, lineno,
Symbol-name, Symbol-number,
destructor, typename. */
- fprintf (out, "%s[[[%s]], [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- first ? "" : ",\n",
- infile, symbol->destructor_location.first_line,
- symbol->tag,
- symbol->number,
- symbol->destructor,
- symbol->type_name);
+ fprintf (out, "%s[",
+ first ? "" : ",\n");
+ escaped_file_name_output (out, sym->destructor_location.start.file);
+ fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+ sym->destructor_location.start.line,
+ sym->tag,
+ sym->number,
+ sym->destructor,
+ sym->type_name);
first = 0;
}
for (i = 0; i < nsyms; ++i)
if (symbols[i]->destructor)
{
- symbol_t *symbol = symbols[i];
+ symbol *sym = symbols[i];
/* Filename, lineno,
Symbol-name, Symbol-number,
printer, typename. */
- fprintf (out, "%s[[[%s]], [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- first ? "" : ",\n",
- infile, symbol->printer_location.first_line,
- symbol->tag,
- symbol->number,
- symbol->printer,
- symbol->type_name);
+ fprintf (out, "%s[",
+ first ? "" : ",\n");
+ escaped_file_name_output (out, sym->printer_location.start.file);
+ fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
+ sym->printer_location.start.line,
+ sym->tag,
+ sym->number,
+ sym->printer,
+ sym->type_name);
first = 0;
}
strcpy (full_path, pkgdatadir);
full_path[pkgdatadirlen] = '/';
strcpy (full_path + pkgdatadirlen + 1, m4sugar);
- in = fopen (full_path, "r");
- if (! in || fclose (in) != 0)
- error (EXIT_FAILURE, errno, "%s", full_path);
+ xfclose (xfopen (full_path, "r"));
strcpy (full_path + pkgdatadirlen + 1, skeleton);
/* Create an m4 subprocess connected to us via two pipes. */
out = fdopen (filter_fd[0], "w");
if (! out)
- error (EXIT_FAILURE, errno, "fdopen");
+ error (EXIT_FAILURE, get_errno (), "fdopen");
/* Output the definitions of all the muscles. */
fputs ("m4_init()\n", out);
fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
fputs ("m4_divert_push(0)dnl\n", out);
- if (ferror (out))
- error (EXIT_FAILURE, 0, "pipe output error");
xfclose (out);
/* Read and process m4's output. */
timevar_push (TV_M4);
in = fdopen (filter_fd[1], "r");
if (! in)
- error (EXIT_FAILURE, errno, "fdopen");
+ error (EXIT_FAILURE, get_errno (), "fdopen");
scan_skel (in);
- if (ferror (in))
- error (EXIT_FAILURE, 0, "pipe input error");
xfclose (in);
reap_subpipe (pid, m4);
timevar_pop (TV_M4);
prepare (void)
{
/* Flags. */
- MUSCLE_INSERT_INT ("locations_flag", locations_flag);
+ MUSCLE_INSERT_INT ("debug", debug_flag);
MUSCLE_INSERT_INT ("defines_flag", defines_flag);
MUSCLE_INSERT_INT ("error_verbose", error_verbose);
+ MUSCLE_INSERT_INT ("locations_flag", locations_flag);
MUSCLE_INSERT_INT ("pure", pure_parser);
- MUSCLE_INSERT_INT ("debug", debug_flag);
+ MUSCLE_INSERT_INT ("synclines_flag", !no_lines_flag);
- /* FIXME: This is wrong: the muscles should decide whether they hold
- a copy or not, but the situation is too obscure currently. */
+ /* File names. */
MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
- MUSCLE_INSERT_STRING ("output_infix", output_infix ? output_infix : "");
- MUSCLE_INSERT_STRING ("output_prefix", short_base_name);
- MUSCLE_INSERT_STRING ("output_parser_name", parser_file_name);
- MUSCLE_INSERT_STRING ("output_header_name", spec_defines_file);
/* User Code. */
obstack_1grow (&pre_prologue_obstack, 0);
}
/* Parse the skeleton file and output the needed parsers. */
- MUSCLE_INSERT_STRING ("skeleton", skeleton);
+ MUSCLE_INSERT_C_STRING ("skeleton", skeleton);
}
projects / bison.git / blobdiff