/* Output the generated parsing program for Bison.
- Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
+
+ Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
#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 *);
{ \
Type min = first; \
Type max = first; \
+ long int lmin; \
+ long int lmax; \
int i; \
int j = 1; \
\
obstack_1grow (&format_obstack, 0); \
muscle_insert (name, obstack_finish (&format_obstack)); \
\
+ lmin = min; \
+ lmax = max; \
/* Build `NAME_min' and `NAME_max' in the obstack. */ \
obstack_fgrow1 (&format_obstack, "%s_min", name); \
obstack_1grow (&format_obstack, 0); \
- MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), \
- (long int) min); \
+ MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmin); \
obstack_fgrow1 (&format_obstack, "%s_max", name); \
obstack_1grow (&format_obstack, 0); \
- MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), \
- (long int) max); \
+ MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), lmax); \
}
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)
/*----------------------------------------------------------------------.
symbols[i]->tag);
/* 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;
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). */
/* Output YYTOKNUM. */
{
int i;
- int *values = XCALLOC (int, ntokens);
+ int *values = MALLOC (values, ntokens);
for (i = 0; i < ntokens; ++i)
values[i] = symbols[i]->user_token_number;
muscle_insert_int_table ("toknum", values,
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);
- unsigned int *prhs = XMALLOC (unsigned int, nrules);
- unsigned int *rline = XMALLOC (unsigned int, nrules);
- symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules);
- unsigned int *r2 = XMALLOC (unsigned int, nrules);
- short *dprec = XMALLOC (short, nrules);
- short *merger = XMALLOC (short, nrules);
+ item_number *rhs = MALLOC (rhs, nritems);
+ unsigned int *prhs = MALLOC (prhs, nrules);
+ unsigned int *rline = MALLOC (rline, nrules);
+ symbol_number *r1 = MALLOC (r1, nrules);
+ unsigned int *r2 = MALLOC (r2, nrules);
+ short *dprec = MALLOC (dprec, nrules);
+ short *merger = MALLOC (merger, 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;
+ rline[r] = rules[r].location.start.line;
/* Dynamic precedence (GLR). */
dprec[r] = rules[r].dprec;
/* Merger-function index (GLR). */
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 = MALLOC (values, nstates);
for (i = 0; i < nstates; ++i)
values[i] = states[i]->accessing_symbol;
muscle_insert_symbol_number_table ("stos", values,
0, 1, nstates);
+ free (values);
MUSCLE_INSERT_INT ("last", high);
MUSCLE_INSERT_INT ("final_state_number", final_state->number);
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);
fprintf (out, "]b4_syncline([[%d]], ",
- rules[r].action_location.first_line);
- escaped_file_name_output (out, rules[r].action_location.file);
+ 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
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[",
first ? "" : ",\n");
- escaped_file_name_output (out, symbol->destructor_location.file);
+ escaped_file_name_output (out, sym->destructor_location.start.file);
fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- symbol->destructor_location.first_line,
- symbol->tag,
- symbol->number,
- symbol->destructor,
- symbol->type_name);
+ sym->destructor_location.start.line,
+ sym->tag,
+ sym->number,
+ sym->destructor,
+ sym->type_name);
first = 0;
}
fputs ("m4_define([b4_symbol_printers], \n[", out);
for (i = 0; i < nsyms; ++i)
- if (symbols[i]->destructor)
+ if (symbols[i]->printer)
{
- symbol_t *symbol = symbols[i];
+ symbol *sym = symbols[i];
/* Filename, lineno,
Symbol-name, Symbol-number,
printer, typename. */
fprintf (out, "%s[",
first ? "" : ",\n");
- escaped_file_name_output (out, symbol->printer_location.file);
+ escaped_file_name_output (out, sym->printer_location.start.file);
fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- symbol->printer_location.first_line,
- symbol->tag,
- symbol->number,
- symbol->printer,
- symbol->type_name);
+ sym->printer_location.start.line,
+ sym->tag,
+ sym->number,
+ sym->printer,
+ sym->type_name);
first = 0;
}
FILE *in;
FILE *out;
int filter_fd[2];
- char const *argv[7];
+ char const *argv[6];
pid_t pid;
/* Compute the names of the package data dir and skeleton file.
installation. A faulty installation can cause deadlock, so a
cheap sanity check is worthwhile. */
char const m4sugar[] = "m4sugar/m4sugar.m4";
+ char *full_m4sugar;
+ char *full_cm4;
char *full_path;
char const *p;
char const *m4 = (p = getenv ("M4")) ? p : M4;
strcpy (full_path, pkgdatadir);
full_path[pkgdatadirlen] = '/';
strcpy (full_path + pkgdatadirlen + 1, m4sugar);
- xfclose (xfopen (full_path, "r"));
+ full_m4sugar = xstrdup (full_path);
+ strcpy (full_path + pkgdatadirlen + 1, "c.m4");
+ full_cm4 = xstrdup (full_path);
strcpy (full_path + pkgdatadirlen + 1, skeleton);
+ xfclose (xfopen (full_m4sugar, "r"));
/* Create an m4 subprocess connected to us via two pipes. */
if (trace_flag & trace_tools)
- fprintf (stderr, "running: %s -I %s %s - %s\n",
- m4, pkgdatadir, m4sugar, full_path);
+ fprintf (stderr, "running: %s %s - %s %s\n",
+ m4, full_m4sugar, full_cm4, full_path);
argv[0] = m4;
- argv[1] = "-I";
- argv[2] = pkgdatadir;
- argv[3] = m4sugar;
- argv[4] = "-";
- argv[5] = full_path;
- argv[6] = NULL;
+ argv[1] = full_m4sugar;
+ argv[2] = "-";
+ argv[3] = full_cm4;
+ argv[4] = full_path;
+ argv[5] = NULL;
init_subpipe ();
pid = create_subpipe (argv, filter_fd);
+ free (full_m4sugar);
+ free (full_cm4);
free (full_path);
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);
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);
xfclose (in);
reap_subpipe (pid, m4);
projects / bison.git / blobdiff