[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Bison fixes to avoid namespace collisions with POSIX, etc.
|
From: |
Paul Eggert |
|
Subject: |
Bison fixes to avoid namespace collisions with POSIX, etc. |
|
Date: |
Tue, 10 Dec 2002 23:16:16 -0800 (PST) |
Bison uses several identifiers like "location_t" that are part of the
reserved POSIX namespace. I installed the following large and tedious
patch that cleans up all such problems that I could find.
2002-12-09 Paul Eggert <address@hidden>
Change identifier spellings to avoid collisions with names
thta are reserved by POSIX.
Don't use names ending in _t, since POSIX reserves them.
For consistency, remove _e and _s endings -- they're weren't
needed to remove ambiguity. All uses changed.
* src/uniqstr.h (uniqstr): Renamed from uniqstr_t, which in
turn was just renamed from struniq_t.
* src/uniqstr.c (uniqstr_processor): Renamed from struniq_processor,
which in turn was just renamed from struniq_processor_t.
(hash_compare_uniqstr): Renamed from hash_compare_struniq, which
in turn was renamed from hash_compare_struniq_t.
* src/LR0.c (struct state_list): Renamed from struct state_list_s.
(state_list): Renamed from state_list_t.
* src/assoc.h (assoc): Renamed from assoc_t.
* src/conflicts.c (enum conflict_resolution): Renamed from
enum conflict_resolution_e.
* src/derives.c (struct rule_list): Renamed from struct rule_list_s.
(rule_list): Renamed from rule_list_t.
* src/getargs.h (enum trace): Renamed from enum trace_e.
(enum report): Renamed from enum report_e.
* src/gram.h (item_number): Renamed from item_number_t.
(rule_number): Renamed from rule_number_t.
(struct rule_s): Remove the "rule_s" part; not used.
(rule): Renamed from rule_t.
(rule_filter): Renamed from rule_filter_t.
* src/lalr.c (struct goto_list): Renamed from struct goto_list_s.
(goto_list): Renamed from goto_list_t.
* src/lalr.h (goto_number): Renamed from goto_number_t.
* src/location.h (location): Renamed from location_t.
* src/muscle_tab.c (muscle_entry): Renamed from muscle_entry_t,
and moved here from:
* src/muscle_tab.h (muscle_entry_t): here.
* src/nullable.c (struct rule_list): Renamed from struct rule_list_s.
(rule_list): Renamed from rule_list_t.
* src/print_graph.c (static_graph): Renamed from graph.
* src/reader.h (braced_code): Renamed from braced_code_t.
Remove brace_code_e tag.
* src/relation.h (relation_node): Renamed from relation_node_t.
(relation_nodes): Renamed from relation_nodes_t.
(relation): Renamed from relation_t.
* src/state.h (state_number): Renamed from state_number_t.
(struct state): Renamed from struct state_s.
(state): Renamed from state_t.
(transitions): Renamed from transitions_t. Unused (and
misspelled) transtion_s tag removed.
(errs): Renamed from errs_t. Unused errs_s tag removed.
(reductions): Renamed from reductions_t. Unused tag
reductions_s removed.
* src/symlist.h (symbol_list): Renamed from symbol_list_t.
(struct symbol_list): Renamed from struct symbol_list_s.
* src/symtab.h (symbol_number): Renamed from symbol_number_t.
(struct symbol): Renamed from struct symbol_s.
(symbol): Renamed from symbol_t.
* src/tables.c (vector_number): Renamed from vector_number_t.
(action_number): Renamed from action_t.
* src/tables.h (base_number): Renamed from base_t.
* src/vcg.h (enum color): Renamed from enum color_e.
(enum textmode): Renamed from enum textmode_e.
(enum shape): Renamed from enum shape_e.
(struct colorentry): Renamed from struct colorentry_s.
(struct classname): Renamed from struct classname_s.
(struct infoname): Renamed from struct infoname_s.
(enum layoutalgorithm): Renamed from enum layoutalgorithm_e.
(enum decision): Renamed from enum decision_e.
(enum orientation): Renamed from enum orientation_e.
(enum alignment): Renamed from enum alignment_e.
(enum arrow_mode): Renamed from enum arrow_mode_e.
(enum crossing_type): Renamed from enum crossing_type_e.
(enum view): Renamed from enum view_e.
(struct node): Renamed from struct node_s.
(node): Renamed from node_t.
(enum linestyle): Renamed from enum linestyle_e.
(enum arrowstyle): Renamed from enum arrowstyle_e.
(struct edge): Renamed from struct edge.
(edge): Renamed from edge_t.
(struct graph): Renamed from struct graph_s.
(graph): Renamed from graph_t.
* tests/calc.at (_AT_DATA_CALC_Y, Simple LALR Calculator):
Rename value_t -> value.
* tests/input.at (Torturing the Scanner): Rename value_t -> value,
value_t_as_yystype -> value_as_yystype.
Don't include <errno.h> in the mainstream code, since it
reserves E[A-Z0-9]* and we want to use symbols like 'EQUALS'.
* lib/get-errno.c, lib/get-errno.h: New files.
* lib/Makefile.am (libbison_a_SOURCES): Add get-errno.h,
get-errno.c.
* src/files.c (xfopen, xfclose): Use get_errno instead of errno.
* src/output.c (output_skeleton): Likewise.
* src/scan-gram.l (<INITIAL>{int}): Use set_errno and get_errno
instead of errno.
(<SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>\\x[0-9abcdefABCDEF]+):
Likewise.
(handle_action_dollar, handle_action_at): Likewise.
* src/system.h: Do not include <errno.h>.
(TAB_EXT): Renamed from EXT_TAB.
(OUTPUT_EXT): Renamed from EXT_OUTPUT.
Avoid str[a-z]*, since <string.h> reserves that name space.
Change all instances of "struniq" in names to "uniqstr", and
likewise for "STRUNIQ" and "UNIQSTR".
* src/uniqstr.c: Renamed from src/struniq.c.
* src/uniqstr.h: Renamed from src/struniq.h.
* src/Makefile.am (bison_SOURCES): Adjust to these renamings.
* src/files.c (strsuffix): Remove; unused.
(concat2): Renamed from stringappend. Now static.
* src/files.h (strsuffix, stringappend): Remove; unused.
* src/parse-gram.y (<chars>): Renamed from <string>.
(<uniqstr>): Renamed from <struniq>.
* src/scan-gram.l (obstack_for_string): Renamed from string_obstack.
* src/vcg.h (struct node_s.expand): Renamed from struct node_s.stretch.
(struct graph_s.expand): Renamed from struct graph_s.stretch.
* src/vcg_defaults.h (G_EXPAND): Renamed from G_STRETCH.
(G_LONG_STRAIGHT_PHASE): Renamed from G_STRAIGHT_PHASE.
(N_EXPAND): Renamed from N_STRETCH.
Avoid *_MAX and *_MIN, since <limits.h> reserves that name space.
* data/yacc.c (YYSTACK_GAP_MAXIMUM): Renamed from YYSTACK_GAP_MAX.
* src/gram.h (ITEM_NUMBER_MAX, ITEM_NUMBER_MIN, RULE_NUMBER_MAX):
Remove; unused.
* src/lalr.h (GOTO_NUMBER_MAXIMUM): Renamed from GOTO_NUMBER_MAX.
* src/state.h (STATE_NUMBER_MAXIMUM): Renamed from STATE_NUMBER_MAX.
* src/symtab.h (SYMBOL_NUMBER_MAXIMUM): Renamed from SYMBOL_NUMBER_MAX.
* src/tables.c (VECTOR_NUMBER_MAX, VECTOR_NUMBER_MIN): Remove; unused.
(BASE_MAXIMUM): Renamed from BASE_MAX.
(BASE_MINIMUM): Renamed from BASE_MIN.
(ACTION_MAX): Remove; unused.
(ACTION_NUMBER_MINIMUM): Renamed from ACTION_MIN.
Unnecessary casts removed from above defines.
Fix misspelling in names.
* src/vcg.h (enum_alignment_e): Renamed from enum_alignement_e.
* src/vcg_defaults.h (G_NODE_ALIGNMENT): Renamed from
G_NODE_ALIGNEMENT.
* lib/timevar.c (timevar_report): Renamed from time_report,
for consistency with other names.
* lib/timevar.h (timevar_report): New decl.
* src/system.h (time_report): Remove; decl is now in lib/timevar.h.
Include-file cleanup.
Reorder all include files under src to be in the order "system.h".
then the ../lib include files in angle brackets (alphabetized),
then the . include files in double-quotes (alphabetized). Fix
dependency breakages encountered in this process, as follows:
* src/closure.h, src/derives.h, src/state.h: Include "gram.h".
* src/complain.c: Don't include stdlib.h, string.h _LIBC stuff.
* src/state.h: Include "symtab.h".
Before applying this patch, do this:
mv src/struniq.c src/uniqstr.c
mv src/struniq.h src/uniqstr.h
Index: data/yacc.c
===================================================================
RCS file: /cvsroot/bison/bison/data/yacc.c,v
retrieving revision 1.41
diff -p -u -r1.41 yacc.c
--- data/yacc.c 9 Dec 2002 04:48:38 -0000 1.41
+++ data/yacc.c 11 Dec 2002 05:09:21 -0000
@@ -261,17 +261,17 @@ union yyalloc
[};
/* The size of the maximum gap between one aligned stack and the next. */
-# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
]b4_location_if(
[# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
- + 2 * YYSTACK_GAP_MAX)],
+ + 2 * YYSTACK_GAP_MAXIMUM)],
[# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE))
\
- + YYSTACK_GAP_MAX)])[
+ + YYSTACK_GAP_MAXIMUM)])[
/* Copy COUNT objects from FROM to TO. The source and destination do
not overlap. */
@@ -302,7 +302,7 @@ union yyalloc
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
}
\
while (0)
Index: lib/Makefile.am
===================================================================
RCS file: /cvsroot/bison/bison/lib/Makefile.am,v
retrieving revision 1.35
diff -p -u -r1.35 Makefile.am
--- lib/Makefile.am 30 Nov 2002 09:10:55 -0000 1.35
+++ lib/Makefile.am 11 Dec 2002 05:09:21 -0000
@@ -35,6 +35,7 @@ EXTRA_DIST = malloc.c realloc.c strnlen.
libbison_a_SOURCES = \
gettext.h \
basename.c dirname.h dirname.c \
+ get-errno.h get-errno.c \
getopt.h getopt.c getopt1.c \
hash.h hash.c \
mbswidth.h mbswidth.c \
Index: lib/timevar.c
===================================================================
RCS file: /cvsroot/bison/bison/lib/timevar.c,v
retrieving revision 1.4
diff -p -u -r1.4 timevar.c
--- lib/timevar.c 20 Oct 2002 05:34:55 -0000 1.4
+++ lib/timevar.c 11 Dec 2002 05:09:22 -0000
@@ -36,7 +36,7 @@ Software Foundation, 59 Temple Place - S
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# endif
-int time_report = 0;
+int timevar_report = 0;
#endif
@@ -134,7 +134,7 @@ static float clocks_to_msec;
/* See timevar.h for an explanation of timing variables. */
/* This macro evaluates to nonzero if timing variables are enabled. */
-#define TIMEVAR_ENABLE (time_report)
+#define TIMEVAR_ENABLE (timevar_report)
/* A timing variable. */
Index: lib/timevar.h
===================================================================
RCS file: /cvsroot/bison/bison/lib/timevar.h,v
retrieving revision 1.2
diff -p -u -r1.2 timevar.h
--- lib/timevar.h 13 Oct 2002 05:58:38 -0000 1.2
+++ lib/timevar.h 11 Dec 2002 05:09:22 -0000
@@ -88,4 +88,6 @@ extern void timevar_print PARAMS ((FILE
extern long get_run_time PARAMS ((void));
extern void print_time PARAMS ((const char *, long));
+extern int timevar_report;
+
#endif /* ! GCC_TIMEVAR_H */
Index: src/LR0.c
===================================================================
RCS file: /cvsroot/bison/bison/src/LR0.c,v
retrieving revision 1.84
diff -p -u -r1.84 LR0.c
--- src/LR0.c 4 Sep 2002 10:18:14 -0000 1.84
+++ src/LR0.c 11 Dec 2002 05:09:22 -0000
@@ -25,28 +25,30 @@
The entry point is generate_states. */
#include "system.h"
-#include "bitset.h"
-#include "quotearg.h"
-#include "symtab.h"
-#include "gram.h"
+
+#include <bitset.h>
+#include <quotearg.h>
+
+#include "LR0.h"
+#include "closure.h"
+#include "complain.h"
#include "getargs.h"
-#include "reader.h"
#include "gram.h"
-#include "state.h"
-#include "complain.h"
-#include "closure.h"
-#include "LR0.h"
+#include "gram.h"
#include "lalr.h"
+#include "reader.h"
#include "reduce.h"
+#include "state.h"
+#include "symtab.h"
-typedef struct state_list_s
+typedef struct state_list
{
- struct state_list_s *next;
- state_t *state;
-} state_list_t;
+ struct state_list *next;
+ state *state;
+} state_list;
-static state_list_t *first_state = NULL;
-static state_list_t *last_state = NULL;
+static state_list *first_state = NULL;
+static state_list *last_state = NULL;
/*------------------------------------------------------------------.
@@ -54,24 +56,23 @@ static state_list_t *last_state = NULL;
| later examination, in order to find its transitions. Return it. |
`------------------------------------------------------------------*/
-static state_t *
-state_list_append (symbol_number_t symbol,
- size_t core_size, item_number_t *core)
+static state *
+state_list_append (symbol_number sym, size_t core_size, item_number *core)
{
- state_list_t *node = XMALLOC (state_list_t, 1);
- state_t *state = state_new (symbol, core_size, core);
+ state_list *node = XMALLOC (state_list, 1);
+ state *s = state_new (sym, core_size, core);
if (trace_flag & trace_automaton)
fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
- nstates, symbol, symbols[symbol]->tag);
+ nstates, sym, symbols[sym]->tag);
/* If this is the endtoken, and this is not the initial state, then
this is the final state. */
- if (symbol == 0 && first_state)
- final_state = state;
+ if (sym == 0 && first_state)
+ final_state = s;
node->next = NULL;
- node->state = state;
+ node->state = s;
if (!first_state)
first_state = node;
@@ -79,26 +80,26 @@ state_list_append (symbol_number_t symbo
last_state->next = node;
last_state = node;
- return state;
+ return s;
}
static int nshifts;
-static symbol_number_t *shift_symbol = NULL;
+static symbol_number *shift_symbol = NULL;
-static rule_t **redset = NULL;
-static state_t **shiftset = NULL;
+static rule **redset = NULL;
+static state **shiftset = NULL;
-static item_number_t **kernel_base = NULL;
+static item_number **kernel_base = NULL;
static int *kernel_size = NULL;
-static item_number_t *kernel_items = NULL;
+static item_number *kernel_items = NULL;
static void
allocate_itemsets (void)
{
- symbol_number_t i;
- rule_number_t r;
- item_number_t *rhsp;
+ symbol_number i;
+ rule_number r;
+ item_number *rhsp;
/* Count the number of occurrences of all the symbols in RITEMS.
Note that useless productions (hence useless nonterminals) are
@@ -116,13 +117,13 @@ allocate_itemsets (void)
/* See comments before new_itemsets. All the vectors of items
live inside KERNEL_ITEMS. The number of active items after
- some symbol cannot be more than the number of times that symbol
- appears as an item, which is SYMBOL_COUNT[SYMBOL].
+ some symbol S cannot be more than the number of times that S
+ appears as an item, which is SYMBOL_COUNT[S].
We allocate that much space for each symbol. */
- kernel_base = XCALLOC (item_number_t *, nsyms);
+ kernel_base = XCALLOC (item_number *, nsyms);
if (count)
- kernel_items = XCALLOC (item_number_t, count);
+ kernel_items = XCALLOC (item_number, count);
count = 0;
for (i = 0; i < nsyms; i++)
@@ -141,10 +142,10 @@ allocate_storage (void)
{
allocate_itemsets ();
- shiftset = XCALLOC (state_t *, nsyms);
- redset = XCALLOC (rule_t *, nrules);
+ shiftset = XCALLOC (state *, nsyms);
+ redset = XCALLOC (rule *, nrules);
state_hash_new ();
- shift_symbol = XCALLOC (symbol_number_t, nsyms);
+ shift_symbol = XCALLOC (symbol_number, nsyms);
}
@@ -164,7 +165,7 @@ free_storage (void)
/*---------------------------------------------------------------.
-| Find which symbols can be shifted in STATE, and for each one |
+| Find which symbols can be shifted in S, and for each one |
| record which items would be active after that shift. Uses the |
| contents of itemset. |
| |
@@ -175,13 +176,12 @@ free_storage (void)
`---------------------------------------------------------------*/
static void
-new_itemsets (state_t *state)
+new_itemsets (state *s)
{
int i;
if (trace_flag & trace_automaton)
- fprintf (stderr, "Entering new_itemsets, state = %d\n",
- state->number);
+ fprintf (stderr, "Entering new_itemsets, state = %d\n", s->number);
for (i = 0; i < nsyms; i++)
kernel_size[i] = 0;
@@ -191,39 +191,38 @@ new_itemsets (state_t *state)
for (i = 0; i < nritemset; ++i)
if (ritem[itemset[i]] >= 0)
{
- symbol_number_t symbol
- = item_number_as_symbol_number (ritem[itemset[i]]);
- if (!kernel_size[symbol])
+ symbol_number sym = item_number_as_symbol_number (ritem[itemset[i]]);
+ if (!kernel_size[sym])
{
- shift_symbol[nshifts] = symbol;
+ shift_symbol[nshifts] = sym;
nshifts++;
}
- kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
- kernel_size[symbol]++;
+ kernel_base[sym][kernel_size[sym]] = itemset[i] + 1;
+ kernel_size[sym]++;
}
}
-/*-----------------------------------------------------------------.
-| Find the state we would get to (from the current state) by |
-| shifting SYMBOL. Create a new state if no equivalent one exists |
-| already. Used by append_states. |
-`-----------------------------------------------------------------*/
+/*--------------------------------------------------------------.
+| Find the state we would get to (from the current state) by |
+| shifting SYM. Create a new state if no equivalent one exists |
+| already. Used by append_states. |
+`--------------------------------------------------------------*/
-static state_t *
-get_state (symbol_number_t symbol, size_t core_size, item_number_t *core)
+static state *
+get_state (symbol_number sym, size_t core_size, item_number *core)
{
- state_t *sp;
+ state *sp;
if (trace_flag & trace_automaton)
fprintf (stderr, "Entering get_state, symbol = %d (%s)\n",
- symbol, symbols[symbol]->tag);
+ sym, symbols[sym]->tag);
sp = state_hash_lookup (core_size, core);
if (!sp)
- sp = state_list_append (symbol, core_size, core);
+ sp = state_list_append (sym, core_size, core);
if (trace_flag & trace_automaton)
fprintf (stderr, "Exiting get_state => %d\n", sp->number);
@@ -233,41 +232,34 @@ get_state (symbol_number_t symbol, size_
/*---------------------------------------------------------------.
| Use the information computed by new_itemsets to find the state |
-| numbers reached by each shift transition from STATE. |
+| numbers reached by each shift transition from S. |
| |
| SHIFTSET is set up as a vector of those states. |
`---------------------------------------------------------------*/
static void
-append_states (state_t *state)
+append_states (state *s)
{
int i;
- int j;
- symbol_number_t symbol;
if (trace_flag & trace_automaton)
- fprintf (stderr, "Entering append_states, state = %d\n",
- state->number);
+ fprintf (stderr, "Entering append_states, state = %d\n", s->number);
- /* first sort shift_symbol into increasing order */
+ /* First sort shift_symbol into increasing order. */
for (i = 1; i < nshifts; i++)
{
- symbol = shift_symbol[i];
- j = i;
- while (j > 0 && shift_symbol[j - 1] > symbol)
- {
- shift_symbol[j] = shift_symbol[j - 1];
- j--;
- }
- shift_symbol[j] = symbol;
+ symbol_number sym = shift_symbol[i];
+ int j;
+ for (j = i; 0 < j && sym < shift_symbol [j - 1]; j--)
+ shift_symbol[j] = shift_symbol[j - 1];
+ shift_symbol[j] = sym;
}
for (i = 0; i < nshifts; i++)
{
- symbol = shift_symbol[i];
- shiftset[i] = get_state (symbol,
- kernel_size[symbol], kernel_base[symbol]);
+ symbol_number sym = shift_symbol[i];
+ shiftset[i] = get_state (sym, kernel_size[sym], kernel_base[sym]);
}
}
@@ -279,7 +271,7 @@ append_states (state_t *state)
`----------------------------------------------------------------*/
static void
-save_reductions (state_t *state)
+save_reductions (state *s)
{
int count = 0;
int i;
@@ -293,7 +285,7 @@ save_reductions (state_t *state)
}
/* Make a reductions structure and copy the data into it. */
- state_reductions_set (state, count, redset);
+ state_reductions_set (s, count, redset);
}
@@ -304,23 +296,23 @@ save_reductions (state_t *state)
static void
set_states (void)
{
- states = XCALLOC (state_t *, nstates);
+ states = XCALLOC (state *, nstates);
while (first_state)
{
- state_list_t *this = first_state;
+ state_list *this = first_state;
/* Pessimization, but simplification of the code: make sure all
the states have valid transitions and reductions members,
even if reduced to 0. It is too soon for errs, which are
computed later, but set_conflicts. */
- state_t *state = this->state;
- if (!state->transitions)
- state_transitions_set (state, 0, 0);
- if (!state->reductions)
- state_reductions_set (state, 0, 0);
+ state *s = this->state;
+ if (!s->transitions)
+ state_transitions_set (s, 0, 0);
+ if (!s->reductions)
+ state_reductions_set (s, 0, 0);
- states[state->number] = state;
+ states[s->number] = s;
first_state = this->next;
free (this);
@@ -338,7 +330,7 @@ set_states (void)
void
generate_states (void)
{
- state_list_t *list = NULL;
+ state_list *list = NULL;
allocate_storage ();
new_closure (nritems);
@@ -352,28 +344,28 @@ generate_states (void)
while (list)
{
- state_t *state = list->state;
+ state *s = list->state;
if (trace_flag & trace_automaton)
fprintf (stderr, "Processing state %d (reached by %s)\n",
- state->number,
- symbols[state->accessing_symbol]->tag);
+ s->number,
+ symbols[s->accessing_symbol]->tag);
/* Set up ruleset and itemset for the transitions out of this
state. ruleset gets a 1 bit for each rule that could reduce
now. itemset gets a vector of all the items that could be
accepted next. */
- closure (state->items, state->nitems);
+ closure (s->items, s->nitems);
/* Record the reductions allowed out of this state. */
- save_reductions (state);
+ save_reductions (s);
/* Find the itemsets of the states that shifts can reach. */
- new_itemsets (state);
+ new_itemsets (s);
/* Find or create the core structures for those states. */
- append_states (state);
+ append_states (s);
/* Create the shifts structures for the shifts to those states,
now that the state numbers transitioning to are known. */
- state_transitions_set (state, nshifts, shiftset);
+ state_transitions_set (s, nshifts, shiftset);
- /* States are queued when they are created; process them all.
+ /* states are queued when they are created; process them all.
*/
list = list->next;
}
Index: src/Makefile.am
===================================================================
RCS file: /cvsroot/bison/bison/src/Makefile.am,v
retrieving revision 1.57
diff -p -u -r1.57 Makefile.am
--- src/Makefile.am 12 Nov 2002 17:51:38 -0000 1.57
+++ src/Makefile.am 11 Dec 2002 05:09:22 -0000
@@ -55,11 +55,11 @@ bison_SOURCES = \
scan-gram.l \
scan-skel.l \
state.c state.h \
- struniq.c struniq.h \
symlist.c symlist.h \
symtab.c symtab.h \
system.h \
tables.h tables.c \
+ uniqstr.c uniqstr.h \
vcg.c vcg.h \
vcg_defaults.h
Index: src/assoc.c
===================================================================
RCS file: /cvsroot/bison/bison/src/assoc.c,v
retrieving revision 1.3
diff -p -u -r1.3 assoc.c
--- src/assoc.c 4 Sep 2002 10:18:15 -0000 1.3
+++ src/assoc.c 11 Dec 2002 05:09:22 -0000
@@ -19,13 +19,14 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
+
#include "assoc.h"
const char *
-assoc_to_string (assoc_t assoc)
+assoc_to_string (assoc a)
{
- switch (assoc)
+ switch (a)
{
case undef_assoc:
return "undefined associativity";
Index: src/assoc.h
===================================================================
RCS file: /cvsroot/bison/bison/src/assoc.h,v
retrieving revision 1.2
diff -p -u -r1.2 assoc.h
--- src/assoc.h 21 Oct 2002 05:30:49 -0000 1.2
+++ src/assoc.h 11 Dec 2002 05:09:22 -0000
@@ -28,8 +28,8 @@ typedef enum
right_assoc,
left_assoc,
non_assoc
-} assoc_t;
+} assoc;
-const char *assoc_to_string (assoc_t assoc);
+char const *assoc_to_string (assoc);
#endif /* !ASSOC_H_ */
Index: src/closure.c
===================================================================
RCS file: /cvsroot/bison/bison/src/closure.c,v
retrieving revision 1.64
diff -p -u -r1.64 closure.c
--- src/closure.c 4 Sep 2002 10:18:15 -0000 1.64
+++ src/closure.c 11 Dec 2002 05:09:22 -0000
@@ -19,19 +19,21 @@
02111-1307, USA. */
#include "system.h"
-#include "quotearg.h"
-#include "bitset.h"
-#include "bitsetv.h"
-#include "bitsetv-print.h"
+
+#include <bitset.h>
+#include <bitsetv-print.h>
+#include <bitsetv.h>
+#include <quotearg.h>
+
+#include "closure.h"
+#include "derives.h"
#include "getargs.h"
-#include "symtab.h"
#include "gram.h"
#include "reader.h"
-#include "closure.h"
-#include "derives.h"
+#include "symtab.h"
/* NITEMSET is the size of the array ITEMSET. */
-item_number_t *itemset;
+item_number *itemset;
int nritemset;
static bitset ruleset;
@@ -50,13 +52,13 @@ static bitsetv firsts = NULL;
`-----------------*/
static void
-print_closure (const char *title, item_number_t *array, size_t size)
+print_closure (char const *title, item_number *array, size_t size)
{
size_t i;
fprintf (stderr, "Closure: %s\n", title);
for (i = 0; i < size; ++i)
{
- item_number_t *rp;
+ item_number *rp;
fprintf (stderr, " %2d: .", array[i]);
for (rp = &ritem[array[i]]; *rp >= 0; ++rp)
fprintf (stderr, " %s", symbols[*rp]->tag);
@@ -69,7 +71,7 @@ print_closure (const char *title, item_n
static void
print_firsts (void)
{
- symbol_number_t i, j;
+ symbol_number i, j;
fprintf (stderr, "FIRSTS\n");
for (i = ntokens; i < nsyms; i++)
@@ -90,7 +92,7 @@ static void
print_fderives (void)
{
int i;
- rule_number_t r;
+ rule_number r;
fprintf (stderr, "FDERIVES\n");
for (i = ntokens; i < nsyms; i++)
@@ -120,16 +122,16 @@ print_fderives (void)
static void
set_firsts (void)
{
- symbol_number_t i, j;
+ symbol_number i, j;
firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
for (i = ntokens; i < nsyms; i++)
for (j = 0; derives[i][j]; ++j)
{
- int symbol = derives[i][j]->rhs[0];
- if (ISVAR (symbol))
- bitset_set (FIRSTS (i), symbol - ntokens);
+ item_number sym = derives[i][j]->rhs[0];
+ if (ISVAR (sym))
+ bitset_set (FIRSTS (i), sym - ntokens);
}
if (trace_flag & trace_sets)
@@ -155,8 +157,8 @@ set_firsts (void)
static void
set_fderives (void)
{
- symbol_number_t i, j;
- rule_number_t k;
+ symbol_number i, j;
+ rule_number k;
fderives = bitsetv_create (nvars, nrules, BITSET_FIXED);
@@ -179,7 +181,7 @@ set_fderives (void)
void
new_closure (int n)
{
- itemset = XCALLOC (item_number_t, n);
+ itemset = XCALLOC (item_number, n);
ruleset = bitset_create (nrules, BITSET_FIXED);
@@ -189,13 +191,13 @@ new_closure (int n)
void
-closure (item_number_t *core, int n)
+closure (item_number *core, int n)
{
/* Index over CORE. */
int c;
/* A bit index over RULESET. */
- rule_number_t ruleno;
+ rule_number ruleno;
bitset_iterator iter;
@@ -212,7 +214,7 @@ closure (item_number_t *core, int n)
c = 0;
BITSET_FOR_EACH (iter, ruleset, ruleno, 0)
{
- item_number_t itemno = rules[ruleno].rhs - ritem;
+ item_number itemno = rules[ruleno].rhs - ritem;
while (c < n && core[c] < itemno)
{
itemset[nritemset] = core[c];
Index: src/closure.h
===================================================================
RCS file: /cvsroot/bison/bison/src/closure.h,v
retrieving revision 1.10
diff -p -u -r1.10 closure.h
--- src/closure.h 21 Oct 2002 05:30:49 -0000 1.10
+++ src/closure.h 11 Dec 2002 05:09:22 -0000
@@ -21,6 +21,8 @@
#ifndef CLOSURE_H_
# define CLOSURE_H_
+# include "gram.h"
+
/* Allocates the itemset and ruleset vectors, and precomputes useful
data so that closure can be called. n is the number of elements to
allocate for itemset. */
@@ -42,14 +44,14 @@ void new_closure (int n);
significant). CLOSURE places there the indices of all items which
represent units of input that could arrive next. */
-void closure (item_number_t *items, int n);
+void closure (item_number *items, int n);
/* Frees ITEMSET, RULESET and internal data. */
void free_closure (void);
-extern item_number_t *itemset;
+extern item_number *itemset;
extern int nritemset;
#endif /* !CLOSURE_H_ */
Index: src/complain.c
===================================================================
RCS file: /cvsroot/bison/bison/src/complain.c,v
retrieving revision 1.18
diff -p -u -r1.18 complain.c
--- src/complain.c 7 Dec 2002 05:53:51 -0000 1.18
+++ src/complain.c 11 Dec 2002 05:09:22 -0000
@@ -26,11 +26,6 @@
# define vfprintf(stream, message, args) _doprnt (message, args, stream)
#endif
-#if STDC_HEADERS || _LIBC
-# include <stdlib.h>
-# include <string.h>
-#endif
-
#include "complain.h"
#include "files.h"
@@ -38,36 +33,18 @@
# define _(String) String
#endif
-#ifdef _LIBC
-/* In the GNU C library, there is a predefined variable for this. */
-
-# define program_name program_invocation_name
-# include <errno.h>
-
-/* In GNU libc we want do not want to use the common name `error' directly.
- Instead make it a weak alias. */
-# define error __error
-# define error_at_line __error_at_line
-
-# ifdef USE_IN_LIBIO
-# include <libio/iolibio.h>
-# define fflush(s) _IO_fflush (s)
-# endif
-
-#else /* not _LIBC */
-
/* The calling program should define program_name and set it to the
name of the executing program. */
extern char *program_name;
-# if HAVE_STRERROR
-# ifndef HAVE_DECL_STRERROR
+#if HAVE_STRERROR
+# ifndef HAVE_DECL_STRERROR
"this configure-time declaration test was not run"
-# endif
-# if !HAVE_DECL_STRERROR && !defined strerror
+# endif
+# if !HAVE_DECL_STRERROR && !defined strerror
char *strerror (int);
-# endif
-# else
+# endif
+#else
static char *
private_strerror (int errnum)
{
@@ -78,9 +55,8 @@ private_strerror (int errnum)
return _(sys_errlist[errnum]);
return _("Unknown system error");
}
-# define strerror private_strerror
-# endif /* HAVE_STRERROR */
-#endif /* not _LIBC */
+# define strerror private_strerror
+#endif /* HAVE_STRERROR */
/* This variable is set each time `warn' is called. */
bool warning_issued;
@@ -94,12 +70,12 @@ bool complaint_issued;
`--------------------------------*/
void
-warn_at (location_t location, const char *message, ...)
+warn_at (location loc, const char *message, ...)
{
va_list args;
fflush (stdout);
- location_print (stderr, location);
+ location_print (stderr, loc);
fputs (": ", stderr);
fputs (_("warning: "), stderr);
@@ -134,12 +110,12 @@ warn (const char *message, ...)
`-----------------------------------------------------------*/
void
-complain_at (location_t location, const char *message, ...)
+complain_at (location loc, const char *message, ...)
{
va_list args;
fflush (stdout);
- location_print (stderr, location);
+ location_print (stderr, loc);
fputs (": ", stderr);
va_start (args, message);
@@ -173,12 +149,12 @@ complain (const char *message, ...)
`-------------------------------------------------*/
void
-fatal_at (location_t location, const char *message, ...)
+fatal_at (location loc, const char *message, ...)
{
va_list args;
fflush (stdout);
- location_print (stderr, location);
+ location_print (stderr, loc);
fputs (": ", stderr);
fputs (_("fatal error: "), stderr);
Index: src/complain.h
===================================================================
RCS file: /cvsroot/bison/bison/src/complain.h,v
retrieving revision 1.13
diff -p -u -r1.13 complain.h
--- src/complain.h 7 Dec 2002 05:54:29 -0000 1.13
+++ src/complain.h 11 Dec 2002 05:09:22 -0000
@@ -25,28 +25,28 @@
extern "C" {
# endif
-/* Informative messages, but we proceed. */
+/* Informative messages, but we proceed. */
-void warn (const char *format, ...)
+void warn (char const *format, ...)
__attribute__ ((__format__ (__printf__, 1, 2)));
-void warn_at (location_t location, const char *format, ...)
+void warn_at (location loc, char const *format, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
-/* Something bad happen, but let's continue and die later. */
+/* Something bad happen, but let's continue and die later. */
-void complain (const char *format, ...)
+void complain (char const *format, ...)
__attribute__ ((__format__ (__printf__, 1, 2)));
-void complain_at (location_t location, const char *format, ...)
+void complain_at (location loc, char const *format, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
-/* Something bad happen and we die now. */
+/* Something bad happen and we die now. */
-void fatal (const char *format, ...)
+void fatal (char const *format, ...)
__attribute__ ((__noreturn__, __format__ (__printf__, 1, 2)));
-void fatal_at (location_t location, const char *format, ...)
+void fatal_at (location loc, char const *format, ...)
__attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
/* This variable is set each time `warn' is called. */
Index: src/conflicts.c
===================================================================
RCS file: /cvsroot/bison/bison/src/conflicts.c,v
retrieving revision 1.97
diff -p -u -r1.97 conflicts.c
--- src/conflicts.c 21 Nov 2002 05:16:36 -0000 1.97
+++ src/conflicts.c 11 Dec 2002 05:09:22 -0000
@@ -20,17 +20,19 @@
02111-1307, USA. */
#include "system.h"
-#include "bitset.h"
+
+#include <bitset.h>
+
+#include "LR0.h"
#include "complain.h"
-#include "getargs.h"
-#include "symtab.h"
+#include "conflicts.h"
#include "files.h"
+#include "getargs.h"
#include "gram.h"
-#include "state.h"
#include "lalr.h"
-#include "conflicts.h"
#include "reader.h"
-#include "LR0.h"
+#include "state.h"
+#include "symtab.h"
/* -1 stands for not specified. */
int expected_conflicts = -1;
@@ -42,7 +44,7 @@ static bitset lookaheadset;
-enum conflict_resolution_e
+enum conflict_resolution
{
shift_resolution,
reduce_resolution,
@@ -58,8 +60,8 @@ enum conflict_resolution_e
`----------------------------------------------------------------*/
static inline void
-log_resolution (rule_t *rule, symbol_number_t token,
- enum conflict_resolution_e resolution)
+log_resolution (rule *r, symbol_number token,
+ enum conflict_resolution resolution)
{
if (report_flag & report_solved_conflicts)
{
@@ -71,7 +73,7 @@ log_resolution (rule_t *rule, symbol_num
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as shift"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
case reduce_resolution:
@@ -79,14 +81,14 @@ log_resolution (rule_t *rule, symbol_num
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as reduce"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
case nonassoc_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
_("\
Conflict between rule %d and token %s resolved as an error"),
- rule->number,
+ r->number,
symbols[token]->tag);
break;
}
@@ -97,7 +99,7 @@ log_resolution (rule_t *rule, symbol_num
case shift_resolution:
obstack_fgrow2 (&solved_conflicts_obstack,
" (%s < %s)",
- rule->prec->tag,
+ r->prec->tag,
symbols[token]->tag);
break;
@@ -105,7 +107,7 @@ log_resolution (rule_t *rule, symbol_num
obstack_fgrow2 (&solved_conflicts_obstack,
" (%s < %s)",
symbols[token]->tag,
- rule->prec->tag);
+ r->prec->tag);
break;
case left_resolution:
@@ -137,16 +139,16 @@ log_resolution (rule_t *rule, symbol_num
`------------------------------------------------------------------*/
static void
-flush_shift (state_t *state, int token)
+flush_shift (state *s, int token)
{
- transitions_t *transitions = state->transitions;
+ transitions *trans = s->transitions;
int i;
bitset_reset (lookaheadset, token);
- for (i = 0; i < transitions->num; i++)
- if (!TRANSITION_IS_DISABLED (transitions, i)
- && TRANSITION_SYMBOL (transitions, i) == token)
- TRANSITION_DISABLE (transitions, i);
+ for (i = 0; i < trans->num; i++)
+ if (!TRANSITION_IS_DISABLED (trans, i)
+ && TRANSITION_SYMBOL (trans, i) == token)
+ TRANSITION_DISABLE (trans, i);
}
@@ -171,17 +173,16 @@ flush_reduce (bitset lookaheads, int tok
| |
| LOOKAHEAD is the number of the lookahead bitset to consider. |
| |
-| ERRS can be used to store discovered explicit errors. |
+| ERRORS can be used to store discovered explicit errors. |
`------------------------------------------------------------------*/
static void
-resolve_sr_conflict (state_t *state, int ruleno,
- symbol_t **errs)
+resolve_sr_conflict (state *s, int ruleno, symbol **errors)
{
- symbol_number_t i;
- reductions_t *reds = state->reductions;
+ symbol_number i;
+ reductions *reds = s->reductions;
/* Find the rule to reduce by to get precedence of reduction. */
- rule_t *redrule = reds->rules[ruleno];
+ rule *redrule = reds->rules[ruleno];
int redprec = redrule->prec->prec;
bitset lookaheads = reds->lookaheads[ruleno];
int nerrs = 0;
@@ -197,7 +198,7 @@ resolve_sr_conflict (state_t *state, int
if (symbols[i]->prec < redprec)
{
log_resolution (redrule, i, reduce_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
}
else if (symbols[i]->prec > redprec)
{
@@ -219,15 +220,15 @@ resolve_sr_conflict (state_t *state, int
case left_assoc:
log_resolution (redrule, i, left_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
break;
case non_assoc:
log_resolution (redrule, i, nonassoc_resolution);
- flush_shift (state, i);
+ flush_shift (s, i);
flush_reduce (lookaheads, i);
/* Record an explicit error for this token. */
- errs[nerrs++] = symbols[i];
+ errors[nerrs++] = symbols[i];
break;
case undef_assoc:
@@ -237,37 +238,37 @@ resolve_sr_conflict (state_t *state, int
/* Some tokens have been explicitly made errors. Allocate a
permanent errs structure for this state, to record them. */
- state_errs_set (state, nerrs, errs);
+ state_errs_set (s, nerrs, errors);
if (obstack_object_size (&solved_conflicts_obstack))
{
obstack_1grow (&solved_conflicts_obstack, '\0');
- state->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
+ s->solved_conflicts = obstack_finish (&solved_conflicts_obstack);
}
}
/*-------------------------------------------------------------------.
-| Solve the S/R conflicts of STATE using the |
+| Solve the S/R conflicts of state S using the |
| precedence/associativity, and flag it inconsistent if it still has |
-| conflicts. ERRS can be used as storage to compute the list of |
-| lookaheads on which this STATE raises a syntax error (%nonassoc). |
+| conflicts. ERRORS can be used as storage to compute the list of |
+| lookaheads on which S raises a syntax error (%nonassoc). |
`-------------------------------------------------------------------*/
static void
-set_conflicts (state_t *state, symbol_t **errs)
+set_conflicts (state *s, symbol **errors)
{
int i;
- transitions_t *transitions = state->transitions;
- reductions_t *reds = state->reductions;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
- if (state->consistent)
+ if (s->consistent)
return;
bitset_zero (lookaheadset);
- FOR_EACH_SHIFT (transitions, i)
- bitset_set (lookaheadset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (trans, i)
+ bitset_set (lookaheadset, TRANSITION_SYMBOL (trans, i));
/* Loop over all rules which require lookahead in this state. First
check for shift-reduce conflict, and try to resolve using
@@ -276,7 +277,7 @@ set_conflicts (state_t *state, symbol_t
if (reds->rules[i]->prec && reds->rules[i]->prec->prec
&& !bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
{
- resolve_sr_conflict (state, i, errs);
+ resolve_sr_conflict (s, i, errors);
break;
}
@@ -285,7 +286,7 @@ set_conflicts (state_t *state, symbol_t
for (i = 0; i < reds->num; ++i)
{
if (!bitset_disjoint_p (reds->lookaheads[i], lookaheadset))
- conflicts[state->number] = 1;
+ conflicts[s->number] = 1;
bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
}
@@ -300,9 +301,9 @@ set_conflicts (state_t *state, symbol_t
void
conflicts_solve (void)
{
- state_number_t i;
+ state_number i;
/* List of lookaheads on which we explicitly raise a syntax error. */
- symbol_t **errs = XMALLOC (symbol_t *, ntokens + 1);
+ symbol **errors = XMALLOC (symbol *, ntokens + 1);
conflicts = XCALLOC (char, nstates);
shiftset = bitset_create (ntokens, BITSET_FIXED);
@@ -311,7 +312,7 @@ conflicts_solve (void)
for (i = 0; i < nstates; i++)
{
- set_conflicts (states[i], errs);
+ set_conflicts (states[i], errors);
/* For uniformity of the code, make sure all the states have a valid
`errs' member. */
@@ -319,7 +320,7 @@ conflicts_solve (void)
states[i]->errs = errs_new (0, 0);
}
- free (errs);
+ free (errors);
}
@@ -328,21 +329,21 @@ conflicts_solve (void)
`---------------------------------------------*/
static int
-count_sr_conflicts (state_t *state)
+count_sr_conflicts (state *s)
{
int i;
int src_count = 0;
- transitions_t *transitions = state->transitions;
- reductions_t *reds = state->reductions;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
- if (!transitions)
+ if (!trans)
return 0;
bitset_zero (lookaheadset);
bitset_zero (shiftset);
- FOR_EACH_SHIFT (transitions, i)
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (trans, i)
+ bitset_set (shiftset, TRANSITION_SYMBOL (trans, i));
for (i = 0; i < reds->num; ++i)
bitset_or (lookaheadset, lookaheadset, reds->lookaheads[i]);
@@ -363,10 +364,10 @@ count_sr_conflicts (state_t *state)
+`----------------------------------------------------------------*/
static int
-count_rr_conflicts (state_t *state, int one_per_token)
+count_rr_conflicts (state *s, int one_per_token)
{
int i;
- reductions_t *reds = state->reductions;
+ reductions *reds = s->reductions;
int rrc_count = 0;
for (i = 0; i < ntokens; i++)
@@ -450,10 +451,10 @@ void
conflicts_output (FILE *out)
{
bool printed_sth = false;
- state_number_t i;
+ state_number i;
for (i = 0; i < nstates; i++)
{
- state_t *s = states[i];
+ state *s = states[i];
if (conflicts[i])
{
fprintf (out, _("State %d contains "), i);
@@ -477,7 +478,7 @@ conflicts_output (FILE *out)
int
conflicts_total_count (void)
{
- state_number_t i;
+ state_number i;
int count;
/* Conflicts by state. */
@@ -509,7 +510,7 @@ conflicts_print (void)
/* Conflicts by state. */
{
- state_number_t i;
+ state_number i;
for (i = 0; i < nstates; i++)
if (conflicts[i])
Index: src/derives.c
===================================================================
RCS file: /cvsroot/bison/bison/src/derives.c,v
retrieving revision 1.37
diff -p -u -r1.37 derives.c
--- src/derives.c 1 Aug 2002 18:13:29 -0000 1.37
+++ src/derives.c 11 Dec 2002 05:09:22 -0000
@@ -20,20 +20,22 @@
#include "system.h"
+
#include "getargs.h"
-#include "symtab.h"
-#include "reader.h"
-#include "gram.h"
+
#include "derives.h"
+#include "gram.h"
+#include "reader.h"
+#include "symtab.h"
/* Linked list of rule numbers. */
-typedef struct rule_list_s
+typedef struct rule_list
{
- struct rule_list_s *next;
- rule_t *value;
-} rule_list_t;
+ struct rule_list *next;
+ rule *value;
+} rule_list;
-rule_t ***derives = NULL;
+rule ***derives = NULL;
static void
print_derives (void)
@@ -44,7 +46,7 @@ print_derives (void)
for (i = ntokens; i < nsyms; i++)
{
- rule_t **rp;
+ rule **rp;
fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
for (rp = derives[i]; *rp; ++rp)
{
@@ -60,23 +62,23 @@ print_derives (void)
void
derives_compute (void)
{
- symbol_number_t i;
+ symbol_number i;
int r;
- rule_t **q;
+ rule **q;
/* DSET[NTERM] -- A linked list of the numbers of the rules whose
LHS is NTERM. */
- rule_list_t **dset = XCALLOC (rule_list_t *, nvars) - ntokens;
+ rule_list **dset = XCALLOC (rule_list *, nvars) - ntokens;
/* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
Instead of performing NRULES allocations for each, have an array
indexed by rule numbers. */
- rule_list_t *delts = XCALLOC (rule_list_t, nrules);
+ rule_list *delts = XCALLOC (rule_list, nrules);
for (r = nrules - 1; r >= 0; --r)
{
- symbol_number_t lhs = rules[r].lhs->number;
- rule_list_t *p = &delts[r];
+ symbol_number lhs = rules[r].lhs->number;
+ rule_list *p = &delts[r];
/* A new LHS is found. */
p->next = dset[lhs];
p->value = &rules[r];
@@ -86,12 +88,12 @@ derives_compute (void)
/* DSET contains what we need under the form of a linked list. Make
it a single array. */
- derives = XCALLOC (rule_t **, nvars) - ntokens;
- q = XCALLOC (rule_t *, nvars + int_of_rule_number (nrules));
+ derives = XCALLOC (rule **, nvars) - ntokens;
+ q = XCALLOC (rule *, nvars + int_of_rule_number (nrules));
for (i = ntokens; i < nsyms; i++)
{
- rule_list_t *p = dset[i];
+ rule_list *p = dset[i];
derives[i] = q;
while (p)
{
Index: src/derives.h
===================================================================
RCS file: /cvsroot/bison/bison/src/derives.h,v
retrieving revision 1.7
diff -p -u -r1.7 derives.h
--- src/derives.h 21 Oct 2002 05:30:49 -0000 1.7
+++ src/derives.h 11 Dec 2002 05:09:22 -0000
@@ -21,9 +21,11 @@
#ifndef DERIVES_H_
# define DERIVES_H_
+# include "gram.h"
+
/* DERIVES[SYMBOL - NTOKENS] points to a vector of the rules that
SYMBOL derives, terminated with NULL. */
-extern rule_t ***derives;
+extern rule ***derives;
/* Compute DERIVES. */
Index: src/files.c
===================================================================
RCS file: /cvsroot/bison/bison/src/files.c,v
retrieving revision 1.81
diff -p -u -r1.81 files.c
--- src/files.c 12 Nov 2002 08:05:59 -0000 1.81
+++ src/files.c 11 Dec 2002 05:09:22 -0000
@@ -21,11 +21,14 @@
#include "system.h"
-#include "getargs.h"
+
+#include <error.h>
+#include <get-errno.h>
+
+#include "complain.h"
#include "files.h"
+#include "getargs.h"
#include "gram.h"
-#include "error.h"
-#include "complain.h"
/* From basename.c. Almost a lie, as it returns a char *. */
const char *base_name (char const *name);
@@ -50,8 +53,8 @@ char *spec_graph_file = NULL; /* for -
char *spec_defines_file = NULL; /* for --defines. */
char *parser_file_name = NULL;
-struniq_t grammar_file = NULL;
-struniq_t current_file = NULL;
+uniqstr grammar_file = NULL;
+uniqstr current_file = NULL;
static char *full_base_name = NULL;
@@ -63,36 +66,19 @@ const char *src_extension = NULL;
/* Header file extension (if option ``-d'' is specified). */
const char *header_extension = NULL;
-
-/*--------------------------.
-| Is SUFFIX ending STRING? |
-`--------------------------*/
-
-int
-strsuffix (const char *string, const char *suffix)
-{
- size_t string_len = strlen (string);
- size_t suffix_len = strlen (suffix);
- if (suffix_len <= string_len)
- return !strcmp (string + string_len - suffix_len, suffix);
- else
- return 0;
-}
-
-
/*-----------------------------------------------------------------.
| Return a newly allocated string composed of the concatenation of |
-| STRING1, and STRING2. |
+| STR1, and STR2. |
`-----------------------------------------------------------------*/
-char*
-stringappend (const char *string1, const char *string2)
+static char *
+concat2 (char const *str1, char const *str2)
{
- size_t len = strlen (string1) + strlen (string2);
+ size_t len = strlen (str1) + strlen (str2);
char *res = XMALLOC (char, len + 1);
char *cp;
- cp = stpcpy (res, string1);
- cp = stpcpy (cp, string2);
+ cp = stpcpy (res, str1);
+ cp = stpcpy (cp, str2);
return res;
}
@@ -108,7 +94,7 @@ xfopen (const char *name, const char *mo
ptr = fopen (name, mode);
if (!ptr)
- error (EXIT_FAILURE, errno, _("cannot open file `%s'"), name);
+ error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);
return ptr;
}
@@ -127,7 +113,7 @@ xfclose (FILE *ptr)
error (EXIT_FAILURE, 0, _("I/O error"));
if (fclose (ptr) != 0)
- error (EXIT_FAILURE, errno, _("cannot close file"));
+ error (EXIT_FAILURE, get_errno (), _("cannot close file"));
}
@@ -288,8 +274,8 @@ compute_base_names (void)
full_base_name = XMALLOC (char,
strlen (short_base_name)
- + strlen (EXT_TAB) + 1);
- stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
+ + strlen (TAB_EXT) + 1);
+ stpcpy (stpcpy (full_base_name, short_base_name), TAB_EXT);
/* Computes the extensions from the grammar file name. */
filename_split (grammar_file, &base, &tab, &ext);
@@ -314,15 +300,15 @@ compute_output_file_names (void)
header_extension = ".h";
parser_file_name =
- spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
+ spec_outfile ? spec_outfile : concat2 (full_base_name, src_extension);
/* It the defines filename if not given, we create it. */
if (!spec_defines_file)
- spec_defines_file = stringappend (full_base_name, header_extension);
+ spec_defines_file = concat2 (full_base_name, header_extension);
/* It the graph filename if not given, we create it. */
if (!spec_graph_file)
- spec_graph_file = stringappend (short_base_name, ".vcg");
+ spec_graph_file = concat2 (short_base_name, ".vcg");
- spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
+ spec_verbose_file = concat2 (short_base_name, OUTPUT_EXT);
}
Index: src/files.h
===================================================================
RCS file: /cvsroot/bison/bison/src/files.h,v
retrieving revision 1.37
diff -p -u -r1.37 files.h
--- src/files.h 12 Nov 2002 08:05:59 -0000 1.37
+++ src/files.h 11 Dec 2002 05:09:22 -0000
@@ -21,7 +21,7 @@
#ifndef FILES_H_
# define FILES_H_
-# include "struniq.h"
+# include "uniqstr.h"
/* File name specified with -o for the output file, or 0 if no -o. */
extern char *spec_outfile;
@@ -55,22 +55,15 @@ extern struct obstack post_prologue_obst
/* The file name as given on the command line.
Not named "input_file" because Flex uses this name for an argument,
and therefore GCC warns about a name clash. */
-extern struniq_t grammar_file;
+extern uniqstr grammar_file;
/* The current file name. Might change with %include, or with #line. */
-extern struniq_t current_file;
+extern uniqstr current_file;
void compute_output_file_names (void);
FILE *xfopen (const char *name, const char *mode);
void xfclose (FILE *ptr);
-
-/* Is SUFFIX ending STRING? */
-int strsuffix (const char* string, const char* suffix);
-
-/* Return a newly allocated string composed of the concatenation of
- STRING1, and STRING2. */
-char* stringappend (const char* string1, const char* string2);
/* Prefix used to generate output file names. */
extern char *short_base_name;
Index: src/getargs.c
===================================================================
RCS file: /cvsroot/bison/bison/src/getargs.c,v
retrieving revision 1.50
diff -p -u -r1.50 getargs.c
--- src/getargs.c 21 Nov 2002 05:17:21 -0000 1.50
+++ src/getargs.c 11 Dec 2002 05:09:22 -0000
@@ -20,13 +20,15 @@
02111-1307, USA. */
#include "system.h"
-#include "getopt.h"
-#include "argmatch.h"
-#include "error.h"
+
+#include <argmatch.h>
+#include <error.h>
+#include <getopt.h>
+
#include "complain.h"
-#include "struniq.h"
-#include "getargs.h"
#include "files.h"
+#include "getargs.h"
+#include "uniqstr.h"
int debug_flag = 0;
int defines_flag = 0;
@@ -410,5 +412,5 @@ getargs (int argc, char *argv[])
usage (EXIT_FAILURE);
}
- current_file = grammar_file = struniq_new (argv[optind]);
+ current_file = grammar_file = uniqstr_new (argv[optind]);
}
Index: src/getargs.h
===================================================================
RCS file: /cvsroot/bison/bison/src/getargs.h,v
retrieving revision 1.22
diff -p -u -r1.22 getargs.h
--- src/getargs.h 16 Nov 2002 12:31:36 -0000 1.22
+++ src/getargs.h 11 Dec 2002 05:09:22 -0000
@@ -1,5 +1,5 @@
/* Parse command line arguments for bison.
- Copyright 1984, 1986, 1989, 1992, 2000, 2001, 2002
+ Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
@@ -36,7 +36,7 @@ extern int graph_flag; /* for -g */
extern int yacc_flag; /* for -y */
/* --trace. */
-enum trace_e
+enum trace
{
trace_none = 0,
trace_scan = 1 << 0,
@@ -54,7 +54,7 @@ enum trace_e
extern int trace_flag;
/* --report. */
-enum report_e
+enum report
{
report_none = 0,
report_states = 1 << 0,
Index: src/gram.c
===================================================================
RCS file: /cvsroot/bison/bison/src/gram.c,v
retrieving revision 1.47
diff -p -u -r1.47 gram.c
--- src/gram.c 7 Dec 2002 05:55:28 -0000 1.47
+++ src/gram.c 11 Dec 2002 05:09:22 -0000
@@ -20,26 +20,28 @@
#include "system.h"
-#include "quotearg.h"
-#include "symtab.h"
+
+#include <quotearg.h>
+
#include "gram.h"
-#include "reduce.h"
#include "reader.h"
+#include "reduce.h"
+#include "symtab.h"
/* Comments for these variables are in gram.h. */
-item_number_t *ritem = NULL;
+item_number *ritem = NULL;
unsigned int nritems = 0;
-rule_t *rules = NULL;
-rule_number_t nrules = 0;
+rule *rules = NULL;
+rule_number nrules = 0;
-symbol_t **symbols = NULL;
+symbol **symbols = NULL;
int nsyms = 0;
int ntokens = 1;
int nvars = 0;
-symbol_number_t *token_translations = NULL;
+symbol_number *token_translations = NULL;
int max_user_token_number = 256;
@@ -52,7 +54,7 @@ int pure_parser = 0;
`--------------------------------------------------------------*/
bool
-rule_useful_p (rule_t *r)
+rule_useful_p (rule *r)
{
return r->number < nrules;
}
@@ -63,7 +65,7 @@ rule_useful_p (rule_t *r)
`-------------------------------------------------------------*/
bool
-rule_useless_p (rule_t *r)
+rule_useless_p (rule *r)
{
return r->number >= nrules;
}
@@ -75,7 +77,7 @@ rule_useless_p (rule_t *r)
`--------------------------------------------------------------------*/
bool
-rule_never_reduced_p (rule_t *r)
+rule_never_reduced_p (rule *r)
{
return !r->useful && r->number < nrules;
}
@@ -88,12 +90,12 @@ rule_never_reduced_p (rule_t *r)
`----------------------------------------------------------------*/
void
-rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
+rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out)
{
- fprintf (out, " %3d ", rule->number);
- if (previous_lhs != rule->lhs)
+ fprintf (out, " %3d ", r->number);
+ if (previous_lhs != r->lhs)
{
- fprintf (out, "%s:", rule->lhs->tag);
+ fprintf (out, "%s:", r->lhs->tag);
}
else
{
@@ -110,28 +112,28 @@ rule_lhs_print (rule_t *rule, symbol_t *
`--------------------------------------*/
int
-rule_rhs_length (rule_t *rule)
+rule_rhs_length (rule *r)
{
int res = 0;
- item_number_t *rhsp;
- for (rhsp = rule->rhs; *rhsp >= 0; ++rhsp)
+ item_number *rhsp;
+ for (rhsp = r->rhs; *rhsp >= 0; ++rhsp)
++res;
return res;
}
/*-------------------------------.
-| Print this RULE's RHS on OUT. |
+| Print this rule's RHS on OUT. |
`-------------------------------*/
void
-rule_rhs_print (rule_t *rule, FILE *out)
+rule_rhs_print (rule *r, FILE *out)
{
- if (*rule->rhs >= 0)
+ if (*r->rhs >= 0)
{
- item_number_t *r;
- for (r = rule->rhs; *r >= 0; r++)
- fprintf (out, " %s", symbols[*r]->tag);
+ item_number *rp;
+ for (rp = r->rhs; *rp >= 0; rp++)
+ fprintf (out, " %s", symbols[*rp]->tag);
fputc ('\n', out);
}
else
@@ -142,14 +144,14 @@ rule_rhs_print (rule_t *rule, FILE *out)
/*-------------------------.
-| Print this RULE on OUT. |
+| Print this rule on OUT. |
`-------------------------*/
void
-rule_print (rule_t *rule, FILE *out)
+rule_print (rule *r, FILE *out)
{
- fprintf (out, "%s:", rule->lhs->tag);
- rule_rhs_print (rule, out);
+ fprintf (out, "%s:", r->lhs->tag);
+ rule_rhs_print (r, out);
}
@@ -179,7 +181,7 @@ size_t
ritem_longest_rhs (void)
{
int max = 0;
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules; ++r)
{
@@ -198,11 +200,11 @@ ritem_longest_rhs (void)
void
grammar_rules_partial_print (FILE *out, const char *title,
- rule_filter_t filter)
+ rule_filter filter)
{
int r;
bool first = true;
- symbol_t *previous_lhs = NULL;
+ symbol *previous_lhs = NULL;
/* rule # : LHS -> RHS */
for (r = 0; r < nrules + nuseless_productions; r++)
@@ -249,7 +251,7 @@ grammar_dump (FILE *out, const char *tit
fprintf (out, "Variables\n---------\n\n");
{
- symbol_number_t i;
+ symbol_number i;
fprintf (out, "Value Sprec Sassoc Tag\n");
for (i = ntokens; i < nsyms; i++)
@@ -262,27 +264,27 @@ grammar_dump (FILE *out, const char *tit
fprintf (out, "Rules\n-----\n\n");
{
- rule_number_t i;
+ rule_number i;
fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem
range) [Num]\n");
for (i = 0; i < nrules + nuseless_productions; i++)
{
- rule_t *rule = &rules[i];
- item_number_t *r = NULL;
- unsigned int rhs_itemno = rule->rhs - ritem;
+ rule *rule_i = &rules[i];
+ item_number *r = NULL;
+ unsigned int rhs_itemno = rule_i->rhs - ritem;
unsigned int rhs_count = 0;
/* Find the last RHS index in ritems. */
- for (r = rule->rhs; *r >= 0; ++r)
+ for (r = rule_i->rhs; *r >= 0; ++r)
++rhs_count;
fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u) %2d ->",
i,
- rule->prec ? rule->prec->prec : 0,
- rule->prec ? rule->prec->assoc : 0,
- rule->useful,
+ rule_i->prec ? rule_i->prec->prec : 0,
+ rule_i->prec ? rule_i->prec->assoc : 0,
+ rule_i->useful,
rhs_itemno,
rhs_itemno + rhs_count - 1,
- rule->lhs->number);
+ rule_i->lhs->number);
/* Dumped the RHS. */
- for (r = rule->rhs; *r >= 0; r++)
+ for (r = rule_i->rhs; *r >= 0; r++)
fprintf (out, " %3d", *r);
fprintf (out, " [%d]\n", item_number_as_rule_number (*r));
}
@@ -291,7 +293,7 @@ grammar_dump (FILE *out, const char *tit
fprintf (out, "Rules interpreted\n-----------------\n\n");
{
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules + nuseless_productions; r++)
{
fprintf (out, "%-5d ", r);
@@ -312,7 +314,7 @@ grammar_dump (FILE *out, const char *tit
void
grammar_rules_never_reduced_report (const char *message)
{
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules ; ++r)
if (!rules[r].useful)
{
Index: src/gram.h
===================================================================
RCS file: /cvsroot/bison/bison/src/gram.h,v
retrieving revision 1.50
diff -p -u -r1.50 gram.h
--- src/gram.h 22 Oct 2002 04:41:59 -0000 1.50
+++ src/gram.h 11 Dec 2002 05:09:22 -0000
@@ -52,7 +52,7 @@
The rules themselves are described by several arrays: amongst which
RITEM, and RULES.
- RULES is an array of struct rule_s, which members are:
+ RULES is an array of rules, whose members are:
RULES[R].lhs -- the symbol of the left hand side of rule R.
@@ -113,105 +113,102 @@ extern int nsyms;
extern int ntokens;
extern int nvars;
-typedef int item_number_t;
-# define ITEM_NUMBER_MAX ((item_number_t) INT_MAX)
-# define ITEM_NUMBER_MIN ((item_number_t) INT_MIN)
-extern item_number_t *ritem;
+typedef int item_number;
+extern item_number *ritem;
extern unsigned int nritems;
-/* There is weird relationship between OT1H item_number_t and OTOH
- symbol_number_t and rule_number_t: we store the latter in
- item_number_t. symbol_number_t are stored as are, while
- the negation of (rule_number_t + 1) are stored.
+/* There is weird relationship between OT1H item_number and OTOH
+ symbol_number and rule_number: we store the latter in
+ item_number. symbol_number values are stored as-is, while
+ the negation of (rule_number + 1) is stored.
- Therefore, an symbol_number_t must be a valid item_number_t, and we
+ Therefore, a symbol_number must be a valid item_number, and we
sometimes have to perform the converse transformation. */
-# define symbol_number_as_item_number(Tok) ((item_number_t) (Tok))
-# define item_number_as_symbol_number(Ite) ((symbol_number_t) (Ite))
+# define symbol_number_as_item_number(Tok) ((item_number) (Tok))
+# define item_number_as_symbol_number(Ite) ((symbol_number) (Ite))
-extern symbol_number_t start_symbol;
+extern symbol_number start_symbol;
-/* Rules numbers. */
-typedef short rule_number_t;
-# define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
-extern rule_number_t nrules;
+/* Rule numbers. */
+typedef short rule_number;
+extern rule_number nrules;
# define int_of_rule_number(RNum) ((int) (RNum))
-# define rule_number_as_item_number(RNum) ((item_number_t) (- RNum - 1))
-# define item_number_as_rule_number(INum) ((rule_number_t) (- INum - 1))
+# define rule_number_as_item_number(RNum) ((item_number) (- RNum - 1))
+# define item_number_as_rule_number(INum) ((rule_number) (- INum - 1))
/*--------.
| Rules. |
`--------*/
-typedef struct rule_s
+typedef struct
{
/* The number of the rule in the source. It is usually the index in
RULES too, except if there are useless rules. */
- rule_number_t user_number;
+ rule_number user_number;
/* The index in RULES. Usually the rule number in the source,
except if some rules are useless. */
- rule_number_t number;
+ rule_number number;
- symbol_t *lhs;
- item_number_t *rhs;
+ symbol *lhs;
+ item_number *rhs;
/* This symbol provides both the associativity, and the precedence. */
- symbol_t *prec;
+ symbol *prec;
short dprec;
short merger;
/* This symbol was attached to the rule via %prec. */
- symbol_t *precsym;
+ symbol *precsym;
- location_t location;
+ location location;
bool useful;
const char *action;
- location_t action_location;
-} rule_t;
+ location action_location;
+} rule;
-extern struct rule_s *rules;
+extern rule *rules;
/* A function that selects a rule. */
-typedef bool (*rule_filter_t) (rule_t *r);
+typedef bool (*rule_filter) (rule *);
/* Return true IFF the rule has a `number' smaller than NRULES. */
-bool rule_useful_p (rule_t *r);
+bool rule_useful_p (rule *r);
/* Return true IFF the rule has a `number' higher than NRULES. */
-bool rule_useless_p (rule_t *r);
+bool rule_useless_p (rule *r);
/* Return true IFF the rule is not flagged as useful *and* is useful.
In other words, it was discarded because of conflicts. */
-bool rule_never_reduced_p (rule_t *r);
+bool rule_never_reduced_p (rule *r);
-/* Print this RULE's number and lhs on OUT. If a PREVIOUS_LHS was
+/* Print this rule's number and lhs on OUT. If a PREVIOUS_LHS was
already displayed (by a previous call for another rule), avoid
useless repetitions. */
-void rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out);
+void rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out);
/* Return the length of the RHS. */
-int rule_rhs_length (rule_t *rule);
+int rule_rhs_length (rule *r);
-/* Print this RULE's RHS on OUT. */
-void rule_rhs_print (rule_t *rule, FILE *out);
+/* Print this rule's RHS on OUT. */
+void rule_rhs_print (rule *r, FILE *out);
-/* Print this RULE on OUT. */
-void rule_print (rule_t *rule, FILE *out);
+/* Print this rule on OUT. */
+void rule_print (rule *r, FILE *out);
/* Table of the symbols, indexed by the symbol number. */
-extern symbol_t **symbols;
+extern symbol **symbols;
/* TOKEN_TRANSLATION -- a table indexed by a token number as returned
by the user's yylex routine, it yields the internal token number
used by the parser and throughout bison. */
-extern symbol_number_t *token_translations;
+extern symbol_number *token_translations;
extern int max_user_token_number;
@@ -236,7 +233,7 @@ size_t ritem_longest_rhs (void);
/* Print the grammar's rules numbers from BEGIN (inclusive) to END
(exclusive) on OUT under TITLE. */
void grammar_rules_partial_print (FILE *out, const char *title,
- rule_filter_t filter);
+ rule_filter filter);
/* Print the grammar's rules on OUT. */
void grammar_rules_print (FILE *out);
Index: src/lalr.c
===================================================================
RCS file: /cvsroot/bison/bison/src/lalr.c,v
retrieving revision 1.94
diff -p -u -r1.94 lalr.c
--- src/lalr.c 21 Nov 2002 05:18:08 -0000 1.94
+++ src/lalr.c 11 Dec 2002 05:09:22 -0000
@@ -25,31 +25,33 @@
tokens they accept. */
#include "system.h"
-#include "bitset.h"
-#include "bitsetv.h"
-#include "relation.h"
-#include "quotearg.h"
-#include "symtab.h"
-#include "gram.h"
-#include "reader.h"
+
+#include <bitset.h>
+#include <bitsetv.h>
+#include <quotearg.h>
+
#include "LR0.h"
#include "complain.h"
-#include "lalr.h"
-#include "nullable.h"
#include "derives.h"
#include "getargs.h"
+#include "gram.h"
+#include "lalr.h"
+#include "nullable.h"
+#include "reader.h"
+#include "relation.h"
+#include "symtab.h"
-goto_number_t *goto_map = NULL;
-static goto_number_t ngotos = 0;
-state_number_t *from_state = NULL;
-state_number_t *to_state = NULL;
+goto_number *goto_map = NULL;
+static goto_number ngotos = 0;
+state_number *from_state = NULL;
+state_number *to_state = NULL;
/* Linked list of goto numbers. */
-typedef struct goto_list_s
+typedef struct goto_list
{
- struct goto_list_s *next;
- goto_number_t value;
-} goto_list_t;
+ struct goto_list *next;
+ goto_number value;
+} goto_list;
/* LA is a LR by NTOKENS matrix of bits. LA[l, i] is 1 if the rule
@@ -65,8 +67,8 @@ size_t nLA;
comment is hardly needed. <grin>. */
static bitsetv F = NULL;
-static goto_number_t **includes;
-static goto_list_t **lookback;
+static goto_number **includes;
+static goto_list **lookback;
@@ -74,20 +76,20 @@ static goto_list_t **lookback;
static void
set_goto_map (void)
{
- state_number_t state;
- goto_number_t *temp_map;
+ state_number s;
+ goto_number *temp_map;
- goto_map = XCALLOC (goto_number_t, nvars + 1) - ntokens;
- temp_map = XCALLOC (goto_number_t, nvars + 1) - ntokens;
+ goto_map = XCALLOC (goto_number, nvars + 1) - ntokens;
+ temp_map = XCALLOC (goto_number, nvars + 1) - ntokens;
ngotos = 0;
- for (state = 0; state < nstates; ++state)
+ for (s = 0; s < nstates; ++s)
{
- transitions_t *sp = states[state]->transitions;
+ transitions *sp = states[s]->transitions;
int i;
for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
{
- if (ngotos >= GOTO_NUMBER_MAX)
+ if (ngotos >= GOTO_NUMBER_MAXIMUM)
abort ();
ngotos++;
goto_map[TRANSITION_SYMBOL (sp, i)]++;
@@ -110,17 +112,17 @@ set_goto_map (void)
temp_map[nsyms] = ngotos;
}
- from_state = XCALLOC (state_number_t, ngotos);
- to_state = XCALLOC (state_number_t, ngotos);
+ from_state = XCALLOC (state_number, ngotos);
+ to_state = XCALLOC (state_number, ngotos);
- for (state = 0; state < nstates; ++state)
+ for (s = 0; s < nstates; ++s)
{
- transitions_t *sp = states[state]->transitions;
+ transitions *sp = states[s]->transitions;
int i;
for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
{
int k = temp_map[TRANSITION_SYMBOL (sp, i)]++;
- from_state[k] = state;
+ from_state[k] = s;
to_state[k] = sp->states[i]->number;
}
}
@@ -135,15 +137,15 @@ set_goto_map (void)
`----------------------------------------------------------*/
static int
-map_goto (state_number_t state, symbol_number_t symbol)
+map_goto (state_number s0, symbol_number sym)
{
int high;
int low;
int middle;
- state_number_t s;
+ state_number s;
- low = goto_map[symbol];
- high = goto_map[symbol + 1] - 1;
+ low = goto_map[sym];
+ high = goto_map[sym + 1] - 1;
for (;;)
{
@@ -151,9 +153,9 @@ map_goto (state_number_t state, symbol_n
abort ();
middle = (low + high) / 2;
s = from_state[middle];
- if (s == state)
+ if (s == s0)
return middle;
- else if (s < state)
+ else if (s < s0)
low = middle + 1;
else
high = middle - 1;
@@ -164,8 +166,8 @@ map_goto (state_number_t state, symbol_n
static void
initialize_F (void)
{
- goto_number_t **reads = XCALLOC (goto_number_t *, ngotos);
- goto_number_t *edge = XCALLOC (goto_number_t, ngotos + 1);
+ goto_number **reads = XCALLOC (goto_number *, ngotos);
+ goto_number *edge = XCALLOC (goto_number, ngotos + 1);
int nedges = 0;
int i;
@@ -174,8 +176,8 @@ initialize_F (void)
for (i = 0; i < ngotos; i++)
{
- state_number_t stateno = to_state[i];
- transitions_t *sp = states[stateno]->transitions;
+ state_number stateno = to_state[i];
+ transitions *sp = states[stateno]->transitions;
int j;
FOR_EACH_SHIFT (sp, j)
@@ -183,14 +185,14 @@ initialize_F (void)
for (; j < sp->num; j++)
{
- symbol_number_t symbol = TRANSITION_SYMBOL (sp, j);
- if (nullable[symbol])
- edge[nedges++] = map_goto (stateno, symbol);
+ symbol_number sym = TRANSITION_SYMBOL (sp, j);
+ if (nullable[sym])
+ edge[nedges++] = map_goto (stateno, sym);
}
if (nedges)
{
- reads[i] = XCALLOC (goto_number_t, nedges + 1);
+ reads[i] = XCALLOC (goto_number, nedges + 1);
memcpy (reads[i], edge, nedges * sizeof (edge[0]));
reads[i][nedges] = -1;
nedges = 0;
@@ -208,13 +210,13 @@ initialize_F (void)
static void
-add_lookback_edge (state_t *state, rule_t *rule, int gotono)
+add_lookback_edge (state *s, rule *r, int gotono)
{
- int r = state_reduction_find (state, rule);
- goto_list_t *sp = XCALLOC (goto_list_t, 1);
- sp->next = lookback[(state->reductions->lookaheads - LA) + r];
+ int ri = state_reduction_find (s, r);
+ goto_list *sp = XCALLOC (goto_list, 1);
+ sp->next = lookback[(s->reductions->lookaheads - LA) + ri];
sp->value = gotono;
- lookback[(state->reductions->lookaheads - LA) + r] = sp;
+ lookback[(s->reductions->lookaheads - LA) + ri] = sp;
}
@@ -222,35 +224,35 @@ add_lookback_edge (state_t *state, rule_
static void
build_relations (void)
{
- goto_number_t *edge = XCALLOC (goto_number_t, ngotos + 1);
- state_number_t *states1 = XCALLOC (state_number_t, ritem_longest_rhs () + 1);
+ goto_number *edge = XCALLOC (goto_number, ngotos + 1);
+ state_number *states1 = XCALLOC (state_number, ritem_longest_rhs () + 1);
int i;
- includes = XCALLOC (goto_number_t *, ngotos);
+ includes = XCALLOC (goto_number *, ngotos);
for (i = 0; i < ngotos; i++)
{
int nedges = 0;
- symbol_number_t symbol1 = states[to_state[i]]->accessing_symbol;
- rule_t **rulep;
+ symbol_number symbol1 = states[to_state[i]]->accessing_symbol;
+ rule **rulep;
for (rulep = derives[symbol1]; *rulep; rulep++)
{
int done;
int length = 1;
- item_number_t *rp;
- state_t *state = states[from_state[i]];
- states1[0] = state->number;
+ item_number *rp;
+ state *s = states[from_state[i]];
+ states1[0] = s->number;
for (rp = (*rulep)->rhs; *rp >= 0; rp++)
{
- state = transitions_to (state->transitions,
- item_number_as_symbol_number (*rp));
- states1[length++] = state->number;
+ s = transitions_to (s->transitions,
+ item_number_as_symbol_number (*rp));
+ states1[length++] = s->number;
}
- if (!state->consistent)
- add_lookback_edge (state, *rulep, i);
+ if (!s->consistent)
+ add_lookback_edge (s, *rulep, i);
length--;
done = 0;
@@ -261,7 +263,7 @@ build_relations (void)
/* JF added rp>=ritem && I hope to god its right! */
if (rp >= ritem && ISVAR (*rp))
{
- /* Downcasting from item_number_t to symbol_number_t. */
+ /* Downcasting from item_number to symbol_number. */
edge[nedges++] = map_goto (states1[--length],
item_number_as_symbol_number
(*rp));
if (nullable[*rp])
@@ -273,7 +275,7 @@ build_relations (void)
if (nedges)
{
int j;
- includes[i] = XCALLOC (goto_number_t, nedges + 1);
+ includes[i] = XCALLOC (goto_number, nedges + 1);
for (j = 0; j < nedges; j++)
includes[i][j] = edge[j];
includes[i][nedges] = -1;
@@ -306,7 +308,7 @@ static void
compute_lookaheads (void)
{
size_t i;
- goto_list_t *sp;
+ goto_list *sp;
for (i = 0; i < nLA; i++)
for (sp = lookback[i]; sp; sp = sp->next)
@@ -314,25 +316,25 @@ compute_lookaheads (void)
/* Free LOOKBACK. */
for (i = 0; i < nLA; i++)
- LIST_FREE (goto_list_t, lookback[i]);
+ LIST_FREE (goto_list, lookback[i]);
XFREE (lookback);
bitsetv_free (F);
}
-/*---------------------------------------------------------------.
-| Count the number of lookaheads required for STATE (NLOOKAHEADS |
-| member). |
-`---------------------------------------------------------------*/
+/*-----------------------------------------------------------.
+| Count the number of lookaheads required for S (NLOOKAHEADS |
+| member). |
+`-----------------------------------------------------------*/
static int
-state_lookaheads_count (state_t *state)
+state_lookaheads_count (state *s)
{
int k;
int nlookaheads = 0;
- reductions_t *rp = state->reductions;
- transitions_t *sp = state->transitions;
+ reductions *rp = s->reductions;
+ transitions *sp = s->transitions;
/* We need a lookahead either to distinguish different
reductions (i.e., there are two or more), or to distinguish a
@@ -343,12 +345,12 @@ state_lookaheads_count (state_t *state)
!TRANSITION_IS_DISABLED (sp, 0) && TRANSITION_IS_SHIFT (sp, 0)))
nlookaheads += rp->num;
else
- state->consistent = 1;
+ s->consistent = 1;
for (k = 0; k < sp->num; k++)
if (!TRANSITION_IS_DISABLED (sp, k) && TRANSITION_IS_ERROR (sp, k))
{
- state->consistent = 0;
+ s->consistent = 0;
break;
}
@@ -363,7 +365,7 @@ state_lookaheads_count (state_t *state)
static void
initialize_LA (void)
{
- state_number_t i;
+ state_number i;
bitsetv pLA;
/* Compute the total number of reductions requiring a lookahead. */
@@ -375,7 +377,7 @@ initialize_LA (void)
nLA = 1;
pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
- lookback = XCALLOC (goto_list_t *, nLA);
+ lookback = XCALLOC (goto_list *, nLA);
/* Initialize the members LOOKAHEADS for each state which reductions
require lookaheads. */
@@ -398,12 +400,12 @@ initialize_LA (void)
static void
lookaheads_print (FILE *out)
{
- state_number_t i;
+ state_number i;
int j, k;
fprintf (out, "Lookaheads: BEGIN\n");
for (i = 0; i < nstates; ++i)
{
- reductions_t *reds = states[i]->reductions;
+ reductions *reds = states[i]->reductions;
bitset_iterator iter;
int nlookaheads = 0;
@@ -445,7 +447,7 @@ lalr (void)
void
lalr_free (void)
{
- state_number_t s;
+ state_number s;
for (s = 0; s < nstates; ++s)
states[s]->reductions->lookaheads = NULL;
bitsetv_free (LA);
Index: src/lalr.h
===================================================================
RCS file: /cvsroot/bison/bison/src/lalr.h,v
retrieving revision 1.25
diff -p -u -r1.25 lalr.h
--- src/lalr.h 21 Oct 2002 05:30:50 -0000 1.25
+++ src/lalr.h 11 Dec 2002 05:09:22 -0000
@@ -21,15 +21,15 @@
#ifndef LALR_H_
# define LALR_H_
-# include "bitset.h"
-# include "bitsetv.h"
-
-/* Import the definition of CORE, TRANSITIONS and REDUCTIONS. */
-# include "state.h"
+# include <bitset.h>
+# include <bitsetv.h>
/* Import the definition of RULE_T. */
# include "gram.h"
+/* Import the definition of CORE, TRANSITIONS and REDUCTIONS. */
+# include "state.h"
+
/* Compute how to make the finite state machine deterministic; find
which rules need lookahead in each state, and which lookahead
tokens they accept. */
@@ -54,12 +54,12 @@ void lalr_free (void);
together and GOTO_MAP[I - NTOKENS] is the index in FROM_STATE and
TO_STATE of the first of them. */
-typedef short goto_number_t;
-# define GOTO_NUMBER_MAX ((goto_number_t) SHRT_MAX)
+typedef short goto_number;
+# define GOTO_NUMBER_MAXIMUM SHRT_MAX
-extern goto_number_t *goto_map;
-extern state_number_t *from_state;
-extern state_number_t *to_state;
+extern goto_number *goto_map;
+extern state_number *from_state;
+extern state_number *to_state;
#endif /* !LALR_H_ */
Index: src/location.c
===================================================================
RCS file: /cvsroot/bison/bison/src/location.c,v
retrieving revision 1.3
diff -p -u -r1.3 location.c
--- src/location.c 7 Dec 2002 05:57:32 -0000 1.3
+++ src/location.c 11 Dec 2002 05:09:22 -0000
@@ -19,15 +19,17 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
-#include "location.h"
+
#include <quotearg.h>
-location_t const empty_location;
+#include "location.h"
+
+location const empty_location;
/* Output to OUT the location LOC.
Warning: it uses quotearg's slot 3. */
void
-location_print (FILE *out, location_t loc)
+location_print (FILE *out, location loc)
{
fprintf (out, "%s:%d.%d",
quotearg_n_style (3, escape_quoting_style, loc.start.file),
Index: src/location.h
===================================================================
RCS file: /cvsroot/bison/bison/src/location.h,v
retrieving revision 1.7
diff -p -u -r1.7 location.h
--- src/location.h 7 Dec 2002 05:58:38 -0000 1.7
+++ src/location.h 11 Dec 2002 05:09:22 -0000
@@ -54,12 +54,12 @@ typedef struct
/* Boundary just after the location ends. */
boundary end;
-} location_t;
+} location;
-#define YYLTYPE location_t
+#define YYLTYPE location
-extern location_t const empty_location;
+extern location const empty_location;
-void location_print (FILE *, location_t);
+void location_print (FILE *, location);
#endif /* ! defined LOCATION_H_ */
Index: src/main.c
===================================================================
RCS file: /cvsroot/bison/bison/src/main.c,v
retrieving revision 1.76
diff -p -u -r1.76 main.c
--- src/main.c 12 Nov 2002 08:05:59 -0000 1.76
+++ src/main.c 11 Dec 2002 05:09:23 -0000
@@ -21,26 +21,29 @@
#include "system.h"
-#include "bitset_stats.h"
-#include "bitset.h"
-#include "getargs.h"
-#include "struniq.h"
-#include "symtab.h"
-#include "gram.h"
-#include "files.h"
+
+#include <bitset_stats.h>
+#include <bitset.h>
+#include <timevar.h>
+
+#include "LR0.h"
#include "complain.h"
+#include "conflicts.h"
#include "derives.h"
-#include "tables.h"
-#include "output.h"
-#include "reader.h"
+#include "files.h"
+#include "getargs.h"
+#include "gram.h"
#include "lalr.h"
-#include "reduce.h"
+#include "muscle_tab.h"
#include "nullable.h"
+#include "output.h"
#include "print.h"
-#include "LR0.h"
-#include "conflicts.h"
#include "print_graph.h"
-#include "muscle_tab.h"
+#include "reader.h"
+#include "reduce.h"
+#include "symtab.h"
+#include "tables.h"
+#include "uniqstr.h"
/* The name this program was run with, for messages. */
char *program_name;
@@ -55,11 +58,11 @@ main (int argc, char *argv[])
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
- struniqs_new ();
+ uniqstrs_new ();
getargs (argc, argv);
- time_report = trace_flag & trace_time;
+ timevar_report = trace_flag & trace_time;
init_timevar ();
timevar_start (TV_TOTAL);
@@ -166,7 +169,7 @@ main (int argc, char *argv[])
contains things such as user actions, prologue, epilogue etc. */
scanner_free ();
muscle_free ();
- struniqs_free ();
+ uniqstrs_free ();
/* If using alloca.c, flush the alloca'ed memory for the benefit of
people running Bison as a library in IDEs. */
#if C_ALLOCA
Index: src/muscle_tab.c
===================================================================
RCS file: /cvsroot/bison/bison/src/muscle_tab.c,v
retrieving revision 1.28
diff -p -u -r1.28 muscle_tab.c
--- src/muscle_tab.c 12 Nov 2002 08:05:59 -0000 1.28
+++ src/muscle_tab.c 11 Dec 2002 05:09:23 -0000
@@ -19,12 +19,19 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
-#include "hash.h"
-#include "quotearg.h"
+
+#include <hash.h>
+#include <quotearg.h>
+
#include "files.h"
#include "muscle_tab.h"
#include "getargs.h"
+typedef struct
+{
+ const char *key;
+ char *value;
+} muscle_entry;
/* An obstack used to create some entries. */
struct obstack muscle_obstack;
@@ -37,15 +44,15 @@ struct hash_table *muscle_table = NULL;
static bool
hash_compare_muscles (void const *x, void const *y)
{
- const muscle_entry_t *m1 = x;
- const muscle_entry_t *m2 = y;
+ muscle_entry const *m1 = x;
+ muscle_entry const *m2 = y;
return strcmp (m1->key, m2->key) == 0;
}
static unsigned int
hash_muscle (const void *x, unsigned int tablesize)
{
- const muscle_entry_t *m = x;
+ muscle_entry const *m = x;
return hash_string (m->key, tablesize);
}
@@ -90,8 +97,8 @@ muscle_free (void)
void
muscle_insert (const char *key, char *value)
{
- muscle_entry_t probe;
- muscle_entry_t *entry = NULL;
+ muscle_entry probe;
+ muscle_entry *entry = NULL;
probe.key = key;
entry = hash_lookup (muscle_table, &probe);
@@ -99,7 +106,7 @@ muscle_insert (const char *key, char *va
if (!entry)
{
/* First insertion in the hash. */
- entry = XMALLOC (muscle_entry_t, 1);
+ entry = XMALLOC (muscle_entry, 1);
entry->key = key;
hash_insert (muscle_table, entry);
}
@@ -116,8 +123,8 @@ muscle_insert (const char *key, char *va
void
muscle_grow (const char *key, const char *val, const char *separator)
{
- muscle_entry_t probe;
- muscle_entry_t *entry = NULL;
+ muscle_entry probe;
+ muscle_entry *entry = NULL;
probe.key = key;
entry = hash_lookup (muscle_table, &probe);
@@ -125,7 +132,7 @@ muscle_grow (const char *key, const char
if (!entry)
{
/* First insertion in the hash. */
- entry = XMALLOC (muscle_entry_t, 1);
+ entry = XMALLOC (muscle_entry, 1);
entry->key = key;
hash_insert (muscle_table, entry);
entry->value = xstrdup (val);
@@ -171,8 +178,8 @@ void muscle_pair_list_grow (const char *
char*
muscle_find (const char *key)
{
- muscle_entry_t probe;
- muscle_entry_t *result = NULL;
+ muscle_entry probe;
+ muscle_entry *result = NULL;
probe.key = key;
result = hash_lookup (muscle_table, &probe);
@@ -185,7 +192,7 @@ muscle_find (const char *key)
`------------------------------------------------*/
static int
-muscle_m4_output (muscle_entry_t *entry, FILE *out)
+muscle_m4_output (muscle_entry *entry, FILE *out)
{
fprintf (out, "m4_define([b4_%s],\n", entry->key);
fprintf (out, "[[%s]])\n\n\n", entry->value);
Index: src/muscle_tab.h
===================================================================
RCS file: /cvsroot/bison/bison/src/muscle_tab.h,v
retrieving revision 1.9
diff -p -u -r1.9 muscle_tab.h
--- src/muscle_tab.h 12 Nov 2002 07:24:33 -0000 1.9
+++ src/muscle_tab.h 11 Dec 2002 05:09:23 -0000
@@ -21,12 +21,6 @@
#ifndef MUSCLE_TAB_H_
# define MUSCLE_TAB_H_
-typedef struct muscle_entry_s
-{
- const char *key;
- char *value;
-} muscle_entry_t;
-
void muscle_init (void);
void muscle_insert (const char *key, char *value);
char *muscle_find (const char *key);
Index: src/nullable.c
===================================================================
RCS file: /cvsroot/bison/bison/src/nullable.c,v
retrieving revision 1.37
diff -p -u -r1.37 nullable.c
--- src/nullable.c 21 Nov 2002 05:18:57 -0000 1.37
+++ src/nullable.c 11 Dec 2002 05:09:23 -0000
@@ -24,18 +24,19 @@
do so. */
#include "system.h"
+
#include "getargs.h"
-#include "symtab.h"
#include "gram.h"
-#include "reduce.h"
#include "nullable.h"
+#include "reduce.h"
+#include "symtab.h"
/* Linked list of rules. */
-typedef struct rule_list_s
+typedef struct rule_list
{
- struct rule_list_s *next;
- rule_t *value;
-} rule_list_t;
+ struct rule_list *next;
+ rule *value;
+} rule_list;
bool *nullable = NULL;
@@ -52,19 +53,19 @@ nullable_print (FILE *out)
void
nullable_compute (void)
{
- rule_number_t ruleno;
- symbol_number_t *s1;
- symbol_number_t *s2;
- rule_list_t *p;
+ rule_number ruleno;
+ symbol_number *s1;
+ symbol_number *s2;
+ rule_list *p;
- symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);
+ symbol_number *squeue = XCALLOC (symbol_number, nvars);
short *rcount = XCALLOC (short, nrules);
/* RITEM contains all the rules, including useless productions.
Hence we must allocate room for useless nonterminals too. */
- rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;
+ rule_list **rsets = XCALLOC (rule_list *, nvars) - ntokens;
/* This is said to be more elements than we actually use.
Supposedly NRITEMS - NRULES is enough. But why take the risk? */
- rule_list_t *relts = XCALLOC (rule_list_t, nritems + nvars + 1);
+ rule_list *relts = XCALLOC (rule_list, nritems + nvars + 1);
nullable = XCALLOC (bool, nvars) - ntokens;
@@ -74,24 +75,24 @@ nullable_compute (void)
for (ruleno = 0; ruleno < nrules; ++ruleno)
if (rules[ruleno].useful)
{
- rule_t *rule = &rules[ruleno];
- if (rule->rhs[0] >= 0)
+ rule *rules_ruleno = &rules[ruleno];
+ if (rules_ruleno->rhs[0] >= 0)
{
/* This rule has a non empty RHS. */
- item_number_t *r = NULL;
+ item_number *r = NULL;
int any_tokens = 0;
- for (r = rule->rhs; *r >= 0; ++r)
+ for (r = rules_ruleno->rhs; *r >= 0; ++r)
if (ISTOKEN (*r))
any_tokens = 1;
/* This rule has only nonterminals: schedule it for the second
pass. */
if (!any_tokens)
- for (r = rule->rhs; *r >= 0; ++r)
+ for (r = rules_ruleno->rhs; *r >= 0; ++r)
{
rcount[ruleno]++;
p->next = rsets[*r];
- p->value = rule;
+ p->value = rules_ruleno;
rsets[*r] = p;
p++;
}
@@ -99,12 +100,12 @@ nullable_compute (void)
else
{
/* This rule has an empty RHS. */
- if (item_number_as_rule_number (rule->rhs[0]) != ruleno)
+ if (item_number_as_rule_number (rules_ruleno->rhs[0]) != ruleno)
abort ();
- if (rule->useful && !nullable[rule->lhs->number])
+ if (rules_ruleno->useful && !nullable[rules_ruleno->lhs->number])
{
- nullable[rule->lhs->number] = 1;
- *s2++ = rule->lhs->number;
+ nullable[rules_ruleno->lhs->number] = 1;
+ *s2++ = rules_ruleno->lhs->number;
}
}
}
@@ -112,12 +113,12 @@ nullable_compute (void)
while (s1 < s2)
for (p = rsets[*s1++]; p; p = p->next)
{
- rule_t *rule = p->value;
- if (--rcount[rule->number] == 0)
- if (rule->useful && !nullable[rule->lhs->number])
+ rule *r = p->value;
+ if (--rcount[r->number] == 0)
+ if (r->useful && !nullable[r->lhs->number])
{
- nullable[rule->lhs->number] = 1;
- *s2++ = rule->lhs->number;
+ nullable[r->lhs->number] = 1;
+ *s2++ = r->lhs->number;
}
}
Index: src/output.c
===================================================================
RCS file: /cvsroot/bison/bison/src/output.c,v
retrieving revision 1.213
diff -p -u -r1.213 output.c
--- src/output.c 7 Dec 2002 05:59:42 -0000 1.213
+++ src/output.c 11 Dec 2002 05:09:23 -0000
@@ -21,18 +21,22 @@
#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 *);
@@ -100,11 +104,11 @@ Name (const char *name,
\
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)
/*----------------------------------------------------------------------.
@@ -162,9 +166,9 @@ prepare_symbols (void)
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;
@@ -172,7 +176,7 @@ prepare_symbols (void)
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). */
@@ -204,19 +208,19 @@ prepare_symbols (void)
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. */
@@ -264,9 +268,9 @@ prepare_rules (void)
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,
@@ -286,7 +290,7 @@ prepare_states (void)
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)
@@ -340,8 +344,8 @@ token_definitions_output (FILE *out)
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
@@ -350,27 +354,27 @@ token_definitions_output (FILE *out)
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;
}
@@ -392,20 +396,20 @@ symbol_destructors_output (FILE *out)
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.start.file);
+ escaped_file_name_output (out, sym->destructor_location.start.file);
fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- symbol->destructor_location.start.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;
}
@@ -427,20 +431,20 @@ symbol_printers_output (FILE *out)
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[",
first ? "" : ",\n");
- escaped_file_name_output (out, symbol->printer_location.start.file);
+ escaped_file_name_output (out, sym->printer_location.start.file);
fprintf (out, ", [[%d]], [[%s]], [[%d]], [[%s]], [[%s]]]",
- symbol->printer_location.start.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;
}
@@ -551,7 +555,7 @@ output_skeleton (void)
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);
@@ -572,7 +576,7 @@ output_skeleton (void)
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);
Index: src/parse-gram.y
===================================================================
RCS file: /cvsroot/bison/bison/src/parse-gram.y,v
retrieving revision 1.34
diff -p -u -r1.34 parse-gram.y
--- src/parse-gram.y 7 Dec 2002 06:01:20 -0000 1.34
+++ src/parse-gram.y 11 Dec 2002 05:09:23 -0000
@@ -30,15 +30,16 @@
%{
#include "system.h"
+
#include "complain.h"
-#include "muscle_tab.h"
+#include "conflicts.h"
#include "files.h"
#include "getargs.h"
-#include "output.h"
-#include "symlist.h"
#include "gram.h"
+#include "muscle_tab.h"
+#include "output.h"
#include "reader.h"
-#include "conflicts.h"
+#include "symlist.h"
/* Produce verbose syntax errors. */
#define YYERROR_VERBOSE 1
@@ -51,33 +52,33 @@ static YYLTYPE lloc_default (YYLTYPE con
#undef yyerror
#define yyerror(Msg) \
gram_error (&yylloc, Msg)
-static void gram_error (location_t const *, char const *);
+static void gram_error (location const *, char const *);
#define YYPRINT(File, Type, Value) \
print_token_value (File, Type, &Value)
static void print_token_value (FILE *, int, YYSTYPE const *);
-static void add_param (char const *, char const *, location_t);
+static void add_param (char const *, char const *, location);
symbol_class current_class = unknown_sym;
-struniq_t current_type = 0;
-symbol_t *current_lhs;
-location_t current_lhs_location;
-assoc_t current_assoc;
+uniqstr current_type = 0;
+symbol *current_lhs;
+location current_lhs_location;
+assoc current_assoc;
int current_prec = 0;
-braced_code_t current_braced_code = action_braced_code;
+braced_code current_braced_code = action_braced_code;
%}
/* Only NUMBERS have a value. */
%union
{
- symbol_t *symbol;
- symbol_list_t *list;
+ symbol *symbol;
+ symbol_list *list;
int integer;
- char *string;
- assoc_t assoc;
- struniq_t struniq;
+ char *chars;
+ assoc assoc;
+ uniqstr uniqstr;
};
/* Define the tokens together with their human representation. */
@@ -141,10 +142,10 @@ braced_code_t current_braced_code = acti
%token BRACED_CODE "{...}"
-%type <string> STRING string_content
- BRACED_CODE code_content action
- PROLOGUE EPILOGUE
-%type <struniq> TYPE
+%type <chars> STRING string_content
+ BRACED_CODE code_content action
+ PROLOGUE EPILOGUE
+%type <uniqstr> TYPE
%type <integer> INT
%type <symbol> ID ID_COLON symbol string_as_id
%type <assoc> precedence_declarator
@@ -206,7 +207,7 @@ grammar_declaration:
{ current_braced_code = destructor_braced_code; }
BRACED_CODE symbols.1
{
- symbol_list_t *list;
+ symbol_list *list;
for (list = $4; list; list = list->next)
symbol_destructor_set (list->sym, $3, @3);
symbol_list_free ($4);
@@ -216,7 +217,7 @@ grammar_declaration:
{ current_braced_code = printer_braced_code; }
BRACED_CODE symbols.1
{
- symbol_list_t *list;
+ symbol_list *list;
for (list = $4; list; list = list->next)
symbol_printer_set (list->sym, $3, list->location);
symbol_list_free ($4);
@@ -237,7 +238,7 @@ symbol_declaration:
}
| "%type" TYPE symbols.1
{
- symbol_list_t *list;
+ symbol_list *list;
for (list = $3; list; list = list->next)
symbol_type_set (list->sym, $2, @2);
symbol_list_free ($3);
@@ -247,7 +248,7 @@ symbol_declaration:
precedence_declaration:
precedence_declarator type.opt symbols.1
{
- symbol_list_t *list;
+ symbol_list *list;
++current_prec;
for (list = $3; list; list = list->next)
{
@@ -448,7 +449,7 @@ lloc_default (YYLTYPE const *rhs, int n)
declaration DECL and location LOC. */
static void
-add_param (char const *type, char const *decl, location_t loc)
+add_param (char const *type, char const *decl, location loc)
{
static char const alphanum[] =
"0123456789"
@@ -504,17 +505,17 @@ print_token_value (FILE *file, int type,
break;
case STRING:
- fprintf (file, " = \"%s\"", value->string);
+ fprintf (file, " = \"%s\"", value->chars);
break;
case TYPE:
- fprintf (file, " = <%s>", value->struniq);
+ fprintf (file, " = <%s>", value->uniqstr);
break;
case BRACED_CODE:
case PROLOGUE:
case EPILOGUE:
- fprintf (file, " = {{ %s }}", value->string);
+ fprintf (file, " = {{ %s }}", value->chars);
break;
default:
@@ -524,7 +525,7 @@ print_token_value (FILE *file, int type,
}
static void
-gram_error (location_t const *loc, char const *msg)
+gram_error (location const *loc, char const *msg)
{
complain_at (*loc, "%s", msg);
}
Index: src/print.c
===================================================================
RCS file: /cvsroot/bison/bison/src/print.c,v
retrieving revision 1.91
diff -p -u -r1.91 print.c
--- src/print.c 22 Oct 2002 04:42:25 -0000 1.91
+++ src/print.c 11 Dec 2002 05:09:24 -0000
@@ -21,20 +21,22 @@
#include "system.h"
-#include "quotearg.h"
-#include "files.h"
-#include "symtab.h"
-#include "gram.h"
+
+#include <bitset.h>
+#include <quotearg.h>
+
#include "LR0.h"
-#include "lalr.h"
+#include "closure.h"
#include "conflicts.h"
+#include "files.h"
#include "getargs.h"
-#include "state.h"
-#include "reader.h"
+#include "gram.h"
+#include "lalr.h"
#include "print.h"
+#include "reader.h"
#include "reduce.h"
-#include "closure.h"
-#include "bitset.h"
+#include "state.h"
+#include "symtab.h"
static bitset shiftset;
static bitset lookaheadset;
@@ -66,12 +68,12 @@ max_length (size_t *width, const char *s
`--------------------------------*/
static void
-print_core (FILE *out, state_t *state)
+print_core (FILE *out, state *s)
{
int i;
- item_number_t *sitems = state->items;
- int snritems = state->nitems;
- symbol_t *previous_lhs = NULL;
+ item_number *sitems = s->items;
+ int snritems = s->nitems;
+ symbol *previous_lhs = NULL;
/* Output all the items of a state, not only its kernel. */
if (report_flag & report_itemsets)
@@ -88,21 +90,21 @@ print_core (FILE *out, state_t *state)
for (i = 0; i < snritems; i++)
{
- item_number_t *sp;
- item_number_t *sp1;
- int rule;
+ item_number *sp;
+ item_number *sp1;
+ int r;
sp1 = sp = ritem + sitems[i];
while (*sp >= 0)
sp++;
- rule = item_number_as_rule_number (*sp);
+ r = item_number_as_rule_number (*sp);
- rule_lhs_print (&rules[rule], previous_lhs, out);
- previous_lhs = rules[rule].lhs;
+ rule_lhs_print (&rules[r], previous_lhs, out);
+ previous_lhs = rules[r].lhs;
- for (sp = rules[rule].rhs; sp < sp1; sp++)
+ for (sp = rules[r].rhs; sp < sp1; sp++)
fprintf (out, " %s", symbols[*sp]->tag);
fputs (" .", out);
for (/* Nothing */; *sp >= 0; ++sp)
@@ -110,32 +112,32 @@ print_core (FILE *out, state_t *state)
/* Display the lookaheads? */
if (report_flag & report_lookaheads)
- state_rule_lookaheads_print (state, &rules[rule], out);
+ state_rule_lookaheads_print (s, &rules[r], out);
fputc ('\n', out);
}
}
-/*----------------------------------------------------------------.
-| Report the shifts iff DISPLAY_SHIFTS_P or the gotos of STATE on |
-| OUT. |
-`----------------------------------------------------------------*/
+/*------------------------------------------------------------.
+| Report the shifts iff DISPLAY_SHIFTS_P or the gotos of S on |
+| OUT. |
+`------------------------------------------------------------*/
static void
-print_transitions (state_t *state, FILE *out, bool display_transitions_p)
+print_transitions (state *s, FILE *out, bool display_transitions_p)
{
- transitions_t *transitions = state->transitions;
+ transitions *trans = s->transitions;
size_t width = 0;
int i;
/* Compute the width of the lookaheads column. */
- for (i = 0; i < transitions->num; i++)
- if (!TRANSITION_IS_DISABLED (transitions, i)
- && TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
+ for (i = 0; i < trans->num; i++)
+ if (!TRANSITION_IS_DISABLED (trans, i)
+ && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)
{
- symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
- max_length (&width, symbol->tag);
+ symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
+ max_length (&width, sym->tag);
}
/* Nothing to report. */
@@ -146,34 +148,34 @@ print_transitions (state_t *state, FILE
width += 2;
/* Report lookaheads and shifts. */
- for (i = 0; i < transitions->num; i++)
- if (!TRANSITION_IS_DISABLED (transitions, i)
- && TRANSITION_IS_SHIFT (transitions, i) == display_transitions_p)
+ for (i = 0; i < trans->num; i++)
+ if (!TRANSITION_IS_DISABLED (trans, i)
+ && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p)
{
- symbol_t *symbol = symbols[TRANSITION_SYMBOL (transitions, i)];
- const char *tag = symbol->tag;
- state_t *state1 = transitions->states[i];
+ symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
+ const char *tag = sym->tag;
+ state *s1 = trans->states[i];
int j;
fprintf (out, " %s", tag);
for (j = width - strlen (tag); j > 0; --j)
fputc (' ', out);
if (display_transitions_p)
- fprintf (out, _("shift, and go to state %d\n"), state1->number);
+ fprintf (out, _("shift, and go to state %d\n"), s1->number);
else
- fprintf (out, _("go to state %d\n"), state1->number);
+ fprintf (out, _("go to state %d\n"), s1->number);
}
}
-/*------------------------------------------------------------.
-| Report the explicit errors of STATE raised from %nonassoc. |
-`------------------------------------------------------------*/
+/*--------------------------------------------------------.
+| Report the explicit errors of S raised from %nonassoc. |
+`--------------------------------------------------------*/
static void
-print_errs (FILE *out, state_t *state)
+print_errs (FILE *out, state *s)
{
- errs_t *errp = state->errs;
+ errs *errp = s->errs;
size_t width = 0;
int i;
@@ -203,66 +205,65 @@ print_errs (FILE *out, state_t *state)
}
-/*----------------------------------------------------------.
-| Return the default rule of this STATE if it has one, NULL |
-| otherwise. |
-`----------------------------------------------------------*/
+/*-------------------------------------------------------------.
+| Return the default rule of S if it has one, NULL otherwise. |
+`-------------------------------------------------------------*/
-static rule_t *
-state_default_rule (state_t *state)
+static rule *
+state_default_rule (state *s)
{
- reductions_t *redp = state->reductions;
- rule_t *default_rule = NULL;
+ reductions *reds = s->reductions;
+ rule *default_rule = NULL;
int cmax = 0;
int i;
/* No need for a lookahead. */
- if (state->consistent)
- return redp->rules[0];
+ if (s->consistent)
+ return reds->rules[0];
/* 1. Each reduction is possibly masked by the lookaheads on which
we shift (S/R conflicts)... */
bitset_zero (shiftset);
{
- transitions_t *transitions = state->transitions;
- FOR_EACH_SHIFT (transitions, i)
+ transitions *trans = s->transitions;
+ FOR_EACH_SHIFT (trans, i)
{
/* If this state has a shift for the error token, don't use a
default rule. */
- if (TRANSITION_IS_ERROR (transitions, i))
+ if (TRANSITION_IS_ERROR (trans, i))
return NULL;
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ bitset_set (shiftset, TRANSITION_SYMBOL (trans, i));
}
}
/* 2. Each reduction is possibly masked by the lookaheads on which
we raise an error (due to %nonassoc). */
{
- errs_t *errp = state->errs;
+ errs *errp = s->errs;
for (i = 0; i < errp->num; i++)
if (errp->symbols[i])
bitset_set (shiftset, errp->symbols[i]->number);
}
- for (i = 0; i < redp->num; ++i)
+ for (i = 0; i < reds->num; ++i)
{
int count = 0;
/* How many non-masked lookaheads are there for this reduction?
*/
- bitset_andn (lookaheadset, redp->lookaheads[i], shiftset);
+ bitset_andn (lookaheadset, reds->lookaheads[i], shiftset);
count = bitset_count (lookaheadset);
if (count > cmax)
{
cmax = count;
- default_rule = redp->rules[i];
+ default_rule = reds->rules[i];
}
/* 3. And finally, each reduction is possibly masked by previous
reductions (in R/R conflicts, we keep the first reductions).
*/
- bitset_or (shiftset, shiftset, redp->lookaheads[i]);
+ bitset_or (shiftset, shiftset, reds->lookaheads[i]);
}
return default_rule;
@@ -278,7 +279,7 @@ state_default_rule (state_t *state)
static void
print_reduction (FILE *out, size_t width,
const char *lookahead,
- rule_t *rule, bool enabled)
+ rule *r, bool enabled)
{
int j;
fprintf (out, " %s", lookahead);
@@ -286,9 +287,8 @@ print_reduction (FILE *out, size_t width
fputc (' ', out);
if (!enabled)
fputc ('[', out);
- if (rule->number)
- fprintf (out, _("reduce using rule %d (%s)"),
- rule->number, rule->lhs->tag);
+ if (r->number)
+ fprintf (out, _("reduce using rule %d (%s)"), r->number, r->lhs->tag);
else
fprintf (out, _("accept"));
if (!enabled)
@@ -297,43 +297,43 @@ print_reduction (FILE *out, size_t width
}
-/*----------------------------------------------------.
-| Report on OUT the reduction actions of this STATE. |
-`----------------------------------------------------*/
+/*-------------------------------------------.
+| Report on OUT the reduction actions of S. |
+`-------------------------------------------*/
static void
-print_reductions (FILE *out, state_t *state)
+print_reductions (FILE *out, state *s)
{
- transitions_t *transitions = state->transitions;
- reductions_t *redp = state->reductions;
- rule_t *default_rule = NULL;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
+ rule *default_rule = NULL;
size_t width = 0;
int i, j;
- if (redp->num == 0)
+ if (reds->num == 0)
return;
- default_rule = state_default_rule (state);
+ default_rule = state_default_rule (s);
bitset_zero (shiftset);
- FOR_EACH_SHIFT (transitions, i)
- bitset_set (shiftset, TRANSITION_SYMBOL (transitions, i));
+ FOR_EACH_SHIFT (trans, i)
+ bitset_set (shiftset, TRANSITION_SYMBOL (trans, i));
/* Compute the width of the lookaheads column. */
if (default_rule)
width = strlen (_("$default"));
- if (redp->lookaheads)
+ if (reds->lookaheads)
for (i = 0; i < ntokens; i++)
{
int count = bitset_test (shiftset, i);
- for (j = 0; j < redp->num; ++j)
- if (bitset_test (redp->lookaheads[j], i))
+ for (j = 0; j < reds->num; ++j)
+ if (bitset_test (reds->lookaheads[j], i))
{
if (count == 0)
{
- if (redp->rules[j] != default_rule)
+ if (reds->rules[j] != default_rule)
max_length (&width, symbols[i]->tag);
count++;
}
@@ -352,21 +352,21 @@ print_reductions (FILE *out, state_t *st
width += 2;
/* Report lookaheads (or $default) and reductions. */
- if (redp->lookaheads)
+ if (reds->lookaheads)
for (i = 0; i < ntokens; i++)
{
int defaulted = 0;
int count = bitset_test (shiftset, i);
- for (j = 0; j < redp->num; ++j)
- if (bitset_test (redp->lookaheads[j], i))
+ for (j = 0; j < reds->num; ++j)
+ if (bitset_test (reds->lookaheads[j], i))
{
if (count == 0)
{
- if (redp->rules[j] != default_rule)
+ if (reds->rules[j] != default_rule)
print_reduction (out, width,
symbols[i]->tag,
- redp->rules[j], true);
+ reds->rules[j], true);
else
defaulted = 1;
count++;
@@ -380,7 +380,7 @@ print_reductions (FILE *out, state_t *st
defaulted = 0;
print_reduction (out, width,
symbols[i]->tag,
- redp->rules[j], false);
+ reds->rules[j], false);
}
}
}
@@ -393,38 +393,37 @@ print_reductions (FILE *out, state_t *st
/*--------------------------------------------------------------.
| Report on OUT all the actions (shifts, gotos, reductions, and |
-| explicit erros from %nonassoc) of STATE. |
+| explicit erros from %nonassoc) of S. |
`--------------------------------------------------------------*/
static void
-print_actions (FILE *out, state_t *state)
+print_actions (FILE *out, state *s)
{
/* Print shifts. */
- print_transitions (state, out, true);
- print_errs (out, state);
- print_reductions (out, state);
+ print_transitions (s, out, true);
+ print_errs (out, s);
+ print_reductions (out, s);
/* Print gotos. */
- print_transitions (state, out, false);
+ print_transitions (s, out, false);
}
-/*--------------------------------------.
-| Report all the data on STATE on OUT. |
-`--------------------------------------*/
+/*----------------------------------.
+| Report all the data on S on OUT. |
+`----------------------------------*/
static void
-print_state (FILE *out, state_t *state)
+print_state (FILE *out, state *s)
{
fputs ("\n\n", out);
- fprintf (out, _("state %d"), state->number);
+ fprintf (out, _("state %d"), s->number);
fputc ('\n', out);
- print_core (out, state);
- print_actions (out, state);
- if ((report_flag & report_solved_conflicts)
- && state->solved_conflicts)
+ print_core (out, s);
+ print_actions (out, s);
+ if ((report_flag & report_solved_conflicts) && s->solved_conflicts)
{
fputc ('\n', out);
- fputs (state->solved_conflicts, out);
+ fputs (s->solved_conflicts, out);
}
}
@@ -446,7 +445,7 @@ do { \
static void
print_grammar (FILE *out)
{
- symbol_number_t i;
+ symbol_number i;
char buffer[90];
int column = 0;
@@ -458,8 +457,8 @@ print_grammar (FILE *out)
if (token_translations[i] != undeftoken->number)
{
const char *tag = symbols[token_translations[i]]->tag;
- rule_number_t r;
- item_number_t *rhsp;
+ rule_number r;
+ item_number *rhsp;
buffer[0] = 0;
column = strlen (tag);
@@ -484,12 +483,12 @@ print_grammar (FILE *out)
for (i = ntokens; i < nsyms; i++)
{
int left_count = 0, right_count = 0;
- rule_number_t r;
+ rule_number r;
const char *tag = symbols[i]->tag;
for (r = 0; r < nrules; r++)
{
- item_number_t *rhsp;
+ item_number *rhsp;
if (rules[r].lhs->number == i)
left_count++;
for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
@@ -527,7 +526,7 @@ print_grammar (FILE *out)
sprintf (buffer + strlen (buffer), _(" on right:"));
for (r = 0; r < nrules; r++)
{
- item_number_t *rhsp;
+ item_number *rhsp;
for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
if (item_number_as_symbol_number (*rhsp) == i)
{
@@ -544,7 +543,7 @@ print_grammar (FILE *out)
void
print_results (void)
{
- state_number_t i;
+ state_number i;
/* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
that conflicts with Posix. */
Index: src/print_graph.c
===================================================================
RCS file: /cvsroot/bison/bison/src/print_graph.c,v
retrieving revision 1.51
diff -p -u -r1.51 print_graph.c
--- src/print_graph.c 1 Aug 2002 18:14:30 -0000 1.51
+++ src/print_graph.c 11 Dec 2002 05:09:24 -0000
@@ -19,23 +19,25 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
-#include "quotearg.h"
-#include "files.h"
-#include "symtab.h"
-#include "gram.h"
+
+#include <obstack.h>
+#include <quotearg.h>
+
#include "LR0.h"
-#include "lalr.h"
-#include "conflicts.h"
+#include "closure.h"
#include "complain.h"
+#include "conflicts.h"
+#include "files.h"
#include "getargs.h"
-#include "state.h"
-#include "reader.h"
-#include "closure.h"
-#include "obstack.h"
+#include "gram.h"
+#include "lalr.h"
#include "print_graph.h"
+#include "reader.h"
+#include "state.h"
+#include "symtab.h"
#include "vcg.h"
-static graph_t graph;
+static graph static_graph;
static FILE *fgraph = NULL;
@@ -44,11 +46,11 @@ static FILE *fgraph = NULL;
`----------------------------*/
static void
-print_core (struct obstack *oout, state_t *state)
+print_core (struct obstack *oout, state *s)
{
int i;
- item_number_t *sitems = state->items;
- int snritems = state->nitems;
+ item_number *sitems = s->items;
+ int snritems = s->nitems;
/* Output all the items of a state, not only its kernel. */
if (report_flag & report_itemsets)
@@ -58,26 +60,26 @@ print_core (struct obstack *oout, state_
snritems = nritemset;
}
- obstack_fgrow1 (oout, "state %2d\n", state->number);
+ obstack_fgrow1 (oout, "state %2d\n", s->number);
for (i = 0; i < snritems; i++)
{
- item_number_t *sp;
- item_number_t *sp1;
- rule_number_t rule;
+ item_number *sp;
+ item_number *sp1;
+ rule_number r;
sp1 = sp = ritem + sitems[i];
while (*sp >= 0)
sp++;
- rule = item_number_as_rule_number (*sp);
+ r = item_number_as_rule_number (*sp);
if (i)
obstack_1grow (oout, '\n');
obstack_fgrow1 (oout, " %s -> ",
- rules[rule].lhs->tag);
+ rules[r].lhs->tag);
- for (sp = rules[rule].rhs; sp < sp1; sp++)
+ for (sp = rules[r].rhs; sp < sp1; sp++)
obstack_fgrow1 (oout, "%s ", symbols[*sp]->tag);
obstack_1grow (oout, '.');
@@ -89,8 +91,8 @@ print_core (struct obstack *oout, state_
if (report_flag & report_lookaheads)
{
/* Find the reduction we are handling. */
- reductions_t *reds = state->reductions;
- int redno = state_reduction_find (state, &rules[rule]);
+ reductions *reds = s->reductions;
+ int redno = state_reduction_find (s, &rules[r]);
/* Print them if there are. */
if (reds->lookaheads && redno != -1)
@@ -116,41 +118,41 @@ print_core (struct obstack *oout, state_
`---------------------------------------------------------------*/
static void
-print_actions (state_t *state, const char *node_name)
+print_actions (state *s, const char *node_name)
{
int i;
- transitions_t *transitions = state->transitions;
- reductions_t *redp = state->reductions;
+ transitions *trans = s->transitions;
+ reductions *reds = s->reductions;
static char buff[10];
- edge_t edge;
+ edge e;
- if (!transitions->num && !redp)
+ if (!trans->num && !reds)
return;
- for (i = 0; i < transitions->num; i++)
- if (!TRANSITION_IS_DISABLED (transitions, i))
+ for (i = 0; i < trans->num; i++)
+ if (!TRANSITION_IS_DISABLED (trans, i))
{
- state_t *state1 = transitions->states[i];
- symbol_number_t symbol = state1->accessing_symbol;
+ state *s1 = trans->states[i];
+ symbol_number sym = s1->accessing_symbol;
- new_edge (&edge);
+ new_edge (&e);
- if (state->number > state1->number)
- edge.type = back_edge;
- open_edge (&edge, fgraph);
+ if (s->number > s1->number)
+ e.type = back_edge;
+ open_edge (&e, fgraph);
/* The edge source is the current node. */
- edge.sourcename = node_name;
- sprintf (buff, "%d", state1->number);
- edge.targetname = buff;
+ e.sourcename = node_name;
+ sprintf (buff, "%d", s1->number);
+ e.targetname = buff;
/* Shifts are blue, gotos are green, and error is red. */
- if (TRANSITION_IS_ERROR (transitions, i))
- edge.color = red;
+ if (TRANSITION_IS_ERROR (trans, i))
+ e.color = red;
else
- edge.color = TRANSITION_IS_SHIFT(transitions, i) ? blue : green;
- edge.label = symbols[symbol]->tag;
- output_edge (&edge, fgraph);
+ e.color = TRANSITION_IS_SHIFT (trans, i) ? blue : green;
+ e.label = symbols[sym]->tag;
+ output_edge (&e, fgraph);
close_edge (fgraph);
}
}
@@ -162,27 +164,27 @@ print_actions (state_t *state, const cha
`-------------------------------------------------------------*/
static void
-print_state (state_t *state)
+print_state (state *s)
{
static char name[10];
struct obstack node_obstack;
- node_t node;
+ node n;
/* The labels of the nodes are their the items. */
obstack_init (&node_obstack);
- new_node (&node);
- sprintf (name, "%d", state->number);
- node.title = name;
- print_core (&node_obstack, state);
+ new_node (&n);
+ sprintf (name, "%d", s->number);
+ n.title = name;
+ print_core (&node_obstack, s);
obstack_1grow (&node_obstack, '\0');
- node.label = obstack_finish (&node_obstack);
+ n.label = obstack_finish (&node_obstack);
open_node (fgraph);
- output_node (&node, fgraph);
+ output_node (&n, fgraph);
close_node (fgraph);
/* Output the edges. */
- print_actions (state, name);
+ print_actions (s, name);
obstack_free (&node_obstack, 0);
}
@@ -191,32 +193,32 @@ print_state (state_t *state)
void
print_graph (void)
{
- state_number_t i;
+ state_number i;
/* Output file. */
fgraph = xfopen (spec_graph_file, "w");
- new_graph (&graph);
+ new_graph (&static_graph);
#if 0
- graph.smanhattan_edges = yes;
- graph.manhattan_edges = yes;
+ static_graph.smanhattan_edges = yes;
+ static_graph.manhattan_edges = yes;
#endif
- graph.display_edge_labels = yes;
- graph.layoutalgorithm = normal;
+ static_graph.display_edge_labels = yes;
+ static_graph.layoutalgorithm = normal;
- graph.port_sharing = no;
- graph.finetuning = yes;
- graph.straight_phase = yes;
- graph.priority_phase = yes;
- graph.splines = yes;
+ static_graph.port_sharing = no;
+ static_graph.finetuning = yes;
+ static_graph.long_straight_phase = yes;
+ static_graph.priority_phase = yes;
+ static_graph.splines = yes;
- graph.crossing_weight = median;
+ static_graph.crossing_weight = median;
/* Output graph options. */
open_graph (fgraph);
- output_graph (&graph, fgraph);
+ output_graph (&static_graph, fgraph);
/* Output nodes and edges. */
new_closure (nritems);
@@ -225,6 +227,6 @@ print_graph (void)
free_closure ();
/* Close graph. */
- close_graph (&graph, fgraph);
+ close_graph (&static_graph, fgraph);
xfclose (fgraph);
}
Index: src/reader.c
===================================================================
RCS file: /cvsroot/bison/bison/src/reader.c,v
retrieving revision 1.227
diff -p -u -r1.227 reader.c
--- src/reader.c 7 Dec 2002 06:02:10 -0000 1.227
+++ src/reader.c 11 Dec 2002 05:09:24 -0000
@@ -19,21 +19,22 @@
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
#include "system.h"
-#include "quotearg.h"
-#include "getargs.h"
+
+#include <quotearg.h>
+
+#include "complain.h"
+#include "conflicts.h"
#include "files.h"
-#include "symtab.h"
-#include "symlist.h"
+#include "getargs.h"
#include "gram.h"
-#include "complain.h"
+#include "muscle_tab.h"
#include "output.h"
#include "reader.h"
-#include "conflicts.h"
-#include "muscle_tab.h"
+#include "symlist.h"
+#include "symtab.h"
-static symbol_list_t *grammar = NULL;
+static symbol_list *grammar = NULL;
static int start_flag = 0;
merger_list *merge_functions;
@@ -45,15 +46,15 @@ int typed = 0;
`-----------------------*/
void
-grammar_start_symbol_set (symbol_t *s, location_t l)
+grammar_start_symbol_set (symbol *s, location loc)
{
if (start_flag)
- complain_at (l, _("multiple %s declarations"), "%start");
+ complain_at (loc, _("multiple %s declarations"), "%start");
else
{
start_flag = 1;
startsymbol = s;
- startsymbol_location = l;
+ startsymbol_location = loc;
}
}
@@ -64,15 +65,14 @@ grammar_start_symbol_set (symbol_t *s, l
`----------------------------------------------------------------*/
void
-prologue_augment (const char *prologue, location_t location)
+prologue_augment (const char *prologue, location loc)
{
struct obstack *oout =
!typed ? &pre_prologue_obstack : &post_prologue_obstack;
- obstack_fgrow1 (oout, "]b4_syncline([[%d]], [[",
- location.start.line);
- MUSCLE_OBSTACK_SGROW (oout, quotearg_style (c_quoting_style,
- location.start.file));
+ obstack_fgrow1 (oout, "]b4_syncline([[%d]], [[", loc.start.line);
+ MUSCLE_OBSTACK_SGROW (oout,
+ quotearg_style (c_quoting_style, loc.start.file));
obstack_sgrow (oout, "]])[\n");
obstack_sgrow (oout, prologue);
}
@@ -85,13 +85,12 @@ prologue_augment (const char *prologue,
`----------------------*/
void
-epilogue_augment (const char *epilogue, location_t location)
+epilogue_augment (const char *epilogue, location loc)
{
char *extension = NULL;
- obstack_fgrow1 (&muscle_obstack, "]b4_syncline([[%d]], [[",
- location.start.line);
+ obstack_fgrow1 (&muscle_obstack, "]b4_syncline([[%d]], [[", loc.start.line);
MUSCLE_OBSTACK_SGROW (&muscle_obstack,
- quotearg_style (c_quoting_style, location.start.file));
+ quotearg_style (c_quoting_style, loc.start.file));
obstack_sgrow (&muscle_obstack, "]])[\n");
obstack_sgrow (&muscle_obstack, epilogue);
obstack_1grow (&muscle_obstack, 0);
@@ -110,7 +109,7 @@ epilogue_augment (const char *epilogue,
`-------------------------------------------------------------------*/
static int
-get_merge_function (struniq_t name, struniq_t type, location_t loc)
+get_merge_function (uniqstr name, uniqstr type, location loc)
{
merger_list *syms;
merger_list head;
@@ -120,21 +119,21 @@ get_merge_function (struniq_t name, stru
return 0;
if (type == NULL)
- type = struniq_new ("");
+ type = uniqstr_new ("");
head.next = merge_functions;
for (syms = &head, n = 1; syms->next != NULL; syms = syms->next, n += 1)
- if (STRUNIQ_EQ (name, syms->next->name))
+ if (UNIQSTR_EQ (name, syms->next->name))
break;
if (syms->next == NULL)
{
syms->next = XMALLOC (merger_list, 1);
- syms->next->name = struniq_new (name);
- syms->next->type = struniq_new (type);
+ syms->next->name = uniqstr_new (name);
+ syms->next->type = uniqstr_new (type);
syms->next->next = NULL;
merge_functions = head.next;
}
- else if (!STRUNIQ_EQ (type, syms->next->type))
+ else if (!UNIQSTR_EQ (type, syms->next->type))
warn_at (loc, _("result type clash on merge function %s: <%s> != <%s>"),
name, type, syms->next->type);
return n;
@@ -161,7 +160,7 @@ free_merger_functions (void)
/*-------------------------------------------------------------------.
-| Parse the input grammar into a one symbol_list_t structure. Each |
+| Parse the input grammar into a one symbol_list structure. Each |
| rule is represented by a sequence of symbols: the left hand side |
| followed by the contents of the right hand side, followed by a |
| null pointer instead of a symbol to terminate the rule. The next |
@@ -179,13 +178,13 @@ free_merger_functions (void)
`-------------------------------------------------------------------*/
/* The (currently) last symbol of GRAMMAR. */
-symbol_list_t *grammar_end = NULL;
+symbol_list *grammar_end = NULL;
/* Append S to the GRAMMAR. */
void
-grammar_symbol_append (symbol_t *symbol, location_t location)
+grammar_symbol_append (symbol *sym, location loc)
{
- symbol_list_t *p = symbol_list_new (symbol, location);
+ symbol_list *p = symbol_list_new (sym, loc);
if (grammar_end)
grammar_end->next = p;
@@ -198,8 +197,8 @@ grammar_symbol_append (symbol_t *symbol,
/* The rule currently being defined, and the previous rule.
CURRENT_RULE points to the first LHS of the current rule, while
PREVIOUS_RULE_END points to the *end* of the previous rule (NULL). */
-symbol_list_t *current_rule = NULL;
-symbol_list_t *previous_rule_end = NULL;
+symbol_list *current_rule = NULL;
+symbol_list *previous_rule_end = NULL;
/*----------------------------------------------.
@@ -207,12 +206,12 @@ symbol_list_t *previous_rule_end = NULL;
`----------------------------------------------*/
void
-grammar_rule_begin (symbol_t *lhs, location_t location)
+grammar_rule_begin (symbol *lhs, location loc)
{
if (!start_flag)
{
startsymbol = lhs;
- startsymbol_location = location;
+ startsymbol_location = loc;
start_flag = 1;
}
@@ -221,7 +220,7 @@ grammar_rule_begin (symbol_t *lhs, locat
++nritems;
previous_rule_end = grammar_end;
- grammar_symbol_append (lhs, location);
+ grammar_symbol_append (lhs, loc);
current_rule = grammar_end;
/* Mark the rule's lhs as a nonterminal if not already so. */
@@ -233,7 +232,7 @@ grammar_rule_begin (symbol_t *lhs, locat
++nvars;
}
else if (lhs->class == token_sym)
- complain_at (location, _("rule given for %s, which is a token"), lhs->tag);
+ complain_at (loc, _("rule given for %s, which is a token"), lhs->tag);
}
/* Check that the last rule (CURRENT_RULE) is properly defined. For
@@ -242,9 +241,9 @@ grammar_rule_begin (symbol_t *lhs, locat
static void
grammar_current_rule_check (void)
{
- symbol_t *lhs = current_rule->sym;
+ symbol *lhs = current_rule->sym;
char const *lhs_type = lhs->type_name;
- symbol_t *first_rhs = current_rule->next->sym;
+ symbol *first_rhs = current_rule->next->sym;
/* If there is an action, then there is nothing we can do: the user
is allowed to shoot herself in the foot. */
@@ -260,7 +259,7 @@ grammar_current_rule_check (void)
if (first_rhs)
{
const char *rhs_type = first_rhs->type_name ? first_rhs->type_name : "";
- if (!STRUNIQ_EQ (lhs_type, rhs_type))
+ if (!UNIQSTR_EQ (lhs_type, rhs_type))
warn_at (current_rule->location,
_("type clash on default action: <%s> != <%s>"),
lhs_type, rhs_type);
@@ -277,11 +276,11 @@ grammar_current_rule_check (void)
`-------------------------------------*/
void
-grammar_rule_end (location_t location)
+grammar_rule_end (location loc)
{
/* Put an empty link in the list to mark the end of this rule */
grammar_symbol_append (NULL, grammar_end->location);
- current_rule->location = location;
+ current_rule->location = loc;
grammar_current_rule_check ();
}
@@ -302,9 +301,9 @@ grammar_midrule_action (void)
/* Make a DUMMY nonterminal, whose location is that of the midrule
action. Create the MIDRULE. */
- location_t dummy_location = current_rule->action_location;
- symbol_t *dummy = dummy_symbol_get (dummy_location);
- symbol_list_t *midrule = symbol_list_new (dummy, dummy_location);
+ location dummy_location = current_rule->action_location;
+ symbol *dummy = dummy_symbol_get (dummy_location);
+ symbol_list *midrule = symbol_list_new (dummy, dummy_location);
/* Make a new rule, whose body is empty, before the current one, so
that the action just read can belong to it. */
@@ -335,25 +334,24 @@ grammar_midrule_action (void)
/* Set the precedence symbol of the current rule to PRECSYM. */
void
-grammar_current_rule_prec_set (symbol_t *precsym, location_t location)
+grammar_current_rule_prec_set (symbol *precsym, location loc)
{
if (current_rule->ruleprec)
- complain_at (location, _("only one %s allowed per rule"), "%prec");
+ complain_at (loc, _("only one %s allowed per rule"), "%prec");
current_rule->ruleprec = precsym;
}
/* Attach dynamic precedence DPREC to the current rule. */
void
-grammar_current_rule_dprec_set (int dprec, location_t location)
+grammar_current_rule_dprec_set (int dprec, location loc)
{
if (! glr_parser)
- warn_at (location, _("%s affects only GLR parsers"), "%dprec");
+ warn_at (loc, _("%s affects only GLR parsers"), "%dprec");
if (dprec <= 0)
- complain_at (location,
- _("%s must be followed by positive number"), "%dprec");
+ complain_at (loc, _("%s must be followed by positive number"), "%dprec");
else if (current_rule->dprec != 0)
- complain_at (location, _("only one %s allowed per rule"), "%dprec");
+ complain_at (loc, _("only one %s allowed per rule"), "%dprec");
current_rule->dprec = dprec;
}
@@ -361,38 +359,38 @@ grammar_current_rule_dprec_set (int dpre
rule. */
void
-grammar_current_rule_merge_set (struniq_t name, location_t location)
+grammar_current_rule_merge_set (uniqstr name, location loc)
{
if (! glr_parser)
- warn_at (location, _("%s affects only GLR parsers"), "%merge");
+ warn_at (loc, _("%s affects only GLR parsers"), "%merge");
if (current_rule->merger != 0)
- complain_at (location, _("only one %s allowed per rule"), "%merge");
+ complain_at (loc, _("only one %s allowed per rule"), "%merge");
current_rule->merger =
- get_merge_function (name, current_rule->sym->type_name, location);
+ get_merge_function (name, current_rule->sym->type_name, loc);
}
-/* Attach a SYMBOL to the current rule. If needed, move the previous
+/* Attach SYM to the current rule. If needed, move the previous
action as a mid-rule action. */
void
-grammar_current_rule_symbol_append (symbol_t *symbol, location_t location)
+grammar_current_rule_symbol_append (symbol *sym, location loc)
{
if (current_rule->action)
grammar_midrule_action ();
++nritems;
- grammar_symbol_append (symbol, location);
+ grammar_symbol_append (sym, loc);
}
/* Attach an ACTION to the current rule. If needed, move the previous
action as a mid-rule action. */
void
-grammar_current_rule_action_append (const char *action, location_t location)
+grammar_current_rule_action_append (const char *action, location loc)
{
if (current_rule->action)
grammar_midrule_action ();
current_rule->action = action;
- current_rule->action_location = location;
+ current_rule->action_location = loc;
}
@@ -405,15 +403,15 @@ static void
packgram (void)
{
unsigned int itemno = 0;
- rule_number_t ruleno = 0;
- symbol_list_t *p = grammar;
+ rule_number ruleno = 0;
+ symbol_list *p = grammar;
- ritem = XCALLOC (item_number_t, nritems);
- rules = XCALLOC (rule_t, nrules);
+ ritem = XCALLOC (item_number, nritems);
+ rules = XCALLOC (rule, nrules);
while (p)
{
- symbol_t *ruleprec = p->ruleprec;
+ symbol *ruleprec = p->ruleprec;
rules[ruleno].user_number = ruleno;
rules[ruleno].number = ruleno;
rules[ruleno].lhs = p->sym;
@@ -428,7 +426,7 @@ packgram (void)
p = p->next;
while (p && p->sym)
{
- /* item_number_t = symbol_number_t.
+ /* item_number = symbol_number.
But the former needs to contain more: negative rule numbers. */
ritem[itemno++] = symbol_number_as_item_number (p->sym->number);
/* A rule gets by default the precedence and associativity
@@ -528,7 +526,7 @@ reader (void)
accept: %start EOF. */
{
- symbol_list_t *p = symbol_list_new (accept, empty_location);
+ symbol_list *p = symbol_list_new (accept, empty_location);
p->location = grammar->location;
p->next = symbol_list_new (startsymbol, empty_location);
p->next->next = symbol_list_new (endtoken, empty_location);
@@ -539,7 +537,7 @@ reader (void)
grammar = p;
}
- if (! (nsyms <= SYMBOL_NUMBER_MAX && nsyms == ntokens + nvars))
+ if (! (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars))
abort ();
xfclose (finput);
@@ -551,6 +549,6 @@ reader (void)
/* Convert the grammar into the format described in gram.h. */
packgram ();
- /* The grammar as a symbol_list_t is no longer needed. */
- LIST_FREE (symbol_list_t, grammar);
+ /* The grammar as a symbol_list is no longer needed. */
+ LIST_FREE (symbol_list, grammar);
}
Index: src/reader.h
===================================================================
RCS file: /cvsroot/bison/bison/src/reader.h,v
retrieving revision 1.34
diff -p -u -r1.34 reader.h
--- src/reader.h 7 Dec 2002 06:11:11 -0000 1.34
+++ src/reader.h 11 Dec 2002 05:09:24 -0000
@@ -23,15 +23,15 @@
# include "location.h"
# include "symlist.h"
+
# include "parse-gram.h"
typedef struct merger_list
{
struct merger_list* next;
- struniq_t name;
- struniq_t type;
-}
-merger_list;
+ uniqstr name;
+ uniqstr type;
+} merger_list;
/* From the scanner. */
extern FILE *gram_in;
@@ -41,7 +41,7 @@ void scanner_initialize (void);
void scanner_free (void);
void scanner_last_string_free (void);
-# define YY_DECL int gram_lex (yystype *val, location_t *loc)
+# define YY_DECL int gram_lex (yystype *val, location *loc)
YY_DECL;
@@ -50,32 +50,32 @@ extern int gram_debug;
int gram_parse (void);
/* The sort of braced code we are in. */
-typedef enum braced_code_e
+typedef enum
{
action_braced_code,
destructor_braced_code,
printer_braced_code
- } braced_code_t;
+ } braced_code;
/* FIXME: This is really a dirty hack which demonstrates that we
should probably not try to parse the actions now. */
-extern braced_code_t current_braced_code;
+extern braced_code current_braced_code;
/* From reader.c. */
-void grammar_start_symbol_set (symbol_t *s, location_t l);
-void prologue_augment (const char *prologue, location_t location);
-void epilogue_augment (const char *epilogue, location_t location);
-void grammar_symbol_append (symbol_t *s, location_t l);
-void grammar_rule_begin (symbol_t *lhs, location_t l);
-void grammar_rule_end (location_t l);
+void grammar_start_symbol_set (symbol *s, location loc);
+void prologue_augment (const char *prologue, location loc);
+void epilogue_augment (const char *epilogue, location loc);
+void grammar_symbol_append (symbol *s, location loc);
+void grammar_rule_begin (symbol *lhs, location loc);
+void grammar_rule_end (location loc);
void grammar_midrule_action (void);
-void grammar_current_rule_prec_set (symbol_t *precsym, location_t l);
-void grammar_current_rule_dprec_set (int dprec, location_t l);
-void grammar_current_rule_merge_set (struniq_t name, location_t l);
-
-void grammar_current_rule_symbol_append (symbol_t *symbol, location_t l);
-void grammar_current_rule_action_append (const char *action, location_t l);
-extern symbol_list_t *current_rule;
+void grammar_current_rule_prec_set (symbol *precsym, location loc);
+void grammar_current_rule_dprec_set (int dprec, location loc);
+void grammar_current_rule_merge_set (uniqstr name, location loc);
+
+void grammar_current_rule_symbol_append (symbol *sym, location loc);
+void grammar_current_rule_action_append (const char *action, location loc);
+extern symbol_list *current_rule;
void reader (void);
void free_merger_functions (void);
Index: src/reduce.c
===================================================================
RCS file: /cvsroot/bison/bison/src/reduce.c,v
retrieving revision 1.78
diff -p -u -r1.78 reduce.c
--- src/reduce.c 7 Dec 2002 06:12:48 -0000 1.78
+++ src/reduce.c 11 Dec 2002 05:09:24 -0000
@@ -26,16 +26,17 @@
user's parser. */
#include "system.h"
-#include "quotearg.h"
-#include "getargs.h"
+
+#include <bitset.h>
+#include <quotearg.h>
+
+#include "complain.h"
#include "files.h"
-#include "symtab.h"
+#include "getargs.h"
#include "gram.h"
-#include "complain.h"
-#include "reduce.h"
#include "reader.h"
-#include "getargs.h"
-#include "bitset.h"
+#include "reduce.h"
+#include "symtab.h"
/* Set of all nonterminals which are not useless. */
static bitset N;
@@ -50,10 +51,10 @@ static bitset V;
`useless', but no warning should be issued). */
static bitset V1;
-static rule_number_t nuseful_productions;
-rule_number_t nuseless_productions;
+static rule_number nuseful_productions;
+rule_number nuseless_productions;
static int nuseful_nonterminals;
-symbol_number_t nuseless_nonterminals;
+symbol_number nuseless_nonterminals;
/*-------------------------------------------------------------------.
| Another way to do this would be with a set for each production and |
@@ -62,9 +63,9 @@ symbol_number_t nuseless_nonterminals;
`-------------------------------------------------------------------*/
static bool
-useful_production (rule_number_t r, bitset N0)
+useful_production (rule_number r, bitset N0)
{
- item_number_t *rhsp;
+ item_number *rhsp;
/* A production is useful if all of the nonterminals in its appear
in the set of useful nonterminals. */
@@ -84,7 +85,7 @@ static void
useless_nonterminals (void)
{
bitset Np, Ns;
- rule_number_t r;
+ rule_number r;
/* N is set as built. Np is set being built this iteration. P is
set of all productions which have a RHS all in N. */
@@ -167,7 +168,7 @@ inaccessable_symbols (void)
while (1)
{
- rule_number_t r;
+ rule_number r;
bitset_copy (Vp, V);
for (r = 0; r < nrules; r++)
{
@@ -175,7 +176,7 @@ inaccessable_symbols (void)
&& bitset_test (P, r)
&& bitset_test (V, rules[r].lhs->number))
{
- item_number_t *rhsp;
+ item_number *rhsp;
for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
if (ISTOKEN (*rhsp) || bitset_test (N, *rhsp - ntokens))
bitset_set (Vp, *rhsp);
@@ -206,7 +207,7 @@ inaccessable_symbols (void)
nuseful_nonterminals = 0;
{
- symbol_number_t i;
+ symbol_number i;
for (i = ntokens; i < nsyms; i++)
if (bitset_test (V, i))
nuseful_nonterminals++;
@@ -215,7 +216,7 @@ inaccessable_symbols (void)
/* A token that was used in %prec should not be warned about. */
{
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules; ++r)
if (rules[r].precsym != 0)
bitset_set (V1, rules[r].precsym->number);
@@ -233,7 +234,7 @@ reduce_grammar_tables (void)
{
/* Report and flag useless productions. */
{
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules; r++)
rules[r].useful = bitset_test (P, r);
grammar_rules_never_reduced_report (_("useless rule"));
@@ -244,8 +245,8 @@ reduce_grammar_tables (void)
{
int useful = 0;
int useless = nrules - nuseless_productions;
- rule_t *rules_sorted = XMALLOC (rule_t, nrules);
- rule_number_t r;
+ rule *rules_sorted = XMALLOC (rule, nrules);
+ rule_number r;
for (r = 0; r < nrules; ++r)
rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r];
free (rules);
@@ -254,7 +255,7 @@ reduce_grammar_tables (void)
/* Renumber the rules markers in RITEMS. */
for (r = 0; r < nrules; ++r)
{
- item_number_t *rhsp = rules[r].rhs;
+ item_number *rhsp = rules[r].rhs;
for (/* Nothing. */; *rhsp >= 0; ++rhsp)
/* Nothing. */;
*rhsp = rule_number_as_item_number (r);
@@ -283,12 +284,12 @@ reduce_grammar_tables (void)
static void
nonterminals_reduce (void)
{
- symbol_number_t i, n;
+ symbol_number i, n;
/* Map the nonterminals to their new index: useful first, useless
afterwards. Kept for later report. */
- symbol_number_t *nontermmap = XCALLOC (symbol_number_t, nvars) - ntokens;
+ symbol_number *nontermmap = XCALLOC (symbol_number, nvars) - ntokens;
n = ntokens;
for (i = ntokens; i < nsyms; i++)
if (bitset_test (V, i))
@@ -304,7 +305,7 @@ nonterminals_reduce (void)
/* Shuffle elements of tables indexed by symbol number. */
{
- symbol_t **symbols_sorted = XMALLOC (symbol_t *, nvars) - ntokens;
+ symbol **symbols_sorted = XMALLOC (symbol *, nvars) - ntokens;
for (i = ntokens; i < nsyms; i++)
symbols[i]->number = nontermmap[i];
@@ -316,10 +317,10 @@ nonterminals_reduce (void)
}
{
- rule_number_t r;
+ rule_number r;
for (r = 0; r < nrules; ++r)
{
- item_number_t *rhsp;
+ item_number *rhsp;
for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
if (ISVAR (*rhsp))
*rhsp = symbol_number_as_item_number (nontermmap[*rhsp]);
Index: src/reduce.h
===================================================================
RCS file: /cvsroot/bison/bison/src/reduce.h,v
retrieving revision 1.7
diff -p -u -r1.7 reduce.h
--- src/reduce.h 21 Oct 2002 05:30:50 -0000 1.7
+++ src/reduce.h 11 Dec 2002 05:09:24 -0000
@@ -25,6 +25,6 @@ void reduce_grammar (void);
void reduce_output (FILE *out);
void reduce_free (void);
-extern symbol_number_t nuseless_nonterminals;
-extern rule_number_t nuseless_productions;
+extern symbol_number nuseless_nonterminals;
+extern rule_number nuseless_productions;
#endif /* !REDUCE_H_ */
Index: src/relation.c
===================================================================
RCS file: /cvsroot/bison/bison/src/relation.c,v
retrieving revision 1.4
diff -p -u -r1.4 relation.c
--- src/relation.c 4 Sep 2002 10:18:15 -0000 1.4
+++ src/relation.c 11 Dec 2002 05:09:24 -0000
@@ -1,5 +1,5 @@
/* Binary relations.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
@@ -19,21 +19,23 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
-#include "bitsetv.h"
-#include "relation.h"
+
+#include <bitsetv.h>
+
#include "getargs.h"
+#include "relation.h"
void
-relation_print (relation_t relation, size_t size, FILE *out)
+relation_print (relation r, size_t size, FILE *out)
{
unsigned i, j;
for (i = 0; i < size; ++i)
{
fprintf (out, "%3d: ", i);
- if (relation[i])
- for (j = 0; relation[i][j] != -1; ++j)
- fprintf (out, "%3d ", relation[i][j]);
+ if (r[i])
+ for (j = 0; r[i][j] != -1; ++j)
+ fprintf (out, "%3d ", r[i][j]);
fputc ('\n', out);
}
fputc ('\n', out);
@@ -47,9 +49,9 @@ relation_print (relation_t relation, siz
| two. |
`---------------------------------------------------------------*/
-static relation_t R;
-static relation_nodes_t INDEX;
-static relation_nodes_t VERTICES;
+static relation R;
+static relation_nodes INDEX;
+static relation_nodes VERTICES;
static int top;
static int infinity;
static bitsetv F;
@@ -90,17 +92,16 @@ traverse (int i)
void
-relation_digraph (relation_t relation, size_t size,
- bitsetv *function)
+relation_digraph (relation r, size_t size, bitsetv *function)
{
unsigned i;
infinity = size + 2;
- INDEX = XCALLOC (relation_node_t, size + 1);
- VERTICES = XCALLOC (relation_node_t, size + 1);
+ INDEX = XCALLOC (relation_node, size + 1);
+ VERTICES = XCALLOC (relation_node, size + 1);
top = 0;
- R = relation;
+ R = r;
F = *function;
for (i = 0; i < size; i++)
@@ -122,12 +123,12 @@ relation_digraph (relation_t relation, s
`-------------------------------------------*/
void
-relation_transpose (relation_t *R_arg, int n)
+relation_transpose (relation *R_arg, int n)
{
/* The result. */
- relation_t new_R = XCALLOC (relation_nodes_t, n);
+ relation new_R = XCALLOC (relation_nodes, n);
/* END_R[I] -- next entry of NEW_R[I]. */
- relation_t end_R = XCALLOC (relation_nodes_t, n);
+ relation end_R = XCALLOC (relation_nodes, n);
/* NEDGES[I] -- total size of NEW_R[I]. */
int *nedges = XCALLOC (int, n);
int i, j;
@@ -148,7 +149,7 @@ relation_transpose (relation_t *R_arg, i
for (i = 0; i < n; i++)
if (nedges[i] > 0)
{
- relation_node_t *sp = XCALLOC (relation_node_t, nedges[i] + 1);
+ relation_node *sp = XCALLOC (relation_node, nedges[i] + 1);
sp[nedges[i]] = -1;
new_R[i] = sp;
end_R[i] = sp;
Index: src/relation.h
===================================================================
RCS file: /cvsroot/bison/bison/src/relation.h,v
retrieving revision 1.2
diff -p -u -r1.2 relation.h
--- src/relation.h 21 Oct 2002 05:30:50 -0000 1.2
+++ src/relation.h 11 Dec 2002 05:09:24 -0000
@@ -1,5 +1,5 @@
/* Binary relations.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
@@ -24,25 +24,25 @@
/* Performing operations on graphs coded as list of adjacency.
- If GRAPH is a relation_t, then GRAPH[Node] is a list of adjacent
+ If GRAPH is a relation, then GRAPH[Node] is a list of adjacent
nodes, ended with -1. */
-typedef short relation_node_t;
-typedef relation_node_t *relation_nodes_t;
-typedef relation_nodes_t *relation_t;
+typedef short relation_node;
+typedef relation_node *relation_nodes;
+typedef relation_nodes *relation;
-/* Report a RELATION that has SIZE vertices. */
-void relation_print (relation_t relatio, size_t size, FILE *out);
+/* Report a relation R that has SIZE vertices. */
+void relation_print (relation r, size_t size, FILE *out);
-/* Compute the transitive closure of the FUNCTION on the RELATION with
- SIZE vertices.
+/* Compute the transitive closure of the FUNCTION on the relation R
+ with SIZE vertices.
- If RELATION (NODE-1, NODE-2) then on exit FUNCTION[NODE-1] was
- extended (unioned) with FUNCTION[NODE-2]. */
-void relation_digraph (relation_t relation, size_t size, bitsetv *function);
+ If R (NODE-1, NODE-2) then on exit FUNCTION[NODE - 1] was extended
+ (unioned) with FUNCTION[NODE - 2]. */
+void relation_digraph (relation r, size_t size, bitsetv *function);
/* Destructively transpose *R_ARG, of size N. */
-void relation_transpose (relation_t *R_arg, int n);
+void relation_transpose (relation *R_arg, int n);
#endif /* ! RELATION_H_ */
Index: src/scan-gram.l
===================================================================
RCS file: /cvsroot/bison/bison/src/scan-gram.l,v
retrieving revision 1.48
diff -p -u -r1.48 scan-gram.l
--- src/scan-gram.l 7 Dec 2002 06:14:27 -0000 1.48
+++ src/scan-gram.l 11 Dec 2002 05:09:24 -0000
@@ -24,14 +24,17 @@
%{
#include "system.h"
-#include "mbswidth.h"
+
+#include <mbswidth.h>
+#include <get-errno.h>
+#include <quote.h>
+
#include "complain.h"
#include "files.h"
-#include "quote.h"
-#include "struniq.h"
#include "getargs.h"
#include "gram.h"
#include "reader.h"
+#include "uniqstr.h"
#define YY_USER_INIT \
do \
@@ -45,14 +48,14 @@
/* Location of scanner cursor. */
boundary scanner_cursor;
-static void adjust_location (location_t *, char const *, size_t);
+static void adjust_location (location *, char const *, size_t);
#define YY_USER_ACTION adjust_location (loc, yytext, yyleng);
static size_t no_cr_read (FILE *, char *, size_t);
#define YY_INPUT(buf, result, size) ((result) = no_cr_read (yyin, buf, size))
-/* STRING_OBSTACK -- Used to store all the characters that we need to
+/* OBSTACK_FOR_STRING -- Used to store all the characters that we need to
keep (to construct ID, STRINGS etc.). Use the following macros to
use it.
@@ -61,23 +64,23 @@ static size_t no_cr_read (FILE *, char *
STRING_FINISH also stores this string in LAST_STRING, which can be
used, and which is used by STRING_FREE to free the last string. */
-static struct obstack string_obstack;
+static struct obstack obstack_for_string;
/* A string representing the most recently saved token. */
static char *last_string;
#define STRING_GROW \
- obstack_grow (&string_obstack, yytext, yyleng)
+ obstack_grow (&obstack_for_string, yytext, yyleng)
#define STRING_FINISH \
do { \
- obstack_1grow (&string_obstack, '\0'); \
- last_string = obstack_finish (&string_obstack); \
+ obstack_1grow (&obstack_for_string, '\0'); \
+ last_string = obstack_finish (&obstack_for_string); \
} while (0)
#define STRING_FREE \
- obstack_free (&string_obstack, last_string)
+ obstack_free (&obstack_for_string, last_string)
void
scanner_last_string_free (void)
@@ -93,10 +96,8 @@ scanner_last_string_free (void)
Outside of well-formed rules, RULE_LENGTH has an undefined value. */
static int rule_length;
-static void handle_dollar (braced_code_t code_kind,
- char *cp, location_t location);
-static void handle_at (braced_code_t code_kind,
- char *cp, location_t location);
+static void handle_dollar (braced_code code_kind, char *cp, location loc);
+static void handle_at (braced_code code_kind, char *cp, location loc);
static void handle_syncline (char *args);
static int convert_ucn_to_byte (char const *hex_text);
static void unexpected_end_of_file (boundary, char const *);
@@ -131,13 +132,13 @@ splice (\\[ \f\t\v]*\n)*
int context_state IF_LINT (= 0);
/* Location of most recent identifier, when applicable. */
- location_t id_loc IF_LINT (= *loc);
+ location id_loc IF_LINT (= *loc);
- /* Location where containing code started, when applicable. */
+ /* Where containing code started, when applicable. */
boundary code_start IF_LINT (= loc->start);
- /* Location where containing comment or string or character literal
- started, when applicable. */
+ /* Where containing comment or string or character literal started,
+ when applicable. */
boundary token_start IF_LINT (= loc->start);
%}
@@ -223,9 +224,9 @@ splice (\\[ \f\t\v]*\n)*
{int} {
unsigned long num;
- errno = 0;
+ set_errno (0);
num = strtoul (yytext, 0, 10);
- if (INT_MAX < num || errno)
+ if (INT_MAX < num || get_errno ())
{
complain_at (*loc, _("integer out of range: %s"), quote (yytext));
num = INT_MAX;
@@ -253,9 +254,9 @@ splice (\\[ \f\t\v]*\n)*
/* A type. */
"<"{tag}">" {
- obstack_grow (&string_obstack, yytext + 1, yyleng - 2);
+ obstack_grow (&obstack_for_string, yytext + 1, yyleng - 2);
STRING_FINISH;
- val->struniq = struniq_new (last_string);
+ val->uniqstr = uniqstr_new (last_string);
STRING_FREE;
return TYPE;
}
@@ -349,7 +350,7 @@ splice (\\[ \f\t\v]*\n)*
STRING_GROW;
STRING_FINISH;
loc->start = token_start;
- val->string = last_string;
+ val->chars = last_string;
rule_length++;
BEGIN INITIAL;
return STRING;
@@ -396,36 +397,36 @@ splice (\\[ \f\t\v]*\n)*
if (UCHAR_MAX < c)
complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
else
- obstack_1grow (&string_obstack, c);
+ obstack_1grow (&obstack_for_string, c);
}
\\x[0-9abcdefABCDEF]+ {
unsigned long c;
- errno = 0;
+ set_errno (0);
c = strtoul (yytext + 2, 0, 16);
- if (UCHAR_MAX < c || errno)
+ if (UCHAR_MAX < c || get_errno ())
complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
else
- obstack_1grow (&string_obstack, c);
+ obstack_1grow (&obstack_for_string, c);
}
- \\a obstack_1grow (&string_obstack, '\a');
- \\b obstack_1grow (&string_obstack, '\b');
- \\f obstack_1grow (&string_obstack, '\f');
- \\n obstack_1grow (&string_obstack, '\n');
- \\r obstack_1grow (&string_obstack, '\r');
- \\t obstack_1grow (&string_obstack, '\t');
- \\v obstack_1grow (&string_obstack, '\v');
+ \\a obstack_1grow (&obstack_for_string, '\a');
+ \\b obstack_1grow (&obstack_for_string, '\b');
+ \\f obstack_1grow (&obstack_for_string, '\f');
+ \\n obstack_1grow (&obstack_for_string, '\n');
+ \\r obstack_1grow (&obstack_for_string, '\r');
+ \\t obstack_1grow (&obstack_for_string, '\t');
+ \\v obstack_1grow (&obstack_for_string, '\v');
/* \\[\"\'?\\] would be shorter, but it confuses xgettext. */
- \\("\""|"'"|"?"|"\\") obstack_1grow (&string_obstack, yytext[1]);
+ \\("\""|"'"|"?"|"\\") obstack_1grow (&obstack_for_string, yytext[1]);
\\(u|U[0-9abcdefABCDEF]{4})[0-9abcdefABCDEF]{4} {
int c = convert_ucn_to_byte (yytext);
if (c < 0)
complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
else
- obstack_1grow (&string_obstack, c);
+ obstack_1grow (&obstack_for_string, c);
}
\\(.|\n) {
complain_at (*loc, _("unrecognized escape sequence: %s"), quote (yytext));
@@ -508,7 +509,7 @@ splice (\\[ \f\t\v]*\n)*
{
STRING_FINISH;
loc->start = code_start;
- val->string = last_string;
+ val->chars = last_string;
rule_length++;
BEGIN INITIAL;
return BRACED_CODE;
@@ -537,7 +538,7 @@ splice (\\[ \f\t\v]*\n)*
"%}" {
STRING_FINISH;
loc->start = code_start;
- val->string = last_string;
+ val->chars = last_string;
BEGIN INITIAL;
return PROLOGUE;
}
@@ -556,7 +557,7 @@ splice (\\[ \f\t\v]*\n)*
<<EOF>> {
STRING_FINISH;
loc->start = code_start;
- val->string = last_string;
+ val->chars = last_string;
BEGIN INITIAL;
return EPILOGUE;
}
@@ -570,10 +571,10 @@ splice (\\[ \f\t\v]*\n)*
<SC_COMMENT,SC_LINE_COMMENT,SC_STRING,SC_CHARACTER,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>
{
- \$ obstack_sgrow (&string_obstack, "$][");
- \@ obstack_sgrow (&string_obstack, "@@");
- \[ obstack_sgrow (&string_obstack, "@{");
- \] obstack_sgrow (&string_obstack, "@}");
+ \$ obstack_sgrow (&obstack_for_string, "$][");
+ \@ obstack_sgrow (&obstack_for_string, "@@");
+ \[ obstack_sgrow (&obstack_for_string, "@{");
+ \] obstack_sgrow (&obstack_for_string, "@}");
.|\n STRING_GROW;
}
@@ -584,7 +585,7 @@ splice (\\[ \f\t\v]*\n)*
size SIZE. */
static void
-adjust_location (location_t *loc, char const *token, size_t size)
+adjust_location (location *loc, char const *token, size_t size)
{
int line = scanner_cursor.line;
int column = scanner_cursor.column;
@@ -669,11 +670,11 @@ no_cr_read (FILE *fp, char *buf, size_t
| |
| Possible inputs: $[<TYPENAME>]($|integer) |
| |
-| Output to the STRING_OBSTACK a reference to this semantic value. |
+| Output to OBSTACK_FOR_STRING a reference to this semantic value. |
`------------------------------------------------------------------*/
static inline void
-handle_action_dollar (char *text, location_t location)
+handle_action_dollar (char *text, location loc)
{
const char *type_name = NULL;
char *cp = text + 1;
@@ -691,38 +692,37 @@ handle_action_dollar (char *text, locati
if (*cp == '$')
{
if (!type_name)
- type_name = symbol_list_n_type_name_get (current_rule, location, 0);
+ type_name = symbol_list_n_type_name_get (current_rule, loc, 0);
if (!type_name && typed)
- complain_at (location, _("$$ of `%s' has no declared type"),
+ complain_at (loc, _("$$ of `%s' has no declared type"),
current_rule->sym->tag);
if (!type_name)
type_name = "";
- obstack_fgrow1 (&string_obstack,
+ obstack_fgrow1 (&obstack_for_string,
"]b4_lhs_value([%s])[", type_name);
}
else
{
long num;
- errno = 0;
+ set_errno (0);
num = strtol (cp, 0, 10);
- if (INT_MIN <= num && num <= rule_length && ! errno)
+ if (INT_MIN <= num && num <= rule_length && ! get_errno ())
{
int n = num;
if (!type_name && n > 0)
- type_name = symbol_list_n_type_name_get (current_rule, location,
- n);
+ type_name = symbol_list_n_type_name_get (current_rule, loc, n);
if (!type_name && typed)
- complain_at (location, _("$%d of `%s' has no declared type"),
- n, current_rule->sym->tag);
+ complain_at (loc, _("$%d of `%s' has no declared type"),
+ n, current_rule->sym->tag);
if (!type_name)
type_name = "";
- obstack_fgrow3 (&string_obstack,
+ obstack_fgrow3 (&obstack_for_string,
"]b4_rhs_value([%d], [%d], [%s])[",
rule_length, n, type_name);
}
else
- complain_at (location, _("integer out of range: %s"), quote (text));
+ complain_at (loc, _("integer out of range: %s"), quote (text));
}
}
@@ -733,13 +733,13 @@ handle_action_dollar (char *text, locati
`---------------------------------------------------------------*/
static inline void
-handle_symbol_code_dollar (char *text, location_t location)
+handle_symbol_code_dollar (char *text, location loc)
{
char *cp = text + 1;
if (*cp == '$')
- obstack_sgrow (&string_obstack, "]b4_dollar_dollar[");
+ obstack_sgrow (&obstack_for_string, "]b4_dollar_dollar[");
else
- complain_at (location, _("invalid value: %s"), quote (text));
+ complain_at (loc, _("invalid value: %s"), quote (text));
}
@@ -749,18 +749,17 @@ handle_symbol_code_dollar (char *text, l
`-----------------------------------------------------------------*/
static void
-handle_dollar (braced_code_t braced_code_kind,
- char *text, location_t location)
+handle_dollar (braced_code braced_code_kind, char *text, location loc)
{
switch (braced_code_kind)
{
case action_braced_code:
- handle_action_dollar (text, location);
+ handle_action_dollar (text, loc);
break;
case destructor_braced_code:
case printer_braced_code:
- handle_symbol_code_dollar (text, location);
+ handle_symbol_code_dollar (text, loc);
break;
}
}
@@ -768,33 +767,33 @@ handle_dollar (braced_code_t braced_code
/*------------------------------------------------------.
| TEXT is a location token (i.e., a address@hidden'). Output to |
-| STRING_OBSTACK a reference to this location. |
+| OBSTACK_FOR_STRING a reference to this location. |
`------------------------------------------------------*/
static inline void
-handle_action_at (char *text, location_t location)
+handle_action_at (char *text, location loc)
{
char *cp = text + 1;
locations_flag = 1;
if (*cp == '$')
{
- obstack_sgrow (&string_obstack, "]b4_lhs_location[");
+ obstack_sgrow (&obstack_for_string, "]b4_lhs_location[");
}
else
{
long num;
- errno = 0;
+ set_errno (0);
num = strtol (cp, 0, 10);
- if (INT_MIN <= num && num <= rule_length && ! errno)
+ if (INT_MIN <= num && num <= rule_length && ! get_errno ())
{
int n = num;
- obstack_fgrow2 (&string_obstack, "]b4_rhs_location([%d], [%d])[",
+ obstack_fgrow2 (&obstack_for_string, "]b4_rhs_location([%d], [%d])[",
rule_length, n);
}
else
- complain_at (location, _("integer out of range: %s"), quote (text));
+ complain_at (loc, _("integer out of range: %s"), quote (text));
}
}
@@ -805,13 +804,13 @@ handle_action_at (char *text, location_t
`---------------------------------------------------------------*/
static inline void
-handle_symbol_code_at (char *text, location_t location)
+handle_symbol_code_at (char *text, location loc)
{
char *cp = text + 1;
if (*cp == '$')
- obstack_sgrow (&string_obstack, "]b4_at_dollar[");
+ obstack_sgrow (&obstack_for_string, "]b4_at_dollar[");
else
- complain_at (location, _("invalid value: %s"), quote (text));
+ complain_at (loc, _("invalid value: %s"), quote (text));
}
@@ -821,18 +820,17 @@ handle_symbol_code_at (char *text, locat
`-------------------------------------------------------------------*/
static void
-handle_at (braced_code_t braced_code_kind,
- char *text, location_t location)
+handle_at (braced_code braced_code_kind, char *text, location loc)
{
switch (braced_code_kind)
{
case action_braced_code:
- handle_action_at (text, location);
+ handle_action_at (text, loc);
break;
case destructor_braced_code:
case printer_braced_code:
- handle_symbol_code_at (text, location);
+ handle_symbol_code_at (text, loc);
break;
}
}
@@ -922,10 +920,10 @@ unexpected_end_of_file (boundary start,
{
size_t i = strlen (token_end);
- location_t location;
- location.start = start;
- location.end = scanner_cursor;
- complain_at (location, _("missing `%s' at end of file"), token_end);
+ location loc;
+ loc.start = start;
+ loc.end = scanner_cursor;
+ complain_at (loc, _("missing `%s' at end of file"), token_end);
/* Adjust scanner cursor so that any later message does not count
the characters about to be inserted. */
@@ -943,7 +941,7 @@ unexpected_end_of_file (boundary start,
void
scanner_initialize (void)
{
- obstack_init (&string_obstack);
+ obstack_init (&obstack_for_string);
}
@@ -954,7 +952,7 @@ scanner_initialize (void)
void
scanner_free (void)
{
- obstack_free (&string_obstack, 0);
+ obstack_free (&obstack_for_string, 0);
/* Reclaim Flex's buffers. */
yy_delete_buffer (YY_CURRENT_BUFFER);
}
Index: src/scan-skel.l
===================================================================
RCS file: /cvsroot/bison/bison/src/scan-skel.l,v
retrieving revision 1.18
diff -p -u -r1.18 scan-skel.l
--- src/scan-skel.l 16 Nov 2002 12:31:36 -0000 1.18
+++ src/scan-skel.l 11 Dec 2002 05:09:24 -0000
@@ -23,8 +23,10 @@
%{
#include "system.h"
-#include "quotearg.h"
-#include "error.h"
+
+#include <error.h>
+#include <quotearg.h>
+
#include "getargs.h"
#include "files.h"
Index: src/state.c
===================================================================
RCS file: /cvsroot/bison/bison/src/state.c,v
retrieving revision 1.26
diff -p -u -r1.26 state.c
--- src/state.c 21 Nov 2002 05:21:35 -0000 1.26
+++ src/state.c 11 Dec 2002 05:09:24 -0000
@@ -20,7 +20,9 @@
#include "system.h"
-#include "hash.h"
+
+#include <hash.h>
+
#include "complain.h"
#include "gram.h"
#include "state.h"
@@ -36,13 +38,14 @@
`---------------------------------------*/
#define TRANSITIONS_ALLOC(Num) \
- (transitions_t *) xcalloc ((sizeof (transitions_t) \
- + (Num - 1) * sizeof (state_t *)), 1)
+ (transitions *) xcalloc ((sizeof (transitions) \
+ + (Num - 1) * sizeof (state *)), \
+ 1)
-static transitions_t *
-transitions_new (int num, state_t **the_states)
+static transitions *
+transitions_new (int num, state **the_states)
{
- transitions_t *res = TRANSITIONS_ALLOC (num);
+ transitions *res = TRANSITIONS_ALLOC (num);
res->num = num;
memcpy (res->states, the_states, num * sizeof (the_states[0]));
return res;
@@ -51,11 +54,11 @@ transitions_new (int num, state_t **the_
/*-------------------------------------------------------------------.
| Return the state such these TRANSITIONS contain a shift/goto to it |
-| on SYMBOL. Aborts if none found. |
+| on S. Abort if none found. |
`-------------------------------------------------------------------*/
-state_t *
-transitions_to (transitions_t *shifts, symbol_number_t s)
+state *
+transitions_to (transitions *shifts, symbol_number s)
{
int j;
for (j = 0; j < shifts->num; j++)
@@ -74,15 +77,14 @@ transitions_to (transitions_t *shifts, s
| Create a new array of N errs. |
`-------------------------------*/
-#define ERRS_ALLOC(Nerrs) \
- (errs_t *) xcalloc ((sizeof (errs_t) \
- + (Nerrs - 1) * sizeof (symbol_t *)), 1)
+#define ERRS_ALLOC(Nerrs) \
+ ((errs *) xcalloc ((sizeof (errs) + (Nerrs - 1) * sizeof (symbol *)), 1))
-errs_t *
-errs_new (int num, symbol_t **tokens)
+errs *
+errs_new (int num, symbol **tokens)
{
- errs_t *res = ERRS_ALLOC (num);
+ errs *res = ERRS_ALLOC (num);
res->num = num;
memcpy (res->symbols, tokens, num * sizeof (tokens[0]));
return res;
@@ -101,15 +103,15 @@ errs_new (int num, symbol_t **tokens)
`-------------------------------------*/
#define REDUCTIONS_ALLOC(Nreductions) \
- (reductions_t *) xcalloc ((sizeof (reductions_t) \
- + (Nreductions - 1) * sizeof (rule_t *)), 1)
+ (reductions *) xcalloc ((sizeof (reductions) \
+ + (Nreductions - 1) * sizeof (rule *)), 1)
-static reductions_t *
-reductions_new (int num, rule_t **reductions)
+static reductions *
+reductions_new (int num, rule **reds)
{
- reductions_t *res = REDUCTIONS_ALLOC (num);
+ reductions *res = REDUCTIONS_ALLOC (num);
res->num = num;
- memcpy (res->rules, reductions, num * sizeof (reductions[0]));
+ memcpy (res->rules, reds, num * sizeof (reds[0]));
res->lookaheads = NULL;
return res;
}
@@ -121,27 +123,28 @@ reductions_new (int num, rule_t **reduct
`---------*/
-state_number_t nstates = 0;
+state_number nstates = 0;
/* FINAL_STATE is properly set by new_state when it recognizes its
accessing symbol: $end. */
-state_t *final_state = NULL;
+state *final_state = NULL;
#define STATE_ALLOC(Nitems) \
- (state_t *) xcalloc ((sizeof (state_t) \
- + (Nitems - 1) * sizeof (item_number_t)), 1)
+ (state *) xcalloc ((sizeof (state) \
+ + (Nitems - 1) * sizeof (item_number)), \
+ 1)
/*------------------------------------------------------------------.
| Create a new state with ACCESSING_SYMBOL, for those items. Store |
| it in the state hash table. |
`------------------------------------------------------------------*/
-state_t *
-state_new (symbol_number_t accessing_symbol,
- size_t core_size, item_number_t *core)
+state *
+state_new (symbol_number accessing_symbol,
+ size_t core_size, item_number *core)
{
- state_t *res;
+ state *res;
- if (STATE_NUMBER_MAX <= nstates)
+ if (STATE_NUMBER_MAXIMUM <= nstates)
abort ();
res = STATE_ALLOC (core_size);
@@ -159,83 +162,83 @@ state_new (symbol_number_t accessing_sym
}
-/*-------------.
-| Free STATE. |
-`-------------*/
+/*---------.
+| Free S. |
+`---------*/
static void
-state_free (state_t *state)
+state_free (state *s)
{
- free (state->transitions);
- free (state->reductions);
- free (state->errs);
- free (state);
+ free (s->transitions);
+ free (s->reductions);
+ free (s->errs);
+ free (s);
}
-/*-------------------------------.
-| Set the transitions of STATE. |
-`-------------------------------*/
+/*---------------------------.
+| Set the transitions of S. |
+`---------------------------*/
void
-state_transitions_set (state_t *state, int num, state_t **transitions)
+state_transitions_set (state *s, int num, state **trans)
{
- if (state->transitions)
+ if (s->transitions)
abort ();
- state->transitions = transitions_new (num, transitions);
+ s->transitions = transitions_new (num, trans);
}
-/*------------------------------.
-| Set the reductions of STATE. |
-`------------------------------*/
+/*--------------------------.
+| Set the reductions of S. |
+`--------------------------*/
void
-state_reductions_set (state_t *state, int num, rule_t **reductions)
+state_reductions_set (state *s, int num, rule **reds)
{
- if (state->reductions)
+ if (s->reductions)
abort ();
- state->reductions = reductions_new (num, reductions);
+ s->reductions = reductions_new (num, reds);
}
int
-state_reduction_find (state_t *state, rule_t *rule)
+state_reduction_find (state *s, rule *r)
{
int i;
- reductions_t *reds = state->reductions;
+ reductions *reds = s->reductions;
for (i = 0; i < reds->num; ++i)
- if (reds->rules[i] == rule)
+ if (reds->rules[i] == r)
return i;
return -1;
}
-/*------------------------.
-| Set the errs of STATE. |
-`------------------------*/
+/*--------------------.
+| Set the errs of S. |
+`--------------------*/
void
-state_errs_set (state_t *state, int num, symbol_t **tokens)
+state_errs_set (state *s, int num, symbol **tokens)
{
- if (state->errs)
+ if (s->errs)
abort ();
- state->errs = errs_new (num, tokens);
+ s->errs = errs_new (num, tokens);
}
-/*--------------------------------------------------------------.
-| Print on OUT all the lookaheads such that this STATE wants to |
-| reduce this RULE. |
-`--------------------------------------------------------------*/
+/*-----------------------------------------------------.
+| Print on OUT all the lookaheads such that S wants to |
+| reduce R. |
+`-----------------------------------------------------*/
void
-state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out)
+state_rule_lookaheads_print (state *s, rule *r, FILE *out)
{
/* Find the reduction we are handling. */
- reductions_t *reds = state->reductions;
- int red = state_reduction_find (state, rule);
+ reductions *reds = s->reductions;
+ int red = state_reduction_find (s, r);
/* Print them if there are. */
if (reds->lookaheads && red != -1)
@@ -264,7 +267,7 @@ static struct hash_table *state_table =
/* Two states are equal if they have the same core items. */
static bool
-state_compare (const state_t *s1, const state_t *s2)
+state_compare (state const *s1, state const *s2)
{
int i;
@@ -279,13 +282,13 @@ state_compare (const state_t *s1, const
}
static unsigned int
-state_hash (const state_t *state, unsigned int tablesize)
+state_hash (state const *s, unsigned int tablesize)
{
/* Add up the state's item numbers to get a hash key. */
int key = 0;
int i;
- for (i = 0; i < state->nitems; ++i)
- key += state->items[i];
+ for (i = 0; i < s->nitems; ++i)
+ key += s->items[i];
return key % tablesize;
}
@@ -316,14 +319,14 @@ state_hash_free (void)
}
-/*---------------------------------------.
-| Insert STATE in the state hash table. |
-`---------------------------------------*/
+/*-----------------------------------.
+| Insert S in the state hash table. |
+`-----------------------------------*/
void
-state_hash_insert (state_t *state)
+state_hash_insert (state *s)
{
- hash_insert (state_table, state);
+ hash_insert (state_table, s);
}
@@ -332,11 +335,11 @@ state_hash_insert (state_t *state)
| not exist yet, return NULL. |
`------------------------------------------------------------------*/
-state_t *
-state_hash_lookup (size_t core_size, item_number_t *core)
+state *
+state_hash_lookup (size_t core_size, item_number *core)
{
- state_t *probe = STATE_ALLOC (core_size);
- state_t *entry;
+ state *probe = STATE_ALLOC (core_size);
+ state *entry;
probe->nitems = core_size;
memcpy (probe->items, core, core_size * sizeof (core[0]));
@@ -346,7 +349,7 @@ state_hash_lookup (size_t core_size, ite
}
/* All the decorated states, indexed by the state number. */
-state_t **states = NULL;
+state **states = NULL;
/*----------------------.
@@ -356,7 +359,7 @@ state_t **states = NULL;
void
states_free (void)
{
- state_number_t i;
+ state_number i;
for (i = 0; i < nstates; ++i)
state_free (states[i]);
free (states);
Index: src/state.h
===================================================================
RCS file: /cvsroot/bison/bison/src/state.h,v
retrieving revision 1.42
diff -p -u -r1.42 state.h
--- src/state.h 21 Oct 2002 05:30:50 -0000 1.42
+++ src/state.h 11 Dec 2002 05:09:24 -0000
@@ -51,7 +51,7 @@
lookahead token alone). When the states are generated, these
actions are represented in two other lists.
- Each transition_t structure describes the possible transitions out
+ Each transition structure describes the possible transitions out
of one state, the state whose number is in the number field. Each
contains a vector of numbers of the states that transitions can go
to. The accessing_symbol fields of those states' cores say what
@@ -82,31 +82,34 @@
#ifndef STATE_H_
# define STATE_H_
-# include "bitset.h"
+# include <bitset.h>
+
+# include "gram.h"
+# include "symtab.h"
/*-------------------.
| Numbering states. |
`-------------------*/
-typedef short state_number_t;
-# define STATE_NUMBER_MAX ((state_number_t) SHRT_MAX)
+typedef short state_number;
+# define STATE_NUMBER_MAXIMUM SHRT_MAX
-/* Be ready to map a state_number_t to an int. */
+/* Be ready to map a state_number to an int. */
# define state_number_as_int(Tok) ((int) (Tok))
-typedef struct state_s state_t;
+typedef struct state state;
/*--------------.
| Transitions. |
`--------------*/
-typedef struct transtion_s
+typedef struct
{
short num;
- state_t *states[1];
-} transitions_t;
+ state *states[1];
+} transitions;
/* What is the symbol labelling the transition to
@@ -151,49 +154,48 @@ typedef struct transtion_s
if (!TRANSITION_IS_DISABLED (Transitions, Iter))
-/* Return the state such these TRANSITIONS contain a shift/goto to it on
- SYMBOL. Aborts if none found. */
-struct state_s;
-struct state_s *transitions_to (transitions_t *state, symbol_number_t s);
+/* Return the state such SHIFTS contain a shift/goto to it on S.
+ Abort if none found. */
+struct state *transitions_to (transitions *shifts, symbol_number s);
/*-------.
| Errs. |
`-------*/
-typedef struct errs_s
+typedef struct
{
short num;
- symbol_t *symbols[1];
-} errs_t;
+ symbol *symbols[1];
+} errs;
-errs_t *errs_new (int num, symbol_t **tokens);
+errs *errs_new (int num, symbol **tokens);
/*-------------.
| Reductions. |
`-------------*/
-typedef struct reductions_s
+typedef struct
{
short num;
bitset *lookaheads;
- rule_t *rules[1];
-} reductions_t;
+ rule *rules[1];
+} reductions;
/*---------.
-| States. |
+| states. |
`---------*/
-struct state_s
+struct state
{
- state_number_t number;
- symbol_number_t accessing_symbol;
- transitions_t *transitions;
- reductions_t *reductions;
- errs_t *errs;
+ state_number number;
+ symbol_number accessing_symbol;
+ transitions *transitions;
+ reductions *reductions;
+ errs *errs;
/* Nonzero if no lookahead is needed to decide what to do in state S. */
char consistent;
@@ -205,30 +207,30 @@ struct state_s
/* Its items. Must be last, since ITEMS can be arbitrarily large.
*/
unsigned short nitems;
- item_number_t items[1];
+ item_number items[1];
};
-extern state_number_t nstates;
-extern state_t *final_state;
+extern state_number nstates;
+extern state *final_state;
/* Create a new state with ACCESSING_SYMBOL for those items. */
-state_t *state_new (symbol_number_t accessing_symbol,
- size_t core_size, item_number_t *core);
+state *state_new (symbol_number accessing_symbol,
+ size_t core_size, item_number *core);
/* Set the transitions of STATE. */
-void state_transitions_set (state_t *state, int num, state_t **transitions);
+void state_transitions_set (state *s, int num, state **trans);
/* Set the reductions of STATE. */
-void state_reductions_set (state_t *state, int num, rule_t **reductions);
+void state_reductions_set (state *s, int num, rule **reds);
-int state_reduction_find (state_t *state, rule_t *rule);
+int state_reduction_find (state *s, rule *r);
/* Set the errs of STATE. */
-void state_errs_set (state_t *state, int num, symbol_t **errs);
+void state_errs_set (state *s, int num, symbol **errors);
/* Print on OUT all the lookaheads such that this STATE wants to
- reduce this RULE. */
-void state_rule_lookaheads_print (state_t *state, rule_t *rule, FILE *out);
+ reduce R. */
+void state_rule_lookaheads_print (state *s, rule *r, FILE *out);
/* Create/destroy the states hash table. */
void state_hash_new (void);
@@ -236,13 +238,13 @@ void state_hash_free (void);
/* Find the state associated to the CORE, and return it. If it does
not exist yet, return NULL. */
-state_t *state_hash_lookup (size_t core_size, item_number_t *core);
+state *state_hash_lookup (size_t core_size, item_number *core);
/* Insert STATE in the state hash table. */
-void state_hash_insert (state_t *state);
+void state_hash_insert (state *s);
/* All the states, indexed by the state number. */
-extern state_t **states;
+extern state **states;
/* Free all the states. */
void states_free (void);
Index: src/symlist.c
===================================================================
RCS file: /cvsroot/bison/bison/src/symlist.c,v
retrieving revision 1.5
diff -p -u -r1.5 symlist.c
--- src/symlist.c 12 Nov 2002 08:05:59 -0000 1.5
+++ src/symlist.c 11 Dec 2002 05:09:24 -0000
@@ -19,21 +19,22 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
+
#include "complain.h"
#include "symlist.h"
-/*----------------------------------------------.
-| Create a list containing SYMBOL at LOCATION. |
-`----------------------------------------------*/
+/*--------------------------------------.
+| Create a list containing SYM at LOC. |
+`--------------------------------------*/
-symbol_list_t *
-symbol_list_new (symbol_t *sym, location_t location)
+symbol_list *
+symbol_list_new (symbol *sym, location loc)
{
- symbol_list_t *res = XMALLOC (symbol_list_t, 1);
+ symbol_list *res = XMALLOC (symbol_list, 1);
res->next = NULL;
res->sym = sym;
- res->location = location;
+ res->location = loc;
res->action = NULL;
res->ruleprec = NULL;
res->dprec = 0;
@@ -42,15 +43,14 @@ symbol_list_new (symbol_t *sym, location
}
-/*-----------------------------------------.
-| Prepend SYMBOL at LOCATION to the LIST. |
-`-----------------------------------------*/
-
-symbol_list_t *
-symbol_list_prepend (symbol_list_t *list,
- symbol_t *symbol, location_t location)
+/*---------------------------------.
+| Prepend SYM at LOC to the LIST. |
+`---------------------------------*/
+
+symbol_list *
+symbol_list_prepend (symbol_list *list, symbol *sym, location loc)
{
- symbol_list_t *res = symbol_list_new (symbol, location);
+ symbol_list *res = symbol_list_new (sym, loc);
res->next = list;
return res;
}
@@ -61,9 +61,9 @@ symbol_list_prepend (symbol_list_t *list
`-------------------------------------------------*/
void
-symbol_list_free (symbol_list_t *list)
+symbol_list_free (symbol_list *list)
{
- LIST_FREE (symbol_list_t, list);
+ LIST_FREE (symbol_list, list);
}
@@ -72,7 +72,7 @@ symbol_list_free (symbol_list_t *list)
`--------------------*/
unsigned int
-symbol_list_length (symbol_list_t *list)
+symbol_list_length (symbol_list *list)
{
int res = 0;
for (/* Nothing. */; list; list = list->next)
@@ -83,22 +83,20 @@ symbol_list_length (symbol_list_t *list)
/*--------------------------------------------------------------.
| Get the data type (alternative in the union) of the value for |
-| symbol N in rule RULE. |
+| symbol N in symbol list RP. |
`--------------------------------------------------------------*/
-struniq_t
-symbol_list_n_type_name_get (symbol_list_t *rule, location_t location, int n)
+uniqstr
+symbol_list_n_type_name_get (symbol_list *rp, location loc, int n)
{
int i;
- symbol_list_t *rp;
if (n < 0)
{
- complain_at (location, _("invalid $ value"));
+ complain_at (loc, _("invalid $ value"));
return NULL;
}
- rp = rule;
i = 0;
while (i < n)
@@ -106,7 +104,7 @@ symbol_list_n_type_name_get (symbol_list
rp = rp->next;
if (rp == NULL || rp->sym == NULL)
{
- complain_at (location, _("invalid $ value"));
+ complain_at (loc, _("invalid $ value"));
return NULL;
}
++i;
Index: src/symlist.h
===================================================================
RCS file: /cvsroot/bison/bison/src/symlist.h,v
retrieving revision 1.6
diff -p -u -r1.6 symlist.h
--- src/symlist.h 12 Nov 2002 08:05:59 -0000 1.6
+++ src/symlist.h 11 Dec 2002 05:09:24 -0000
@@ -21,42 +21,41 @@
#ifndef SYMLIST_H_
# define SYMLIST_H_
-# include "symtab.h"
# include "location.h"
+# include "symtab.h"
-typedef struct symbol_list_s
+typedef struct symbol_list
{
- struct symbol_list_s *next;
- symbol_t *sym;
- location_t location;
+ struct symbol_list *next;
+ symbol *sym;
+ location location;
/* The action is attached to the LHS of a rule. */
const char *action;
- location_t action_location;
+ location action_location;
- symbol_t *ruleprec;
+ symbol *ruleprec;
int dprec;
int merger;
-} symbol_list_t;
+} symbol_list;
-/* Create a list containing SYMBOL at LOCATION. */
-symbol_list_t *symbol_list_new (symbol_t *sym, location_t location);
+/* Create a list containing SYM at LOC. */
+symbol_list *symbol_list_new (symbol *sym, location loc);
-/* Prepend SYMBOL at LOCATION to the LIST. */
-symbol_list_t * symbol_list_prepend (symbol_list_t *list,
- symbol_t *symbol,
- location_t location);
+/* Prepend SYM at LOC to the LIST. */
+symbol_list *symbol_list_prepend (symbol_list *list,
+ symbol *sym,
+ location loc);
/* Free the LIST, but not the symbols it contains. */
-void symbol_list_free (symbol_list_t *list);
+void symbol_list_free (symbol_list *list);
/* Return its length. */
-unsigned int symbol_list_length (symbol_list_t *list);
+unsigned int symbol_list_length (symbol_list *list);
/* Get the data type (alternative in the union) of the value for
symbol N in rule RULE. */
-struniq_t symbol_list_n_type_name_get (symbol_list_t *rule,
- location_t location, int n);
+uniqstr symbol_list_n_type_name_get (symbol_list *rp, location loc, int n);
#endif /* !SYMLIST_H_ */
Index: src/symtab.c
===================================================================
RCS file: /cvsroot/bison/bison/src/symtab.c,v
retrieving revision 1.52
diff -p -u -r1.52 symtab.c
--- src/symtab.c 21 Nov 2002 05:23:46 -0000 1.52
+++ src/symtab.c 11 Dec 2002 05:09:25 -0000
@@ -20,35 +20,37 @@
#include "system.h"
-#include "quotearg.h"
-#include "hash.h"
+
+#include <hash.h>
+#include <quotearg.h>
+
#include "complain.h"
-#include "symtab.h"
#include "gram.h"
+#include "symtab.h"
/*------------------------.
| Distinguished symbols. |
`------------------------*/
-symbol_t *errtoken = NULL;
-symbol_t *undeftoken = NULL;
-symbol_t *endtoken = NULL;
-symbol_t *accept = NULL;
-symbol_t *startsymbol = NULL;
-location_t startsymbol_location;
+symbol *errtoken = NULL;
+symbol *undeftoken = NULL;
+symbol *endtoken = NULL;
+symbol *accept = NULL;
+symbol *startsymbol = NULL;
+location startsymbol_location;
/*---------------------------------.
| Create a new symbol, named TAG. |
`---------------------------------*/
-static symbol_t *
-symbol_new (struniq_t tag, location_t location)
+static symbol *
+symbol_new (uniqstr tag, location loc)
{
- symbol_t *res = XMALLOC (symbol_t, 1);
+ symbol *res = XMALLOC (symbol, 1);
- struniq_assert (tag);
+ uniqstr_assert (tag);
res->tag = tag;
- res->location = location;
+ res->location = loc;
res->type_name = NULL;
res->destructor = NULL;
@@ -67,127 +69,119 @@ symbol_new (struniq_t tag, location_t lo
}
-/*------------------------------------------------------------------.
-| Set the TYPE_NAME associated to SYMBOL. Does nothing if passed 0 |
-| as TYPE_NAME. |
-`------------------------------------------------------------------*/
+/*-----------------------------------------------------------------.
+| Set the TYPE_NAME associated with SYM. Does nothing if passed 0 |
+| as TYPE_NAME. |
+`-----------------------------------------------------------------*/
void
-symbol_type_set (symbol_t *symbol, struniq_t type_name, location_t location)
+symbol_type_set (symbol *sym, uniqstr type_name, location loc)
{
if (type_name)
{
- if (symbol->type_name)
- complain_at (location,
- _("type redeclaration for %s"), symbol->tag);
- struniq_assert (type_name);
- symbol->type_name = type_name;
+ if (sym->type_name)
+ complain_at (loc, _("type redeclaration for %s"), sym->tag);
+ uniqstr_assert (type_name);
+ sym->type_name = type_name;
}
}
-/*-------------------------------------------------------------------.
-| Set the DESTRUCTOR associated to SYMBOL. Do nothing if passed 0. |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Set the DESTRUCTOR associated with SYM. Do nothing if passed 0. |
+`------------------------------------------------------------------*/
void
-symbol_destructor_set (symbol_t *symbol, char *destructor, location_t location)
+symbol_destructor_set (symbol *sym, char *destructor, location loc)
{
if (destructor)
{
- if (symbol->destructor)
- complain_at (location,
- _("%s redeclaration for %s"),
- "%destructor", symbol->tag);
- symbol->destructor = destructor;
- symbol->destructor_location = location;
+ if (sym->destructor)
+ complain_at (loc, _("%s redeclaration for %s"),
+ "%destructor", sym->tag);
+ sym->destructor = destructor;
+ sym->destructor_location = loc;
}
}
-/*----------------------------------------------------------------.
-| Set the PRINTER associated to SYMBOL. Do nothing if passed 0. |
-`----------------------------------------------------------------*/
+/*---------------------------------------------------------------.
+| Set the PRINTER associated with SYM. Do nothing if passed 0. |
+`---------------------------------------------------------------*/
void
-symbol_printer_set (symbol_t *symbol, char *printer, location_t location)
+symbol_printer_set (symbol *sym, char *printer, location loc)
{
if (printer)
{
- if (symbol->printer)
- complain_at (location,
- _("%s redeclaration for %s"),
- "%printer", symbol->tag);
- symbol->printer = printer;
- symbol->printer_location = location;
+ if (sym->printer)
+ complain_at (loc, _("%s redeclaration for %s"),
+ "%printer", sym->tag);
+ sym->printer = printer;
+ sym->printer_location = loc;
}
}
-/*------------------------------------------------------------------.
-| Set the PRECEDENCE associated to SYMBOL. Does nothing if invoked |
-| with UNDEF_ASSOC as ASSOC. |
-`------------------------------------------------------------------*/
+/*-----------------------------------------------------------------.
+| Set the PRECEDENCE associated with SYM. Does nothing if invoked |
+| with UNDEF_ASSOC as ASSOC. |
+`-----------------------------------------------------------------*/
void
-symbol_precedence_set (symbol_t *symbol,
- int prec, assoc_t assoc, location_t location)
+symbol_precedence_set (symbol *sym, int prec, assoc a, location loc)
{
- if (assoc != undef_assoc)
+ if (a != undef_assoc)
{
- if (symbol->prec != 0)
- complain_at (location,
- _("redefining precedence of %s"),
- symbol->tag);
- symbol->prec = prec;
- symbol->assoc = assoc;
+ if (sym->prec != 0)
+ complain_at (loc, _("redefining precedence of %s"), sym->tag);
+ sym->prec = prec;
+ sym->assoc = a;
}
/* Only terminals have a precedence. */
- symbol_class_set (symbol, token_sym, location);
+ symbol_class_set (sym, token_sym, loc);
}
-/*-------------------------------------.
-| Set the CLASS associated to SYMBOL. |
-`-------------------------------------*/
+/*------------------------------------.
+| Set the CLASS associated with SYM. |
+`------------------------------------*/
void
-symbol_class_set (symbol_t *symbol, symbol_class class, location_t location)
+symbol_class_set (symbol *sym, symbol_class class, location loc)
{
- if (symbol->class != unknown_sym && symbol->class != class)
- complain_at (location, _("symbol %s redefined"), symbol->tag);
+ if (sym->class != unknown_sym && sym->class != class)
+ complain_at (loc, _("symbol %s redefined"), sym->tag);
- if (class == nterm_sym && symbol->class != nterm_sym)
- symbol->number = nvars++;
- else if (class == token_sym && symbol->number == NUMBER_UNDEFINED)
- symbol->number = ntokens++;
+ if (class == nterm_sym && sym->class != nterm_sym)
+ sym->number = nvars++;
+ else if (class == token_sym && sym->number == NUMBER_UNDEFINED)
+ sym->number = ntokens++;
- symbol->class = class;
+ sym->class = class;
}
-/*-------------------------------------------------.
-| Set the USER_TOKEN_NUMBER associated to SYMBOL. |
-`-------------------------------------------------*/
+/*------------------------------------------------.
+| Set the USER_TOKEN_NUMBER associated with SYM. |
+`------------------------------------------------*/
void
-symbol_user_token_number_set (symbol_t *symbol,
- int user_token_number, location_t location)
+symbol_user_token_number_set (symbol *sym, int user_token_number, location loc)
{
- if (symbol->class != token_sym)
+ if (sym->class != token_sym)
abort ();
- if (symbol->user_token_number != USER_NUMBER_UNDEFINED
- && symbol->user_token_number != user_token_number)
- complain_at (location, _("redefining user token number of %s"),
- symbol->tag);
+ if (sym->user_token_number != USER_NUMBER_UNDEFINED
+ && sym->user_token_number != user_token_number)
+ complain_at (loc, _("redefining user token number of %s"), sym->tag);
- symbol->user_token_number = user_token_number;
+ sym->user_token_number = user_token_number;
/* User defined $end token? */
if (user_token_number == 0)
{
- endtoken = symbol;
+ endtoken = sym;
endtoken->number = 0;
/* It is always mapped to 0, so it was already counted in
NTOKENS. */
@@ -196,67 +190,67 @@ symbol_user_token_number_set (symbol_t *
}
-/*------------.
-| Free THIS. |
-`------------*/
+/*-----------.
+| Free SYM. |
+`-----------*/
static void
-symbol_free (symbol_t *this)
+symbol_free (symbol *sym)
{
- free (this);
+ free (sym);
}
-/*-----------------------------------------------------------.
-| If THIS is not defined, report an error, and consider it a |
-| nonterminal. |
-`-----------------------------------------------------------*/
+/*----------------------------------------------------------.
+| If SYM is not defined, report an error, and consider it a |
+| nonterminal. |
+`----------------------------------------------------------*/
static bool
-symbol_check_defined (symbol_t *this)
+symbol_check_defined (symbol *sym)
{
- if (this->class == unknown_sym)
+ if (sym->class == unknown_sym)
{
complain_at
- (this->location,
+ (sym->location,
_("symbol %s is used, but is not defined as a token and has no rules"),
- this->tag);
- this->class = nterm_sym;
- this->number = nvars++;
+ sym->tag);
+ sym->class = nterm_sym;
+ sym->number = nvars++;
}
return true;
}
-/*-------------------------------------------------------------------.
-| Declare the new SYMBOL. Make it an alias of SYMVAL, and type them |
-| with TYPENAME. |
-`-------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Declare the new symbol SYM. Make it an alias of SYMVAL, and type |
+| them with TYPENAME. |
+`------------------------------------------------------------------*/
void
-symbol_make_alias (symbol_t *symbol, symbol_t *symval, location_t loc)
+symbol_make_alias (symbol *sym, symbol *symval, location loc)
{
if (symval->alias)
warn_at (loc, _("symbol `%s' used more than once as a literal string"),
symval->tag);
- else if (symbol->alias)
+ else if (sym->alias)
warn_at (loc, _("symbol `%s' given more than one literal string"),
- symbol->tag);
+ sym->tag);
else
{
symval->class = token_sym;
- symval->user_token_number = symbol->user_token_number;
- symbol->user_token_number = USER_NUMBER_ALIAS;
- symval->alias = symbol;
- symbol->alias = symval;
- /* symbol and symval combined are only one symbol */
+ symval->user_token_number = sym->user_token_number;
+ sym->user_token_number = USER_NUMBER_ALIAS;
+ symval->alias = sym;
+ sym->alias = symval;
+ /* sym and symval combined are only one symbol. */
nsyms--;
ntokens--;
- if (ntokens != symbol->number && ntokens != symval->number)
+ if (ntokens != sym->number && ntokens != symval->number)
abort ();
- symbol->number = symval->number =
- (symval->number < symbol->number) ? symval->number : symbol->number;
+ sym->number = symval->number =
+ (symval->number < sym->number) ? symval->number : sym->number;
}
}
@@ -267,7 +261,7 @@ symbol_make_alias (symbol_t *symbol, sym
`---------------------------------------------------------*/
static bool
-symbol_check_alias_consistence (symbol_t *this)
+symbol_check_alias_consistence (symbol *this)
{
/* Check only those who _are_ the aliases. */
if (this->alias && this->user_token_number == USER_NUMBER_ALIAS)
@@ -307,7 +301,7 @@ symbol_check_alias_consistence (symbol_t
`-------------------------------------------------------------------*/
static bool
-symbol_pack (symbol_t *this)
+symbol_pack (symbol *this)
{
if (this->class == nterm_sym)
{
@@ -351,7 +345,7 @@ symbol_pack (symbol_t *this)
`--------------------------------------------------*/
static bool
-symbol_translation (symbol_t *this)
+symbol_translation (symbol *this)
{
/* Non-terminal? */
if (this->class == token_sym
@@ -381,14 +375,14 @@ symbol_translation (symbol_t *this)
static struct hash_table *symbol_table = NULL;
static bool
-hash_compare_symbol (const symbol_t *m1, const symbol_t *m2)
+hash_compare_symbol (const symbol *m1, const symbol *m2)
{
/* Since tags are unique, we can compare the pointers themselves. */
- return STRUNIQ_EQ (m1->tag, m2->tag);
+ return UNIQSTR_EQ (m1->tag, m2->tag);
}
static unsigned int
-hash_symbol (const symbol_t *m, unsigned int tablesize)
+hash_symbol (const symbol *m, unsigned int tablesize)
{
/* Since tags are unique, we can hash the pointer itself. */
return ((size_t) m->tag) % tablesize;
@@ -415,21 +409,21 @@ symbols_new (void)
| yet, create it. |
`----------------------------------------------------------------*/
-symbol_t *
-symbol_get (const char *key, location_t location)
+symbol *
+symbol_get (const char *key, location loc)
{
- symbol_t probe;
- symbol_t *entry;
+ symbol probe;
+ symbol *entry;
/* Keep the symbol in a printable form. */
- key = struniq_new (quotearg_style (escape_quoting_style, key));
+ key = uniqstr_new (quotearg_style (escape_quoting_style, key));
*(char const **) &probe.tag = key;
entry = hash_lookup (symbol_table, &probe);
if (!entry)
{
/* First insertion in the hash. */
- entry = symbol_new (key, location);
+ entry = symbol_new (key, loc);
hash_insert (symbol_table, entry);
}
return entry;
@@ -441,17 +435,17 @@ symbol_get (const char *key, location_t
| user's names. |
`------------------------------------------------------------------*/
-symbol_t *
-dummy_symbol_get (location_t location)
+symbol *
+dummy_symbol_get (location loc)
{
/* Incremented for each generated symbol. */
static int dummy_count = 0;
static char buf[256];
- symbol_t *sym;
+ symbol *sym;
sprintf (buf, "@%d", ++dummy_count);
- sym = symbol_get (buf, location);
+ sym = symbol_get (buf, loc);
sym->class = nterm_sym;
sym->number = nvars++;
return sym;
@@ -511,7 +505,7 @@ symbols_token_translations_init (void)
max_user_token_number = 0;
for (i = 0; i < ntokens; ++i)
{
- symbol_t *this = symbols[i];
+ symbol *this = symbols[i];
if (this->user_token_number != USER_NUMBER_UNDEFINED)
{
if (this->user_token_number > max_user_token_number)
@@ -532,14 +526,14 @@ symbols_token_translations_init (void)
for (i = 0; i < ntokens; ++i)
{
- symbol_t *this = symbols[i];
+ symbol *this = symbols[i];
if (this->user_token_number == USER_NUMBER_UNDEFINED)
this->user_token_number = ++max_user_token_number;
if (this->user_token_number > max_user_token_number)
max_user_token_number = this->user_token_number;
}
- token_translations = XCALLOC (symbol_number_t, max_user_token_number + 1);
+ token_translations = XCALLOC (symbol_number, max_user_token_number + 1);
/* Initialize all entries for literal tokens to 2, the internal
token number for $undefined, which represents all invalid inputs.
@@ -558,7 +552,7 @@ symbols_token_translations_init (void)
void
symbols_pack (void)
{
- symbols = XCALLOC (symbol_t *, nsyms);
+ symbols = XCALLOC (symbol *, nsyms);
symbols_do (symbol_check_alias_consistence, NULL);
symbols_do (symbol_pack, NULL);
Index: src/symtab.h
===================================================================
RCS file: /cvsroot/bison/bison/src/symtab.h,v
retrieving revision 1.49
diff -p -u -r1.49 symtab.h
--- src/symtab.h 12 Nov 2002 08:05:59 -0000 1.49
+++ src/symtab.h 11 Dec 2002 05:09:25 -0000
@@ -22,9 +22,9 @@
#ifndef SYMTAB_H_
# define SYMTAB_H_
-# include "struniq.h"
-# include "location.h"
# include "assoc.h"
+# include "location.h"
+# include "uniqstr.h"
/*----------.
| Symbols. |
@@ -40,34 +40,34 @@ typedef enum
/* Internal token numbers. */
-typedef short symbol_number_t;
-#define SYMBOL_NUMBER_MAX ((symbol_number_t) SHRT_MAX)
+typedef short symbol_number;
+#define SYMBOL_NUMBER_MAXIMUM SHRT_MAX
-typedef struct symbol_s symbol_t;
-struct symbol_s
+typedef struct symbol symbol;
+struct symbol
{
/* The key, name of the symbol. */
- struniq_t tag;
- /* The location of its first occurence. */
- location_t location;
+ uniqstr tag;
+ /* The location of its first occurrence. */
+ location location;
/* Its %type and associated printer and destructor. */
- struniq_t type_name;
+ uniqstr type_name;
char *destructor;
- location_t destructor_location;
+ location destructor_location;
char *printer;
- location_t printer_location;
+ location printer_location;
- symbol_number_t number;
+ symbol_number number;
short prec;
- assoc_t assoc;
+ assoc assoc;
int user_token_number;
/* Points to the other in the identifier-symbol pair for an alias.
Special value USER_NUMBER_ALIAS in the identifier half of the
identifier-symbol pair for an alias. */
- symbol_t *alias;
+ symbol *alias;
symbol_class class;
};
@@ -81,56 +81,49 @@ struct symbol_s
#define USER_NUMBER_ALIAS -9991
/* Undefined internal token number. */
-#define NUMBER_UNDEFINED ((symbol_number_t) -1)
+#define NUMBER_UNDEFINED ((symbol_number) -1)
/* Fetch (or create) the symbol associated to KEY. */
-symbol_t *symbol_get (const char *key, location_t location);
+symbol *symbol_get (const char *key, location loc);
/* Generate a dummy nonterminal, whose name cannot conflict with the
user's names. */
-symbol_t *dummy_symbol_get (location_t location);
+symbol *dummy_symbol_get (location loc);
-/* Declare the new SYMBOL. Make it an alias of SYMVAL. */
-void symbol_make_alias (symbol_t *symbol, symbol_t *symval,
- location_t location);
+/* Declare the new symbol SYM. Make it an alias of SYMVAL. */
+void symbol_make_alias (symbol *sym, symbol *symval, location loc);
-/* Set the TYPE_NAME associated to SYMBOL. Does nothing if passed 0 as
+/* Set the TYPE_NAME associated with SYM. Do nothing if passed 0 as
TYPE_NAME. */
-void symbol_type_set (symbol_t *symbol,
- struniq_t type_name, location_t location);
+void symbol_type_set (symbol *sym, uniqstr type_name, location loc);
+
+/* Set the DESTRUCTOR associated with SYM. */
+void symbol_destructor_set (symbol *sym, char *destructor, location loc);
+
+/* Set the PRINTER associated with SYM. */
+void symbol_printer_set (symbol *sym, char *printer, location loc);
+
+/* Set the PRECEDENCE associated with SYM. Ensure that SYMBOL is a
+ terminal. Do nothing if invoked with UNDEF_ASSOC as ASSOC. */
+void symbol_precedence_set (symbol *sym, int prec, assoc a, location loc);
+
+/* Set the CLASS associated with SYM. */
+void symbol_class_set (symbol *sym, symbol_class class, location loc);
-/* Set the DESTRUCTOR associated to SYMBOL. */
-void symbol_destructor_set (symbol_t *symbol,
- char *destructor, location_t location);
-
-/* Set the PRINTER associated to SYMBOL. */
-void symbol_printer_set (symbol_t *symbol,
- char *printer, location_t location);
-
-/* Set the PRECEDENCE associated to SYMBOL. Ensures that SYMBOL is a
- terminal. Does nothing if invoked with UNDEF_ASSOC as ASSOC. */
-void symbol_precedence_set (symbol_t *symbol,
- int prec, assoc_t assoc, location_t location);
-
-/* Set the CLASS associated to SYMBOL. */
-void symbol_class_set (symbol_t *symbol,
- symbol_class class, location_t location);
-
-/* Set the USER_TOKEN_NUMBER associated to SYMBOL. */
-void symbol_user_token_number_set (symbol_t *symbol,
- int user_number, location_t location);
+/* Set the USER_TOKEN_NUMBER associated with SYM. */
+void symbol_user_token_number_set (symbol *sym, int user_number, location loc);
/* Distinguished symbols. AXIOM is the real start symbol, that used
by the automaton. STARTSYMBOL is the one specified by the user.
*/
-extern symbol_t *errtoken;
-extern symbol_t *undeftoken;
-extern symbol_t *endtoken;
-extern symbol_t *accept;
-extern symbol_t *startsymbol;
-extern location_t startsymbol_location;
+extern symbol *errtoken;
+extern symbol *undeftoken;
+extern symbol *endtoken;
+extern symbol *accept;
+extern symbol *startsymbol;
+extern location startsymbol_location;
/*---------------.
@@ -142,7 +135,7 @@ extern location_t startsymbol_location;
void symbols_new (void);
/* A function to apply to each symbol. */
-typedef bool (*symbol_processor) (symbol_t *);
+typedef bool (*symbol_processor) (symbol *);
/* Apply PROCESSOR to all the symbols. PROCESSOR must return true: on
false, the processing stops. */
Index: src/system.h
===================================================================
RCS file: /cvsroot/bison/bison/src/system.h,v
retrieving revision 1.56
diff -p -u -r1.56 system.h
--- src/system.h 21 Nov 2002 05:24:53 -0000 1.56
+++ src/system.h 11 Dec 2002 05:09:25 -0000
@@ -79,23 +79,14 @@ char *alloca ();
/* memory.h and strings.h conflict on some systems. */
#endif /* not STDC_HEADERS and not HAVE_STRING_H */
-#include <errno.h>
#include <limits.h>
-# include "xalloc.h"
+#include <xalloc.h>
/* From xstrndup.c. */
char *xstrndup (const char *s, size_t n);
-/*----------------.
-| Using timevar. |
-`----------------*/
-
-#include "timevar.h"
-extern int time_report;
-
-
/*---------------------.
| Missing prototypes. |
`---------------------*/
@@ -172,7 +163,7 @@ void *memrchr (const void *s, int c, siz
# define setlocale(Category, Locale)
#endif
-#include "gettext.h"
+#include <gettext.h>
#define _(Msgid) gettext (Msgid)
#define N_(Msgid) (Msgid)
@@ -203,7 +194,7 @@ typedef enum {false = 0, true = 1} bool;
# define obstack_chunk_alloc xmalloc
# define obstack_chunk_free free
-# include "obstack.h"
+# include <obstack.h>
#define obstack_sgrow(Obs, Str) \
obstack_grow (Obs, Str, strlen (Str))
@@ -244,17 +235,17 @@ do {
\
#ifdef VMS
/* VMS. */
-# define EXT_TAB "_tab"
-# define EXT_OUTPUT ".output"
+# define TAB_EXT "_tab"
+# define OUTPUT_EXT ".output"
#else /* ! VMS */
# ifdef MSDOS
/* MS DOS. */
-# define EXT_TAB "_tab"
-# define EXT_OUTPUT ".out"
+# define TAB_EXT "_tab"
+# define OUTPUT_EXT ".out"
# else /* ! MSDOS */
/* Standard. */
-# define EXT_TAB ".tab"
-# define EXT_OUTPUT ".output"
+# define TAB_EXT ".tab"
+# define OUTPUT_EXT ".output"
# endif /* ! MSDOS */
#endif /* ! VMS */
Index: src/tables.c
===================================================================
RCS file: /cvsroot/bison/bison/src/tables.c,v
retrieving revision 1.14
diff -p -u -r1.14 tables.c
--- src/tables.c 21 Nov 2002 05:25:55 -0000 1.14
+++ src/tables.c 11 Dec 2002 05:09:25 -0000
@@ -21,16 +21,18 @@
#include "system.h"
-#include "bitsetv.h"
-#include "quotearg.h"
-#include "getargs.h"
+
+#include <bitsetv.h>
+#include <quotearg.h>
+
+#include "complain.h"
+#include "conflicts.h"
#include "files.h"
+#include "getargs.h"
#include "gram.h"
-#include "complain.h"
#include "lalr.h"
#include "reader.h"
#include "symtab.h"
-#include "conflicts.h"
#include "tables.h"
/* Several tables are indexed both by state and nonterminal numbers.
@@ -38,19 +40,17 @@
or a nonterminal number.
Of course vector_number_t ought to be wide enough to contain
- state_number_t and symbol_number_t. */
-typedef short vector_number_t;
-#define VECTOR_NUMBER_MAX ((vector_number_t) SHRT_MAX)
-#define VECTOR_NUMBER_MIN ((vector_number_t) SHRT_MIN)
+ state_number and symbol_number. */
+typedef short vector_number;
#define state_number_to_vector_number(State) \
- ((vector_number_t) State)
+ ((vector_number) State)
#define symbol_number_to_vector_number(Symbol) \
- ((vector_number_t) (state_number_as_int (nstates) + Symbol - ntokens))
+ ((vector_number) (state_number_as_int (nstates) + Symbol - ntokens))
int nvectors;
-/* FROMS and TOS are indexed by vector_number_t.
+/* FROMS and TOS are indexed by vector_number.
If VECTOR is a nonterminal, (FROMS[VECTOR], TOS[VECTOR]) form an
array of state numbers of the non defaulted GOTO on VECTOR.
@@ -63,20 +63,20 @@ int nvectors;
(FROMS[VECTOR][SIZE] - FROMS[VECTOR][0] + 1) where SIZE =
TALLY[VECTOR].
- FROMS therefore contains symbol_number_t and action_number_t,
- TOS state_number_t and action_number_t,
+ FROMS therefore contains symbol_number and action_number,
+ TOS state_number and action_number,
TALLY sizes,
WIDTH differences of FROMS.
- Let base_t be the type of FROMS, TOS, and WIDTH. */
-#define BASE_MAX ((base_t) INT_MAX)
-#define BASE_MIN ((base_t) INT_MIN)
+ Let base_number be the type of FROMS, TOS, and WIDTH. */
+#define BASE_MAXIMUM INT_MAX
+#define BASE_MINIMUM INT_MIN
-static base_t **froms = NULL;
-static base_t **tos = NULL;
+static base_number **froms = NULL;
+static base_number **tos = NULL;
static unsigned int **conflict_tos = NULL;
static short *tally = NULL;
-static base_t *width = NULL;
+static base_number *width = NULL;
/* For a given state, N = ACTROW[SYMBOL]:
@@ -85,24 +85,23 @@ static base_t *width = NULL;
If N = MIN, stands for `raise a syntax error'.
If N > 0, stands for `shift SYMBOL and go to n'.
If N < 0, stands for `reduce -N'. */
-typedef short action_t;
-#define ACTION_MAX ((action_t) SHRT_MAX)
-#define ACTION_MIN ((action_t) SHRT_MIN)
+typedef short action_number;
+#define ACTION_NUMBER_MINIMUM SHRT_MIN
-static action_t *actrow = NULL;
+static action_number *actrow = NULL;
/* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the
new vector number of VECTOR. We skip `empty' vectors (i.e.,
TALLY[VECTOR] = 0), and call these `entries'. */
-static vector_number_t *order = NULL;
+static vector_number *order = NULL;
static int nentries;
-base_t *base = NULL;
+base_number *base = NULL;
/* A distinguished value of BASE, negative infinite. During the
- computation equals to BASE_MIN, later mapped to BASE_NINF to
+ computation equals to BASE_MINIMUM, later mapped to BASE_NINF to
keep parser tables small. */
-base_t base_ninf = 0;
-static base_t *pos = NULL;
+base_number base_ninf = 0;
+static base_number *pos = NULL;
static unsigned int *conflrow = NULL;
unsigned int *conflict_table = NULL;
@@ -114,18 +113,18 @@ static int conflict_list_free;
with more or less the original hard-coded value (which was
SHRT_MAX). */
static size_t table_size = 32768;
-base_t *table = NULL;
-base_t *check = NULL;
+base_number *table = NULL;
+base_number *check = NULL;
/* The value used in TABLE to denote explicit syntax errors
- (%nonassoc), a negative infinite. First defaults to ACTION_MIN,
+ (%nonassoc), a negative infinite. First defaults to ACTION_NUMBER_MININUM,
but in order to keep small tables, renumbered as TABLE_ERROR, which
is the smallest (non error) value minus 1. */
-base_t table_ninf = 0;
+base_number table_ninf = 0;
static int lowzero;
int high;
-state_number_t *yydefgoto;
-rule_number_t *yydefact;
+state_number *yydefgoto;
+rule_number *yydefact;
/*----------------------------------------------------------------.
| If TABLE (and CHECK) appear to be small to be addressed at |
@@ -145,8 +144,8 @@ table_grow (size_t desired)
fprintf (stderr, "growing table and check from: %d to %d\n",
old_size, table_size);
- table = XREALLOC (table, base_t, table_size);
- check = XREALLOC (check, base_t, table_size);
+ table = XREALLOC (table, base_number, table_size);
+ check = XREALLOC (check, base_number, table_size);
conflict_table = XREALLOC (conflict_table, unsigned int, table_size);
for (/* Nothing. */; old_size < table_size; ++old_size)
@@ -160,20 +159,20 @@ table_grow (size_t desired)
/*-------------------------------------------------------------------.
-| For GLR parsers, for each conflicted token in STATE, as indicated |
+| For GLR parsers, for each conflicted token in S, as indicated |
| by non-zero entries in CONFLROW, create a list of possible |
| reductions that are alternatives to the shift or reduction |
-| currently recorded for that token in STATE. Store the alternative |
+| currently recorded for that token in S. Store the alternative |
| reductions followed by a 0 in CONFLICT_LIST, updating |
| CONFLICT_LIST_CNT, and storing an index to the start of the list |
| back into CONFLROW. |
`-------------------------------------------------------------------*/
static void
-conflict_row (state_t *state)
+conflict_row (state *s)
{
int i, j;
- reductions_t *reds = state->reductions;
+ reductions *reds = s->reductions;
if (! glr_parser)
return;
@@ -212,8 +211,9 @@ conflict_row (state_t *state)
| default action (yydefact) for the state. In addition, ACTROW is |
| filled with what to do for each kind of token, index by symbol |
| number, with zero meaning do the default action. The value |
-| ACTION_MIN, a very negative number, means this situation is an |
-| error. The parser recognizes this value specially. |
+| ACTION_NUMBER_MINIMUM, a very negative number, means this |
+| situation is an error. The parser recognizes this value |
+| specially. |
| |
| This is where conflicts are resolved. The loop over lookahead |
| rules considered lower-numbered rules last, and the last rule |
@@ -225,14 +225,14 @@ conflict_row (state_t *state)
| that has any such conflicts. |
`------------------------------------------------------------------*/
-static rule_t *
-action_row (state_t *state)
+static rule *
+action_row (state *s)
{
int i;
- rule_t *default_rule = NULL;
- reductions_t *redp = state->reductions;
- transitions_t *transitions = state->transitions;
- errs_t *errp = state->errs;
+ rule *default_rule = NULL;
+ reductions *reds = s->reductions;
+ transitions *trans = s->transitions;
+ errs *errp = s->errs;
/* Set to nonzero to inhibit having any default reduction. */
int nodefault = 0;
int conflicted = 0;
@@ -240,76 +240,77 @@ action_row (state_t *state)
for (i = 0; i < ntokens; i++)
actrow[i] = conflrow[i] = 0;
- if (redp->lookaheads)
+ if (reds->lookaheads)
{
int j;
bitset_iterator biter;
/* loop over all the rules available here which require
lookahead (in reverse order to give precedence to the first
rule) */
- for (i = redp->num - 1; i >= 0; --i)
+ for (i = reds->num - 1; i >= 0; --i)
/* and find each token which the rule finds acceptable
to come next */
- BITSET_FOR_EACH (biter, redp->lookaheads[i], j, 0)
+ BITSET_FOR_EACH (biter, reds->lookaheads[i], j, 0)
{
/* and record this rule as the rule to use if that
token follows. */
if (actrow[j] != 0)
conflicted = conflrow[j] = 1;
- actrow[j] = rule_number_as_item_number (redp->rules[i]->number);
+ actrow[j] = rule_number_as_item_number (reds->rules[i]->number);
}
}
/* Now see which tokens are allowed for shifts in this state. For
them, record the shift as the thing to do. So shift is preferred
to reduce. */
- FOR_EACH_SHIFT (transitions, i)
+ FOR_EACH_SHIFT (trans, i)
{
- symbol_number_t symbol = TRANSITION_SYMBOL (transitions, i);
- state_t *shift_state = transitions->states[i];
+ symbol_number sym = TRANSITION_SYMBOL (trans, i);
+ state *shift_state = trans->states[i];
- if (actrow[symbol] != 0)
- conflicted = conflrow[symbol] = 1;
- actrow[symbol] = state_number_as_int (shift_state->number);
+ if (actrow[sym] != 0)
+ conflicted = conflrow[sym] = 1;
+ actrow[sym] = state_number_as_int (shift_state->number);
/* Do not use any default reduction if there is a shift for
error */
- if (symbol == errtoken->number)
+ if (sym == errtoken->number)
nodefault = 1;
}
/* See which tokens are an explicit error in this state (due to
- %nonassoc). For them, record ACTION_MIN as the action. */
+ %nonassoc). For them, record ACTION_NUMBER_MINIMUM as the
+ action. */
for (i = 0; i < errp->num; i++)
{
- symbol_t *symbol = errp->symbols[i];
- actrow[symbol->number] = ACTION_MIN;
+ symbol *sym = errp->symbols[i];
+ actrow[sym->number] = ACTION_NUMBER_MINIMUM;
}
/* Now find the most common reduction and make it the default action
for this state. */
- if (redp->num >= 1 && !nodefault)
+ if (reds->num >= 1 && !nodefault)
{
- if (state->consistent)
- default_rule = redp->rules[0];
+ if (s->consistent)
+ default_rule = reds->rules[0];
else
{
int max = 0;
- for (i = 0; i < redp->num; i++)
+ for (i = 0; i < reds->num; i++)
{
int count = 0;
- rule_t *rule = redp->rules[i];
- symbol_number_t j;
+ rule *r = reds->rules[i];
+ symbol_number j;
for (j = 0; j < ntokens; j++)
- if (actrow[j] == rule_number_as_item_number (rule->number))
+ if (actrow[j] == rule_number_as_item_number (r->number))
count++;
if (count > max)
{
max = count;
- default_rule = rule;
+ default_rule = r;
}
}
@@ -335,31 +336,31 @@ action_row (state_t *state)
if (!default_rule)
for (i = 0; i < ntokens; i++)
- if (actrow[i] == ACTION_MIN)
+ if (actrow[i] == ACTION_NUMBER_MINIMUM)
actrow[i] = 0;
if (conflicted)
- conflict_row (state);
+ conflict_row (s);
return default_rule;
}
-/*--------------------------------------------.
-| Set FROMS, TOS, TALLY and WIDTH for STATE. |
-`--------------------------------------------*/
+/*----------------------------------------.
+| Set FROMS, TOS, TALLY and WIDTH for S. |
+`----------------------------------------*/
static void
-save_row (state_number_t state)
+save_row (state_number s)
{
- symbol_number_t i;
+ symbol_number i;
int count;
- base_t *sp = NULL;
- base_t *sp1 = NULL;
- base_t *sp2 = NULL;
+ base_number *sp = NULL;
+ base_number *sp1 = NULL;
+ base_number *sp2 = NULL;
unsigned int *sp3 = NULL;
- /* Number of non default actions in STATE. */
+ /* Number of non default actions in S. */
count = 0;
for (i = 0; i < ntokens; i++)
if (actrow[i] != 0)
@@ -369,12 +370,12 @@ save_row (state_number_t state)
return;
/* Allocate non defaulted actions. */
- froms[state] = sp1 = sp = XCALLOC (base_t, count);
- tos[state] = sp2 = XCALLOC (base_t, count);
+ froms[s] = sp1 = sp = XCALLOC (base_number, count);
+ tos[s] = sp2 = XCALLOC (base_number, count);
if (glr_parser)
- conflict_tos[state] = sp3 = XCALLOC (unsigned int, count);
+ conflict_tos[s] = sp3 = XCALLOC (unsigned int, count);
else
- conflict_tos[state] = NULL;
+ conflict_tos[s] = NULL;
/* Store non defaulted actions. */
for (i = 0; i < ntokens; i++)
@@ -386,8 +387,8 @@ save_row (state_number_t state)
*sp3++ = conflrow[i];
}
- tally[state] = count;
- width[state] = sp1[-1] - sp[0] + 1;
+ tally[s] = count;
+ width[s] = sp1[-1] - sp[0] + 1;
}
@@ -402,15 +403,15 @@ save_row (state_number_t state)
static void
token_actions (void)
{
- state_number_t i;
- symbol_number_t j;
- rule_number_t r;
+ state_number i;
+ symbol_number j;
+ rule_number r;
int nconflict = glr_parser ? conflicts_total_count () : 0;
- yydefact = XCALLOC (rule_number_t, nstates);
+ yydefact = XCALLOC (rule_number, nstates);
- actrow = XCALLOC (action_t, ntokens);
+ actrow = XCALLOC (action_number, ntokens);
conflrow = XCALLOC (unsigned int, ntokens);
conflict_list = XCALLOC (unsigned int, 1 + 2 * nconflict);
@@ -424,7 +425,7 @@ token_actions (void)
for (i = 0; i < nstates; ++i)
{
- rule_t *default_rule = action_row (states[i]);
+ rule *default_rule = action_row (states[i]);
yydefact[i] = default_rule ? default_rule->number + 1 : 0;
save_row (i);
@@ -434,7 +435,7 @@ token_actions (void)
if (!glr_parser)
{
for (j = 0; j < ntokens; ++j)
- if (actrow[j] < 0 && actrow[j] != ACTION_MIN)
+ if (actrow[j] < 0 && actrow[j] != ACTION_NUMBER_MINIMUM)
rules[item_number_as_rule_number (actrow[j])].useful = true;
if (yydefact[i])
rules[yydefact[i] - 1].useful = true;
@@ -449,24 +450,24 @@ token_actions (void)
/*------------------------------------------------------------------.
| Compute FROMS[VECTOR], TOS[VECTOR], TALLY[VECTOR], WIDTH[VECTOR], |
| i.e., the information related to non defaulted GOTO on the nterm |
-| SYMBOL. |
+| SYM. |
| |
-| DEFAULT_STATE is the principal destination on SYMBOL, i.e., the |
-| default GOTO destination on SYMBOL. |
+| DEFAULT_STATE is the principal destination on SYM, i.e., the |
+| default GOTO destination on SYM. |
`------------------------------------------------------------------*/
static void
-save_column (symbol_number_t symbol, state_number_t default_state)
+save_column (symbol_number sym, state_number default_state)
{
int i;
- base_t *sp;
- base_t *sp1;
- base_t *sp2;
+ base_number *sp;
+ base_number *sp1;
+ base_number *sp2;
int count;
- vector_number_t symno = symbol_number_to_vector_number (symbol);
+ vector_number symno = symbol_number_to_vector_number (sym);
- goto_number_t begin = goto_map[symbol];
- goto_number_t end = goto_map[symbol + 1];
+ goto_number begin = goto_map[sym];
+ goto_number end = goto_map[sym + 1];
/* Number of non default GOTO. */
count = 0;
@@ -478,8 +479,8 @@ save_column (symbol_number_t symbol, sta
return;
/* Allocate room for non defaulted gotos. */
- froms[symno] = sp1 = sp = XCALLOC (base_t, count);
- tos[symno] = sp2 = XCALLOC (base_t, count);
+ froms[symno] = sp1 = sp = XCALLOC (base_number, count);
+ tos[symno] = sp2 = XCALLOC (base_number, count);
/* Store the state numbers of the non defaulted gotos. */
for (i = begin; i < end; i++)
@@ -494,22 +495,22 @@ save_column (symbol_number_t symbol, sta
}
-/*----------------------------------------------------------------.
-| Return `the' most common destination GOTO on SYMBOL (a nterm). |
-`----------------------------------------------------------------*/
+/*-------------------------------------------------------------.
+| Return `the' most common destination GOTO on SYM (a nterm). |
+`-------------------------------------------------------------*/
-static state_number_t
-default_goto (symbol_number_t symbol, short state_count[])
+static state_number
+default_goto (symbol_number sym, short state_count[])
{
- state_number_t s;
+ state_number s;
int i;
- goto_number_t m = goto_map[symbol];
- goto_number_t n = goto_map[symbol + 1];
- state_number_t default_state = (state_number_t) -1;
+ goto_number m = goto_map[sym];
+ goto_number n = goto_map[sym + 1];
+ state_number default_state = (state_number) -1;
int max = 0;
if (m == n)
- return (state_number_t) -1;
+ return (state_number) -1;
for (s = 0; s < nstates; s++)
state_count[s] = 0;
@@ -540,15 +541,15 @@ default_goto (symbol_number_t symbol, sh
static void
goto_actions (void)
{
- symbol_number_t i;
+ symbol_number i;
short *state_count = XCALLOC (short, nstates);
- yydefgoto = XMALLOC (state_number_t, nvars);
+ yydefgoto = XMALLOC (state_number, nvars);
/* For a given nterm I, STATE_COUNT[S] is the number of times there
is a GOTO to S on I. */
for (i = ntokens; i < nsyms; ++i)
{
- state_number_t default_state = default_goto (i, state_count);
+ state_number default_state = default_goto (i, state_count);
save_column (i, default_state);
yydefgoto[i - ntokens] = default_state;
}
@@ -597,10 +598,10 @@ sort_actions (void)
In any other case, return -1. */
-static state_number_t
-matching_state (vector_number_t vector)
+static state_number
+matching_state (vector_number vector)
{
- vector_number_t i = order[vector];
+ vector_number i = order[vector];
int t;
int w;
int prev;
@@ -623,7 +624,7 @@ matching_state (vector_number_t vector)
for (prev = vector - 1; prev >= 0; prev--)
{
- vector_number_t j = order[prev];
+ vector_number j = order[prev];
int k;
int match = 1;
@@ -645,15 +646,15 @@ matching_state (vector_number_t vector)
}
-static base_t
-pack_vector (vector_number_t vector)
+static base_number
+pack_vector (vector_number vector)
{
- vector_number_t i = order[vector];
+ vector_number i = order[vector];
int j;
int t = tally[i];
int loc = 0;
- base_t *from = froms[i];
- base_t *to = tos[i];
+ base_number *from = froms[i];
+ base_number *to = tos[i];
unsigned int *conflict_to = conflict_tos[i];
if (! t)
@@ -698,7 +699,7 @@ pack_vector (vector_number_t vector)
if (loc > high)
high = loc;
- if (! (BASE_MIN <= j && j <= BASE_MAX))
+ if (! (BASE_MINIMUM <= j && j <= BASE_MAXIMUM))
abort ();
return j;
}
@@ -714,10 +715,10 @@ pack_vector (vector_number_t vector)
| parsers. |
`-------------------------------------------------------------*/
-static base_t
-table_ninf_remap (base_t tab[], size_t size, base_t ninf)
+static base_number
+table_ninf_remap (base_number tab[], size_t size, base_number ninf)
{
- base_t res = 0;
+ base_number res = 0;
size_t i;
for (i = 0; i < size; i++)
@@ -738,40 +739,40 @@ pack_table (void)
{
int i;
- base = XCALLOC (base_t, nvectors);
- pos = XCALLOC (base_t, nentries);
- table = XCALLOC (base_t, table_size);
+ base = XCALLOC (base_number, nvectors);
+ pos = XCALLOC (base_number, nentries);
+ table = XCALLOC (base_number, table_size);
conflict_table = XCALLOC (unsigned int, table_size);
- check = XCALLOC (base_t, table_size);
+ check = XCALLOC (base_number, table_size);
lowzero = 0;
high = 0;
for (i = 0; i < nvectors; i++)
- base[i] = BASE_MIN;
+ base[i] = BASE_MINIMUM;
for (i = 0; i < (int) table_size; i++)
check[i] = -1;
for (i = 0; i < nentries; i++)
{
- state_number_t state = matching_state (i);
- base_t place;
+ state_number s = matching_state (i);
+ base_number place;
- if (state < 0)
+ if (s < 0)
/* A new set of state actions, or a nonterminal. */
place = pack_vector (i);
else
- /* Action of I were already coded for STATE. */
- place = base[state];
+ /* Action of I were already coded for S. */
+ place = base[s];
pos[i] = place;
base[order[i]] = place;
}
/* Use the greatest possible negative infinites. */
- base_ninf = table_ninf_remap (base, nvectors, BASE_MIN);
- table_ninf = table_ninf_remap (table, high + 1, ACTION_MIN);
+ base_ninf = table_ninf_remap (base, nvectors, BASE_MINIMUM);
+ table_ninf = table_ninf_remap (table, high + 1, ACTION_NUMBER_MINIMUM);
free (pos);
}
@@ -797,11 +798,11 @@ tables_generate (void)
nvectors = state_number_as_int (nstates) + nvars;
- froms = XCALLOC (base_t *, nvectors);
- tos = XCALLOC (base_t *, nvectors);
+ froms = XCALLOC (base_number *, nvectors);
+ tos = XCALLOC (base_number *, nvectors);
conflict_tos = XCALLOC (unsigned int *, nvectors);
tally = XCALLOC (short, nvectors);
- width = XCALLOC (base_t, nvectors);
+ width = XCALLOC (base_number, nvectors);
token_actions ();
@@ -810,7 +811,7 @@ tables_generate (void)
free (from_state);
free (to_state);
- order = XCALLOC (vector_number_t, nvectors);
+ order = XCALLOC (vector_number, nvectors);
sort_actions ();
pack_table ();
free (order);
Index: src/tables.h
===================================================================
RCS file: /cvsroot/bison/bison/src/tables.h,v
retrieving revision 1.5
diff -p -u -r1.5 tables.h
--- src/tables.h 15 Nov 2002 20:32:21 -0000 1.5
+++ src/tables.h 11 Dec 2002 05:09:25 -0000
@@ -1,5 +1,5 @@
/* Prepare the LALR and GLR parser tables.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
@@ -92,25 +92,25 @@
extern int nvectors;
-typedef int base_t;
-extern base_t *base;
+typedef int base_number;
+extern base_number *base;
/* A distinguished value of BASE, negative infinite. During the
- computation equals to BASE_MIN, later mapped to BASE_NINF to
+ computation equals to BASE_MINIMUM, later mapped to BASE_NINF to
keep parser tables small. */
-extern base_t base_ninf;
+extern base_number base_ninf;
extern unsigned int *conflict_table;
extern unsigned int *conflict_list;
extern int conflict_list_cnt;
-extern base_t *table;
-extern base_t *check;
+extern base_number *table;
+extern base_number *check;
/* The value used in TABLE to denote explicit syntax errors
(%nonassoc), a negative infinite. */
-extern base_t table_ninf;
+extern base_number table_ninf;
-extern state_number_t *yydefgoto;
-extern rule_number_t *yydefact;
+extern state_number *yydefgoto;
+extern rule_number *yydefact;
extern int high;
void tables_generate (void);
Index: src/vcg.c
===================================================================
RCS file: /cvsroot/bison/bison/src/vcg.c,v
retrieving revision 1.10
diff -p -u -r1.10 vcg.c
--- src/vcg.c 21 Nov 2002 05:26:41 -0000 1.10
+++ src/vcg.c 11 Dec 2002 05:09:25 -0000
@@ -19,9 +19,11 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
+
+#include <quotearg.h>
+
#include "vcg.h"
#include "vcg_defaults.h"
-#include "quotearg.h"
/* Return an unambiguous printable representated, for NAME, suitable
for C strings. Use slot 2 since the user may use slots 0 and 1.
@@ -36,7 +38,7 @@ quote (char const *name)
/* Initialize a graph with the default values. */
void
-new_graph (graph_t *g)
+new_graph (graph *g)
{
g->title = G_TITLE;
g->label = G_LABEL;
@@ -56,7 +58,7 @@ new_graph (graph_t *g)
g->y = G_Y;
g->folding = G_FOLDING;
g->shrink = G_SHRINK;
- g->stretch = G_STRETCH;
+ g->expand = G_EXPAND;
g->textmode = G_TEXTMODE;
g->shape = G_SHAPE;
@@ -93,14 +95,14 @@ new_graph (graph_t *g)
g->dirty_edge_labels = G_DIRTY_EDGE_LABELS;
g->finetuning = G_FINETUNING;
g->ignore_singles = G_IGNORE_SINGLES;
- g->straight_phase = G_STRAIGHT_PHASE;
+ g->long_straight_phase = G_LONG_STRAIGHT_PHASE;
g->priority_phase = G_PRIORITY_PHASE;
g->manhattan_edges = G_MANHATTAN_EDGES;
g->smanhattan_edges = G_SMANHATTAN_EDGES;
g->near_edges = G_NEAR_EDGES;
g->orientation = G_ORIENTATION;
- g->node_alignement = G_NODE_ALIGNEMENT;
+ g->node_alignment = G_NODE_ALIGNMENT;
g->port_sharing = G_PORT_SHARING;
g->arrow_mode = G_ARROW_MODE;
g->treefactor = G_TREEFACTOR;
@@ -126,79 +128,79 @@ new_graph (graph_t *g)
g->node_list = G_NODE_LIST;
g->edge_list = G_EDGE_LIST;
- new_edge(&g->edge);
- new_node(&g->node);
+ new_edge (&g->edge);
+ new_node (&g->node);
}
-/* Initialize a node with the defalut values. */
+/* Initialize a node with the default values. */
void
-new_node (node_t *node)
+new_node (node *n)
{
- node->title = N_TITLE;
- node->label = N_LABEL;
+ n->title = N_TITLE;
+ n->label = N_LABEL;
- node->locx = N_LOCX; /* Default unspcified. */
- node->locy = N_LOCY; /* Default unspcified. */
+ n->locx = N_LOCX; /* Default unspcified. */
+ n->locy = N_LOCY; /* Default unspcified. */
- node->vertical_order = N_VERTICAL_ORDER; /* Default unspcified. */
- node->horizontal_order = N_HORIZONTAL_ORDER; /* Default unspcified. */
+ n->vertical_order = N_VERTICAL_ORDER; /* Default unspcified. */
+ n->horizontal_order = N_HORIZONTAL_ORDER; /* Default unspcified. */
- node->width = N_WIDTH; /* We assume that we can't define it now. */
- node->height = N_HEIGHT; /* Also. */
+ n->width = N_WIDTH; /* We assume that we can't define it now. */
+ n->height = N_HEIGHT; /* Also. */
- node->shrink = N_SHRINK;
- node->stretch = N_STRETCH;
+ n->shrink = N_SHRINK;
+ n->expand = N_EXPAND;
- node->folding = N_FOLDING; /* No explicit default value. */
+ n->folding = N_FOLDING; /* No explicit default value. */
- node->shape = N_SHAPE;
- node->textmode = N_TEXTMODE;
- node->borderwidth = N_BORDERWIDTH;
+ n->shape = N_SHAPE;
+ n->textmode = N_TEXTMODE;
+ n->borderwidth = N_BORDERWIDTH;
- node->color = N_COLOR;
- node->textcolor = N_TEXTCOLOR;
- node->bordercolor = N_BORDERCOLOR;
+ n->color = N_COLOR;
+ n->textcolor = N_TEXTCOLOR;
+ n->bordercolor = N_BORDERCOLOR;
- node->infos[0] = N_INFOS1;
- node->infos[1] = N_INFOS2;
- node->infos[2] = N_INFOS3;
+ n->infos[0] = N_INFOS1;
+ n->infos[1] = N_INFOS2;
+ n->infos[2] = N_INFOS3;
- node->next = N_NEXT;
+ n->next = N_NEXT;
}
-/* Initialize a edge with the defalut values. */
+/* Initialize an edge with the default values. */
void
-new_edge (edge_t *edge)
+new_edge (edge *e)
{
- edge->type = E_EDGE_TYPE;
+ e->type = E_EDGE_TYPE;
- edge->sourcename = E_SOURCENAME;
- edge->targetname = E_TARGETNAME;
- edge->label = E_LABEL;
+ e->sourcename = E_SOURCENAME;
+ e->targetname = E_TARGETNAME;
+ e->label = E_LABEL;
- edge->linestyle = E_LINESTYLE;
- edge->thickness = E_THICKNESS;
+ e->linestyle = E_LINESTYLE;
+ e->thickness = E_THICKNESS;
- edge->class = E_CLASS;
+ e->class = E_CLASS;
- edge->color = E_COLOR;
- edge->textcolor = E_TEXTCOLOR;
- edge->arrowcolor = E_ARROWCOLOR;
- edge->backarrowcolor = E_BACKARROWCOLOR;
+ e->color = E_COLOR;
+ e->textcolor = E_TEXTCOLOR;
+ e->arrowcolor = E_ARROWCOLOR;
+ e->backarrowcolor = E_BACKARROWCOLOR;
- edge->arrowsize = E_ARROWSIZE;
- edge->backarrowsize = E_BACKARROWSIZE;
- edge->arrowstyle = E_ARROWSTYLE;
+ e->arrowsize = E_ARROWSIZE;
+ e->backarrowsize = E_BACKARROWSIZE;
+ e->arrowstyle = E_ARROWSTYLE;
- edge->backarrowstyle = E_BACKARROWSTYLE;
+ e->backarrowstyle = E_BACKARROWSTYLE;
- edge->priority = E_PRIORITY;
+ e->priority = E_PRIORITY;
- edge->anchor = E_ANCHOR;
+ e->anchor = E_ANCHOR;
- edge->horizontal_order = E_HORIZONTAL_ORDER;
+ e->horizontal_order = E_HORIZONTAL_ORDER;
- edge->next = E_NEXT;
+ e->next = E_NEXT;
}
/*----------------------------------------------.
@@ -207,7 +209,7 @@ new_edge (edge_t *edge)
`----------------------------------------------*/
static const char *
-get_color_str (enum color_e c)
+get_color_str (enum color c)
{
switch (c)
{
@@ -248,7 +250,7 @@ get_color_str (enum color_e c)
}
static const char *
-get_textmode_str (enum textmode_e t)
+get_textmode_str (enum textmode t)
{
switch (t)
{
@@ -260,7 +262,7 @@ get_textmode_str (enum textmode_e t)
}
static const char *
-get_shape_str (enum shape_e s)
+get_shape_str (enum shape s)
{
switch (s)
{
@@ -273,7 +275,7 @@ get_shape_str (enum shape_e s)
}
static const char *
-get_layoutalgorithm_str (enum layoutalgorithm_e l)
+get_layoutalgorithm_str (enum layoutalgorithm l)
{
switch (l)
{
@@ -296,7 +298,7 @@ get_layoutalgorithm_str (enum layoutalgo
}
static const char *
-get_decision_str (enum decision_e d)
+get_decision_str (enum decision d)
{
switch (d)
{
@@ -307,7 +309,7 @@ get_decision_str (enum decision_e d)
}
static const char *
-get_orientation_str (enum orientation_e o)
+get_orientation_str (enum orientation o)
{
switch (o)
{
@@ -320,7 +322,7 @@ get_orientation_str (enum orientation_e
}
static const char *
-get_node_alignement_str (enum alignement_e a)
+get_node_alignment_str (enum alignment a)
{
switch (a)
{
@@ -332,7 +334,7 @@ get_node_alignement_str (enum alignement
}
static const char *
-get_arrow_mode_str (enum arrow_mode_e a)
+get_arrow_mode_str (enum arrow_mode a)
{
switch (a)
{
@@ -343,7 +345,7 @@ get_arrow_mode_str (enum arrow_mode_e a)
}
static const char *
-get_crossing_type_str (enum crossing_type_e c)
+get_crossing_type_str (enum crossing_type c)
{
switch (c)
{
@@ -356,7 +358,7 @@ get_crossing_type_str (enum crossing_typ
}
static const char *
-get_view_str (enum view_e v)
+get_view_str (enum view v)
{
switch (v)
{
@@ -370,7 +372,7 @@ get_view_str (enum view_e v)
}
static const char *
-get_linestyle_str (enum linestyle_e l)
+get_linestyle_str (enum linestyle l)
{
switch (l)
{
@@ -383,7 +385,7 @@ get_linestyle_str (enum linestyle_e l)
}
static const char *
-get_arrowstyle_str (enum arrowstyle_e a)
+get_arrowstyle_str (enum arrowstyle a)
{
switch (a)
{
@@ -394,31 +396,31 @@ get_arrowstyle_str (enum arrowstyle_e a)
}
}
-/*----------------------------.
-| Add functions. |
-| Edge and Nodes int a graph. |
-`----------------------------*/
+/*------------------------------.
+| Add functions. |
+| Edge and nodes into a graph. |
+`------------------------------*/
void
-add_node (graph_t *graph, node_t *node)
+add_node (graph *g, node *n)
{
- node->next = graph->node_list;
- graph->node_list = node;
+ n->next = g->node_list;
+ g->node_list = n;
}
void
-add_edge (graph_t *graph, edge_t *edge)
+add_edge (graph *g, edge *e)
{
- edge->next = graph->edge_list;
- graph->edge_list = edge;
+ e->next = g->edge_list;
+ g->edge_list = e;
}
void
-add_classname (graph_t *g, int val, const char *name)
+add_classname (graph *g, int val, const char *name)
{
- struct classname_s *classname;
+ struct classname *classname;
- classname = XMALLOC (struct classname_s, 1);
+ classname = XMALLOC (struct classname, 1);
classname->no = val;
classname->name = name;
classname->next = g->classname;
@@ -426,25 +428,25 @@ add_classname (graph_t *g, int val, cons
}
void
-add_infoname (graph_t *g, int integer, const char *string)
+add_infoname (graph *g, int integer, const char *str)
{
- struct infoname_s *infoname;
+ struct infoname *infoname;
- infoname = XMALLOC (struct infoname_s, 1);
+ infoname = XMALLOC (struct infoname, 1);
infoname->integer = integer;
- infoname->string = string;
+ infoname->chars = str;
infoname->next = g->infoname;
g->infoname = infoname;
}
/* Build a colorentry struct and add it to the list. */
void
-add_colorentry (graph_t *g, int color_idx, int red_cp,
+add_colorentry (graph *g, int color_idx, int red_cp,
int green_cp, int blue_cp)
{
- struct colorentry_s *ce;
+ struct colorentry *ce;
- ce = XMALLOC (struct colorentry_s, 1);
+ ce = XMALLOC (struct colorentry, 1);
ce->color_index = color_idx;
ce->red_cp = red_cp;
ce->green_cp = green_cp;
@@ -458,9 +460,9 @@ add_colorentry (graph_t *g, int color_id
`-------------------------------------*/
void
-open_edge(edge_t *edge, FILE *fout)
+open_edge (edge *e, FILE *fout)
{
- switch (edge->type)
+ switch (e->type)
{
case normal_edge:
fputs ("\tedge: {\n", fout);
@@ -480,42 +482,42 @@ open_edge(edge_t *edge, FILE *fout)
}
void
-close_edge(FILE *fout)
+close_edge (FILE *fout)
{
fputs ("\t}\n", fout);
}
void
-open_node(FILE *fout)
+open_node (FILE *fout)
{
fputs ("\tnode: {\n", fout);
}
void
-close_node(FILE *fout)
+close_node (FILE *fout)
{
fputs ("\t}\n", fout);
}
void
-open_graph(FILE *fout)
+open_graph (FILE *fout)
{
fputs ("graph: {\n", fout);
}
void
-close_graph(graph_t *graph, FILE *fout)
+close_graph (graph *g, FILE *fout)
{
fputc ('\n', fout);
/* FIXME: Unallocate nodes and edges if required. */
{
- node_t *node;
+ node *n;
- for (node = graph->node_list; node; node = node->next)
+ for (n = g->node_list; n; n = n->next)
{
open_node (fout);
- output_node (node, fout);
+ output_node (n, fout);
close_node (fout);
}
}
@@ -523,12 +525,12 @@ close_graph(graph_t *graph, FILE *fout)
fputc ('\n', fout);
{
- edge_t *edge;
+ edge *e;
- for (edge = graph->edge_list; edge; edge = edge->next)
+ for (e = g->edge_list; e; e = e->next)
{
- open_edge (edge, fout);
- output_edge (edge, fout);
+ open_edge (e, fout);
+ output_edge (e, fout);
close_edge (fout);
}
}
@@ -541,221 +543,221 @@ close_graph(graph_t *graph, FILE *fout)
`-------------------------------------------*/
void
-output_node (node_t *node, FILE *fout)
+output_node (node *n, FILE *fout)
{
- if (node->title != N_TITLE)
- fprintf (fout, "\t\ttitle:\t%s\n", quote (node->title));
- if (node->label != N_LABEL)
- fprintf (fout, "\t\tlabel:\t%s\n", quote (node->label));
-
- if ((node->locx != N_LOCX) && (node->locy != N_LOCY))
- fprintf (fout, "\t\tloc { x: %d y: %d }\t\n", node->locx, node->locy);
-
- if (node->vertical_order != N_VERTICAL_ORDER)
- fprintf (fout, "\t\tvertical_order:\t%d\n", node->vertical_order);
- if (node->horizontal_order != N_HORIZONTAL_ORDER)
- fprintf (fout, "\t\thorizontal_order:\t%d\n", node->horizontal_order);
-
- if (node->width != N_WIDTH)
- fprintf (fout, "\t\twidth:\t%d\n", node->width);
- if (node->height != N_HEIGHT)
- fprintf (fout, "\t\theight:\t%d\n", node->height);
-
- if (node->shrink != N_SHRINK)
- fprintf (fout, "\t\tshrink:\t%d\n", node->shrink);
- if (node->stretch != N_STRETCH)
- fprintf (fout, "\t\tstretch:\t%d\n", node->stretch);
+ if (n->title != N_TITLE)
+ fprintf (fout, "\t\ttitle:\t%s\n", quote (n->title));
+ if (n->label != N_LABEL)
+ fprintf (fout, "\t\tlabel:\t%s\n", quote (n->label));
+
+ if ((n->locx != N_LOCX) && (n->locy != N_LOCY))
+ fprintf (fout, "\t\tloc { x: %d y: %d }\t\n", n->locx, n->locy);
+
+ if (n->vertical_order != N_VERTICAL_ORDER)
+ fprintf (fout, "\t\tvertical_order:\t%d\n", n->vertical_order);
+ if (n->horizontal_order != N_HORIZONTAL_ORDER)
+ fprintf (fout, "\t\thorizontal_order:\t%d\n", n->horizontal_order);
+
+ if (n->width != N_WIDTH)
+ fprintf (fout, "\t\twidth:\t%d\n", n->width);
+ if (n->height != N_HEIGHT)
+ fprintf (fout, "\t\theight:\t%d\n", n->height);
+
+ if (n->shrink != N_SHRINK)
+ fprintf (fout, "\t\tshrink:\t%d\n", n->shrink);
+ if (n->expand != N_EXPAND)
+ fprintf (fout, "\t\texpand:\t%d\n", n->expand);
- if (node->folding != N_FOLDING)
- fprintf (fout, "\t\tfolding:\t%d\n", node->folding);
+ if (n->folding != N_FOLDING)
+ fprintf (fout, "\t\tfolding:\t%d\n", n->folding);
- if (node->textmode != N_TEXTMODE)
+ if (n->textmode != N_TEXTMODE)
fprintf (fout, "\t\ttextmode:\t%s\n",
- get_textmode_str (node->textmode));
+ get_textmode_str (n->textmode));
- if (node->shape != N_SHAPE)
- fprintf (fout, "\t\tshape:\t%s\n", get_shape_str (node->shape));
+ if (n->shape != N_SHAPE)
+ fprintf (fout, "\t\tshape:\t%s\n", get_shape_str (n->shape));
- if (node->borderwidth != N_BORDERWIDTH)
- fprintf (fout, "\t\tborderwidth:\t%d\n", node->borderwidth);
+ if (n->borderwidth != N_BORDERWIDTH)
+ fprintf (fout, "\t\tborderwidth:\t%d\n", n->borderwidth);
- if (node->color != N_COLOR)
- fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (node->color));
- if (node->textcolor != N_TEXTCOLOR)
+ if (n->color != N_COLOR)
+ fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (n->color));
+ if (n->textcolor != N_TEXTCOLOR)
fprintf (fout, "\t\ttextcolor:\t%s\n",
- get_color_str (node->textcolor));
- if (node->bordercolor != N_BORDERCOLOR)
+ get_color_str (n->textcolor));
+ if (n->bordercolor != N_BORDERCOLOR)
fprintf (fout, "\t\tbordercolor:\t%s\n",
- get_color_str (node->bordercolor));
+ get_color_str (n->bordercolor));
{
int i;
for (i = 0; i < 3; ++i)
- if (node->infos[i])
+ if (n->infos[i])
fprintf (fout, "\t\tinfo%d:\t%s\n",
- i, quote (node->infos[i]));
+ i, quote (n->infos[i]));
}
}
void
-output_edge (edge_t *edge, FILE *fout)
+output_edge (edge *e, FILE *fout)
{
/* FIXME: SOURCENAME and TARGETNAME are mandatory
so it has to be fatal not to give these informations. */
- if (edge->sourcename != E_SOURCENAME)
- fprintf (fout, "\t\tsourcename:\t%s\n", quote (edge->sourcename));
- if (edge->targetname != E_TARGETNAME)
- fprintf (fout, "\t\ttargetname:\t%s\n", quote (edge->targetname));
+ if (e->sourcename != E_SOURCENAME)
+ fprintf (fout, "\t\tsourcename:\t%s\n", quote (e->sourcename));
+ if (e->targetname != E_TARGETNAME)
+ fprintf (fout, "\t\ttargetname:\t%s\n", quote (e->targetname));
- if (edge->label != E_LABEL)
- fprintf (fout, "\t\tlabel:\t%s\n", quote (edge->label));
+ if (e->label != E_LABEL)
+ fprintf (fout, "\t\tlabel:\t%s\n", quote (e->label));
- if (edge->linestyle != E_LINESTYLE)
+ if (e->linestyle != E_LINESTYLE)
fprintf (fout, "\t\tlinestyle:\t%s\n",
- quote (get_linestyle_str(edge->linestyle)));
+ quote (get_linestyle_str (e->linestyle)));
- if (edge->thickness != E_THICKNESS)
- fprintf (fout, "\t\tthickness:\t%d\n", edge->thickness);
- if (edge->class != E_CLASS)
- fprintf (fout, "\t\tclass:\t%d\n", edge->class);
-
- if (edge->color != E_COLOR)
- fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (edge->color));
- if (edge->color != E_TEXTCOLOR)
+ if (e->thickness != E_THICKNESS)
+ fprintf (fout, "\t\tthickness:\t%d\n", e->thickness);
+ if (e->class != E_CLASS)
+ fprintf (fout, "\t\tclass:\t%d\n", e->class);
+
+ if (e->color != E_COLOR)
+ fprintf (fout, "\t\tcolor:\t%s\n", get_color_str (e->color));
+ if (e->color != E_TEXTCOLOR)
fprintf (fout, "\t\ttextcolor:\t%s\n",
- get_color_str (edge->textcolor));
- if (edge->arrowcolor != E_ARROWCOLOR)
+ get_color_str (e->textcolor));
+ if (e->arrowcolor != E_ARROWCOLOR)
fprintf (fout, "\t\tarrowcolor:\t%s\n",
- get_color_str (edge->arrowcolor));
- if (edge->backarrowcolor != E_BACKARROWCOLOR)
+ get_color_str (e->arrowcolor));
+ if (e->backarrowcolor != E_BACKARROWCOLOR)
fprintf (fout, "\t\tbackarrowcolor:\t%s\n",
- get_color_str (edge->backarrowcolor));
+ get_color_str (e->backarrowcolor));
- if (edge->arrowsize != E_ARROWSIZE)
- fprintf (fout, "\t\tarrowsize:\t%d\n", edge->arrowsize);
- if (edge->backarrowsize != E_BACKARROWSIZE)
- fprintf (fout, "\t\tbackarrowsize:\t%d\n", edge->backarrowsize);
+ if (e->arrowsize != E_ARROWSIZE)
+ fprintf (fout, "\t\tarrowsize:\t%d\n", e->arrowsize);
+ if (e->backarrowsize != E_BACKARROWSIZE)
+ fprintf (fout, "\t\tbackarrowsize:\t%d\n", e->backarrowsize);
- if (edge->arrowstyle != E_ARROWSTYLE)
+ if (e->arrowstyle != E_ARROWSTYLE)
fprintf (fout, "\t\tarrowstyle:\t%s\n",
- get_arrowstyle_str(edge->arrowstyle));
- if (edge->backarrowstyle != E_BACKARROWSTYLE)
+ get_arrowstyle_str (e->arrowstyle));
+ if (e->backarrowstyle != E_BACKARROWSTYLE)
fprintf (fout, "\t\tbackarrowstyle:\t%s\n",
- get_arrowstyle_str(edge->backarrowstyle));
+ get_arrowstyle_str (e->backarrowstyle));
- if (edge->priority != E_PRIORITY)
- fprintf (fout, "\t\tpriority:\t%d\n", edge->priority);
- if (edge->anchor != E_ANCHOR)
- fprintf (fout, "\t\tanchor:\t%d\n", edge->anchor);
- if (edge->horizontal_order != E_HORIZONTAL_ORDER)
- fprintf (fout, "\t\thorizontal_order:\t%d\n", edge->horizontal_order);
+ if (e->priority != E_PRIORITY)
+ fprintf (fout, "\t\tpriority:\t%d\n", e->priority);
+ if (e->anchor != E_ANCHOR)
+ fprintf (fout, "\t\tanchor:\t%d\n", e->anchor);
+ if (e->horizontal_order != E_HORIZONTAL_ORDER)
+ fprintf (fout, "\t\thorizontal_order:\t%d\n", e->horizontal_order);
}
void
-output_graph (graph_t *graph, FILE *fout)
+output_graph (graph *g, FILE *fout)
{
- if (graph->title)
- fprintf (fout, "\ttitle:\t%s\n", quote (graph->title));
- if (graph->label)
- fprintf (fout, "\tlabel:\t%s\n", quote (graph->label));
+ if (g->title)
+ fprintf (fout, "\ttitle:\t%s\n", quote (g->title));
+ if (g->label)
+ fprintf (fout, "\tlabel:\t%s\n", quote (g->label));
{
int i;
for (i = 0; i < 3; ++i)
- if (graph->infos[i])
- fprintf (fout, "\tinfo%d:\t%s\n", i, quote (graph->infos[i]));
+ if (g->infos[i])
+ fprintf (fout, "\tinfo%d:\t%s\n", i, quote (g->infos[i]));
}
- if (graph->color != G_COLOR)
- fprintf (fout, "\tcolor:\t%s\n", get_color_str (graph->color));
- if (graph->textcolor != G_TEXTCOLOR)
- fprintf (fout, "\ttextcolor:\t%s\n", get_color_str (graph->textcolor));
- if (graph->bordercolor != G_BORDERCOLOR)
+ if (g->color != G_COLOR)
+ fprintf (fout, "\tcolor:\t%s\n", get_color_str (g->color));
+ if (g->textcolor != G_TEXTCOLOR)
+ fprintf (fout, "\ttextcolor:\t%s\n", get_color_str (g->textcolor));
+ if (g->bordercolor != G_BORDERCOLOR)
fprintf (fout, "\tbordercolor:\t%s\n",
- get_color_str (graph->bordercolor));
+ get_color_str (g->bordercolor));
- if (graph->width != G_WIDTH)
- fprintf (fout, "\twidth:\t%d\n", graph->width);
- if (graph->height != G_HEIGHT)
- fprintf (fout, "\theight:\t%d\n", graph->height);
- if (graph->borderwidth != G_BORDERWIDTH)
- fprintf (fout, "\tborderwidth:\t%d\n", graph->borderwidth);
-
- if (graph->x != G_X)
- fprintf (fout, "\tx:\t%d\n", graph->x);
- if (graph->y != G_Y)
- fprintf (fout, "\ty:\t%d\n", graph->y);
-
- if (graph->folding != G_FOLDING)
- fprintf (fout, "\tfolding:\t%d\n", graph->folding);
-
- if (graph->shrink != G_SHRINK)
- fprintf (fout, "\tshrink:\t%d\n", graph->shrink);
- if (graph->stretch != G_STRETCH)
- fprintf (fout, "\tstretch:\t%d\n", graph->stretch);
+ if (g->width != G_WIDTH)
+ fprintf (fout, "\twidth:\t%d\n", g->width);
+ if (g->height != G_HEIGHT)
+ fprintf (fout, "\theight:\t%d\n", g->height);
+ if (g->borderwidth != G_BORDERWIDTH)
+ fprintf (fout, "\tborderwidth:\t%d\n", g->borderwidth);
+
+ if (g->x != G_X)
+ fprintf (fout, "\tx:\t%d\n", g->x);
+ if (g->y != G_Y)
+ fprintf (fout, "\ty:\t%d\n", g->y);
+
+ if (g->folding != G_FOLDING)
+ fprintf (fout, "\tfolding:\t%d\n", g->folding);
+
+ if (g->shrink != G_SHRINK)
+ fprintf (fout, "\tshrink:\t%d\n", g->shrink);
+ if (g->expand != G_EXPAND)
+ fprintf (fout, "\texpand:\t%d\n", g->expand);
- if (graph->textmode != G_TEXTMODE)
+ if (g->textmode != G_TEXTMODE)
fprintf (fout, "\ttextmode:\t%s\n",
- get_textmode_str (graph->textmode));
+ get_textmode_str (g->textmode));
- if (graph->shape != G_SHAPE)
- fprintf (fout, "\tshape:\t%s\n", get_shape_str (graph->shape));
+ if (g->shape != G_SHAPE)
+ fprintf (fout, "\tshape:\t%s\n", get_shape_str (g->shape));
- if (graph->vertical_order != G_VERTICAL_ORDER)
- fprintf (fout, "\tvertical_order:\t%d\n", graph->vertical_order);
- if (graph->horizontal_order != G_HORIZONTAL_ORDER)
- fprintf (fout, "\thorizontal_order:\t%d\n", graph->horizontal_order);
-
- if (graph->xmax != G_XMAX)
- fprintf (fout, "\txmax:\t%d\n", graph->xmax);
- if (graph->ymax != G_YMAX)
- fprintf (fout, "\tymax:\t%d\n", graph->ymax);
-
- if (graph->xbase != G_XBASE)
- fprintf (fout, "\txbase:\t%d\n", graph->xbase);
- if (graph->ybase != G_YBASE)
- fprintf (fout, "\tybase:\t%d\n", graph->ybase);
-
- if (graph->xspace != G_XSPACE)
- fprintf (fout, "\txspace:\t%d\n", graph->xspace);
- if (graph->yspace != G_YSPACE)
- fprintf (fout, "\tyspace:\t%d\n", graph->yspace);
- if (graph->xlspace != G_XLSPACE)
- fprintf (fout, "\txlspace:\t%d\n", graph->xlspace);
-
- if (graph->xraster != G_XRASTER)
- fprintf (fout, "\txraster:\t%d\n", graph->xraster);
- if (graph->yraster != G_YRASTER)
- fprintf (fout, "\tyraster:\t%d\n", graph->yraster);
- if (graph->xlraster != G_XLRASTER)
- fprintf (fout, "\txlraster:\t%d\n", graph->xlraster);
+ if (g->vertical_order != G_VERTICAL_ORDER)
+ fprintf (fout, "\tvertical_order:\t%d\n", g->vertical_order);
+ if (g->horizontal_order != G_HORIZONTAL_ORDER)
+ fprintf (fout, "\thorizontal_order:\t%d\n", g->horizontal_order);
+
+ if (g->xmax != G_XMAX)
+ fprintf (fout, "\txmax:\t%d\n", g->xmax);
+ if (g->ymax != G_YMAX)
+ fprintf (fout, "\tymax:\t%d\n", g->ymax);
+
+ if (g->xbase != G_XBASE)
+ fprintf (fout, "\txbase:\t%d\n", g->xbase);
+ if (g->ybase != G_YBASE)
+ fprintf (fout, "\tybase:\t%d\n", g->ybase);
+
+ if (g->xspace != G_XSPACE)
+ fprintf (fout, "\txspace:\t%d\n", g->xspace);
+ if (g->yspace != G_YSPACE)
+ fprintf (fout, "\tyspace:\t%d\n", g->yspace);
+ if (g->xlspace != G_XLSPACE)
+ fprintf (fout, "\txlspace:\t%d\n", g->xlspace);
+
+ if (g->xraster != G_XRASTER)
+ fprintf (fout, "\txraster:\t%d\n", g->xraster);
+ if (g->yraster != G_YRASTER)
+ fprintf (fout, "\tyraster:\t%d\n", g->yraster);
+ if (g->xlraster != G_XLRASTER)
+ fprintf (fout, "\txlraster:\t%d\n", g->xlraster);
- if (graph->hidden != G_HIDDEN)
- fprintf (fout, "\thidden:\t%d\n", graph->hidden);
+ if (g->hidden != G_HIDDEN)
+ fprintf (fout, "\thidden:\t%d\n", g->hidden);
/* FIXME: Unallocate struct list if required.
Maybe with a little function. */
- if (graph->classname != G_CLASSNAME)
+ if (g->classname != G_CLASSNAME)
{
- struct classname_s *ite;
+ struct classname *ite;
- for (ite = graph->classname; ite; ite = ite->next)
+ for (ite = g->classname; ite; ite = ite->next)
fprintf (fout, "\tclassname %d :\t%s\n", ite->no, ite->name);
}
- if (graph->infoname != G_INFONAME)
+ if (g->infoname != G_INFONAME)
{
- struct infoname_s *ite;
+ struct infoname *ite;
- for (ite = graph->infoname; ite; ite = ite->next)
- fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->string);
+ for (ite = g->infoname; ite; ite = ite->next)
+ fprintf (fout, "\tinfoname %d :\t%s\n", ite->integer, ite->chars);
}
- if (graph->colorentry != G_COLORENTRY)
+ if (g->colorentry != G_COLORENTRY)
{
- struct colorentry_s *ite;
+ struct colorentry *ite;
- for (ite = graph->colorentry; ite; ite = ite->next)
+ for (ite = g->colorentry; ite; ite = ite->next)
{
fprintf (fout, "\tcolorentry %d :\t%d %d %d\n",
ite->color_index,
@@ -765,110 +767,110 @@ output_graph (graph_t *graph, FILE *fout
}
}
- if (graph->layoutalgorithm != G_LAYOUTALGORITHM)
+ if (g->layoutalgorithm != G_LAYOUTALGORITHM)
fprintf (fout, "\tlayoutalgorithm:\t%s\n",
- get_layoutalgorithm_str(graph->layoutalgorithm));
+ get_layoutalgorithm_str (g->layoutalgorithm));
- if (graph->layout_downfactor != G_LAYOUT_DOWNFACTOR)
- fprintf (fout, "\tlayout_downfactor:\t%d\n", graph->layout_downfactor);
- if (graph->layout_upfactor != G_LAYOUT_UPFACTOR)
- fprintf (fout, "\tlayout_upfactor:\t%d\n", graph->layout_upfactor);
- if (graph->layout_nearfactor != G_LAYOUT_NEARFACTOR)
- fprintf (fout, "\tlayout_nearfactor:\t%d\n", graph->layout_nearfactor);
- if (graph->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)
+ if (g->layout_downfactor != G_LAYOUT_DOWNFACTOR)
+ fprintf (fout, "\tlayout_downfactor:\t%d\n", g->layout_downfactor);
+ if (g->layout_upfactor != G_LAYOUT_UPFACTOR)
+ fprintf (fout, "\tlayout_upfactor:\t%d\n", g->layout_upfactor);
+ if (g->layout_nearfactor != G_LAYOUT_NEARFACTOR)
+ fprintf (fout, "\tlayout_nearfactor:\t%d\n", g->layout_nearfactor);
+ if (g->layout_splinefactor != G_LAYOUT_SPLINEFACTOR)
fprintf (fout, "\tlayout_splinefactor:\t%d\n",
- graph->layout_splinefactor);
+ g->layout_splinefactor);
- if (graph->late_edge_labels != G_LATE_EDGE_LABELS)
+ if (g->late_edge_labels != G_LATE_EDGE_LABELS)
fprintf (fout, "\tlate_edge_labels:\t%s\n",
- get_decision_str(graph->late_edge_labels));
- if (graph->display_edge_labels != G_DISPLAY_EDGE_LABELS)
+ get_decision_str (g->late_edge_labels));
+ if (g->display_edge_labels != G_DISPLAY_EDGE_LABELS)
fprintf (fout, "\tdisplay_edge_labels:\t%s\n",
- get_decision_str(graph->display_edge_labels));
- if (graph->dirty_edge_labels != G_DIRTY_EDGE_LABELS)
+ get_decision_str (g->display_edge_labels));
+ if (g->dirty_edge_labels != G_DIRTY_EDGE_LABELS)
fprintf (fout, "\tdirty_edge_labels:\t%s\n",
- get_decision_str(graph->dirty_edge_labels));
- if (graph->finetuning != G_FINETUNING)
+ get_decision_str (g->dirty_edge_labels));
+ if (g->finetuning != G_FINETUNING)
fprintf (fout, "\tfinetuning:\t%s\n",
- get_decision_str(graph->finetuning));
- if (graph->ignore_singles != G_IGNORE_SINGLES)
+ get_decision_str (g->finetuning));
+ if (g->ignore_singles != G_IGNORE_SINGLES)
fprintf (fout, "\tignore_singles:\t%s\n",
- get_decision_str(graph->ignore_singles));
- if (graph->straight_phase != G_STRAIGHT_PHASE)
- fprintf (fout, "\tstraight_phase:\t%s\n",
- get_decision_str(graph->straight_phase));
- if (graph->priority_phase != G_PRIORITY_PHASE)
+ get_decision_str (g->ignore_singles));
+ if (g->long_straight_phase != G_LONG_STRAIGHT_PHASE)
+ fprintf (fout, "\tlong_straight_phase:\t%s\n",
+ get_decision_str (g->long_straight_phase));
+ if (g->priority_phase != G_PRIORITY_PHASE)
fprintf (fout, "\tpriority_phase:\t%s\n",
- get_decision_str(graph->priority_phase));
- if (graph->manhattan_edges != G_MANHATTAN_EDGES)
+ get_decision_str (g->priority_phase));
+ if (g->manhattan_edges != G_MANHATTAN_EDGES)
fprintf (fout,
"\tmanhattan_edges:\t%s\n",
- get_decision_str(graph->manhattan_edges));
- if (graph->smanhattan_edges != G_SMANHATTAN_EDGES)
+ get_decision_str (g->manhattan_edges));
+ if (g->smanhattan_edges != G_SMANHATTAN_EDGES)
fprintf (fout,
"\tsmanhattan_edges:\t%s\n",
- get_decision_str(graph->smanhattan_edges));
- if (graph->near_edges != G_NEAR_EDGES)
+ get_decision_str (g->smanhattan_edges));
+ if (g->near_edges != G_NEAR_EDGES)
fprintf (fout, "\tnear_edges:\t%s\n",
- get_decision_str(graph->near_edges));
+ get_decision_str (g->near_edges));
- if (graph->orientation != G_ORIENTATION)
+ if (g->orientation != G_ORIENTATION)
fprintf (fout, "\torientation:\t%s\n",
- get_orientation_str(graph->orientation));
+ get_orientation_str (g->orientation));
- if (graph->node_alignement != G_NODE_ALIGNEMENT)
- fprintf (fout, "\tnode_alignement:\t%s\n",
- get_node_alignement_str(graph->node_alignement));
+ if (g->node_alignment != G_NODE_ALIGNMENT)
+ fprintf (fout, "\tnode_alignment:\t%s\n",
+ get_node_alignment_str (g->node_alignment));
- if (graph->port_sharing != G_PORT_SHARING)
+ if (g->port_sharing != G_PORT_SHARING)
fprintf (fout, "\tport_sharing:\t%s\n",
- get_decision_str(graph->port_sharing));
+ get_decision_str (g->port_sharing));
- if (graph->arrow_mode != G_ARROW_MODE)
+ if (g->arrow_mode != G_ARROW_MODE)
fprintf (fout, "\tarrow_mode:\t%s\n",
- get_arrow_mode_str(graph->arrow_mode));
+ get_arrow_mode_str (g->arrow_mode));
- if (graph->treefactor != G_TREEFACTOR)
- fprintf (fout, "\ttreefactor:\t%f\n", graph->treefactor);
- if (graph->spreadlevel != G_SPREADLEVEL)
- fprintf (fout, "\tspreadlevel:\t%d\n", graph->spreadlevel);
+ if (g->treefactor != G_TREEFACTOR)
+ fprintf (fout, "\ttreefactor:\t%f\n", g->treefactor);
+ if (g->spreadlevel != G_SPREADLEVEL)
+ fprintf (fout, "\tspreadlevel:\t%d\n", g->spreadlevel);
- if (graph->crossing_weight != G_CROSSING_WEIGHT)
+ if (g->crossing_weight != G_CROSSING_WEIGHT)
fprintf (fout, "\tcrossing_weight:\t%s\n",
- get_crossing_type_str(graph->crossing_weight));
- if (graph->crossing_phase2 != G_CROSSING_PHASE2)
+ get_crossing_type_str (g->crossing_weight));
+ if (g->crossing_phase2 != G_CROSSING_PHASE2)
fprintf (fout, "\tcrossing_phase2:\t%s\n",
- get_decision_str(graph->crossing_phase2));
- if (graph->crossing_optimization != G_CROSSING_OPTIMIZATION)
+ get_decision_str (g->crossing_phase2));
+ if (g->crossing_optimization != G_CROSSING_OPTIMIZATION)
fprintf (fout, "\tcrossing_optimization:\t%s\n",
- get_decision_str(graph->crossing_optimization));
+ get_decision_str (g->crossing_optimization));
- if (graph->view != G_VIEW)
- fprintf (fout, "\tview:\t%s\n", get_view_str(graph->view));
+ if (g->view != G_VIEW)
+ fprintf (fout, "\tview:\t%s\n", get_view_str (g->view));
- if (graph->edges != G_EDGES)
- fprintf (fout, "\tedges:\t%s\n", get_decision_str(graph->edges));
+ if (g->edges != G_EDGES)
+ fprintf (fout, "\tedges:\t%s\n", get_decision_str (g->edges));
- if (graph->nodes != G_NODES)
- fprintf (fout,"\tnodes:\t%s\n", get_decision_str(graph->nodes));
-
- if (graph->splines != G_SPLINES)
- fprintf (fout, "\tsplines:\t%s\n", get_decision_str(graph->splines));
-
- if (graph->bmax != G_BMAX)
- fprintf (fout, "\tbmax:\t%d\n", graph->bmax);
- if (graph->cmin != G_CMIN)
- fprintf (fout, "\tcmin:\t%d\n", graph->cmin);
- if (graph->cmax != G_CMAX)
- fprintf (fout, "\tcmax:\t%d\n", graph->cmax);
- if (graph->pmin != G_PMIN)
- fprintf (fout, "\tpmin:\t%d\n", graph->pmin);
- if (graph->pmax != G_PMAX)
- fprintf (fout, "\tpmax:\t%d\n", graph->pmax);
- if (graph->rmin != G_RMIN)
- fprintf (fout, "\trmin:\t%d\n", graph->rmin);
- if (graph->rmax != G_RMAX)
- fprintf (fout, "\trmax:\t%d\n", graph->rmax);
- if (graph->smax != G_SMAX)
- fprintf (fout, "\tsmax:\t%d\n", graph->smax);
+ if (g->nodes != G_NODES)
+ fprintf (fout,"\tnodes:\t%s\n", get_decision_str (g->nodes));
+
+ if (g->splines != G_SPLINES)
+ fprintf (fout, "\tsplines:\t%s\n", get_decision_str (g->splines));
+
+ if (g->bmax != G_BMAX)
+ fprintf (fout, "\tbmax:\t%d\n", g->bmax);
+ if (g->cmin != G_CMIN)
+ fprintf (fout, "\tcmin:\t%d\n", g->cmin);
+ if (g->cmax != G_CMAX)
+ fprintf (fout, "\tcmax:\t%d\n", g->cmax);
+ if (g->pmin != G_PMIN)
+ fprintf (fout, "\tpmin:\t%d\n", g->pmin);
+ if (g->pmax != G_PMAX)
+ fprintf (fout, "\tpmax:\t%d\n", g->pmax);
+ if (g->rmin != G_RMIN)
+ fprintf (fout, "\trmin:\t%d\n", g->rmin);
+ if (g->rmax != G_RMAX)
+ fprintf (fout, "\trmax:\t%d\n", g->rmax);
+ if (g->smax != G_SMAX)
+ fprintf (fout, "\tsmax:\t%d\n", g->smax);
}
Index: src/vcg.h
===================================================================
RCS file: /cvsroot/bison/bison/src/vcg.h,v
retrieving revision 1.5
diff -p -u -r1.5 vcg.h
--- src/vcg.h 21 Oct 2002 05:30:50 -0000 1.5
+++ src/vcg.h 11 Dec 2002 05:09:26 -0000
@@ -22,7 +22,7 @@
# define VCG_H_
/* VCG color map. The 32 prime predefined colors. */
-enum color_e
+enum color
{
white = 0,
blue,
@@ -59,7 +59,7 @@ enum color_e
};
/* VCG textmode. Specify the adjustement of the text within the border of a
summary node. */
-enum textmode_e
+enum textmode
{
centered,
left_justify,
@@ -67,7 +67,7 @@ enum textmode_e
};
/* VCG shapes. Used for nodes shapes. */
-enum shape_e
+enum shape
{
box,
rhomb,
@@ -76,34 +76,34 @@ enum shape_e
};
/* Structure for colorentries. */
-struct colorentry_s
+struct colorentry
{
int color_index;
int red_cp;
int green_cp;
int blue_cp;
- struct colorentry_s *next;
+ struct colorentry *next;
};
/* Structure to construct lists of classnames. */
-struct classname_s
+struct classname
{
int no; /* Class number */
const char *name; /* Name associated to the class no. */
- struct classname_s *next; /* next name class association. */
+ struct classname *next; /* next name class association. */
};
/* Structure is in infoname. */
-struct infoname_s
+struct infoname
{
int integer;
- const char *string;
- struct infoname_s *next;
+ char const *chars;
+ struct infoname *next;
};
/* Layout Algorithms which can be found in VCG.
Details about each algoithm can be found below. */
-enum layoutalgorithm_e
+enum layoutalgorithm
{
normal,
maxdepth,
@@ -122,14 +122,14 @@ enum layoutalgorithm_e
};
/* VCG decision yes/no. */
-enum decision_e
+enum decision
{
yes,
no
};
/* VCG graph orientation. */
-enum orientation_e
+enum orientation
{
top_to_bottom,
bottom_to_top,
@@ -137,8 +137,8 @@ enum orientation_e
right_to_left
};
-/* VCG alignement for node alignement. */
-enum alignement_e
+/* VCG alignment for node alignement. */
+enum alignment
{
center,
top,
@@ -146,14 +146,14 @@ enum alignement_e
};
/* VCG arrow mode. */
-enum arrow_mode_e
+enum arrow_mode
{
fixed,
free_a
};
/* VCG crossing weight type. */
-enum crossing_type_e
+enum crossing_type
{
bary,
median,
@@ -162,7 +162,7 @@ enum crossing_type_e
};
/* VCG views. */
-enum view_e
+enum view
{
normal_view,
cfish,
@@ -175,7 +175,7 @@ enum view_e
| Node attributs list. structure that describes a node. |
`------------------------------------------------------*/
-struct node_s
+struct node
{
/* Title the unique string identifying the node. This attribute is
mandatory. */
@@ -231,18 +231,18 @@ struct node_s
int width;
int height;
- /* shrink, stretch gives the shrinking and stretching factor of the
+ /* shrink, expand gives the shrinking and expanding factor of the
node. The values of the attributes width, height, borderwidth and
- the size of the label text is scaled by ((stretch=shrink) \Lambda
+ the size of the label text is scaled by ((expand=shrink) \Lambda
100) percent. Note that the actual scale value is determined by the
scale value of a node relatively to a scale value of the graph,
- i.e. if (stretch,shrink) = (2,1) for the graph and (stretch,shrink)
+ i.e. if (expand,shrink) = (2,1) for the graph and (expand,shrink)
= (2,1) for the node of the graph, then the node is scaled by the
factor 4 compared to the normal size. The scale value can also be
specified by scaling: float.
Default are 1,1. */
int shrink;
- int stretch;
+ int expand;
/* folding specifies the default folding of the nodes. The folding k
(with k ? 0) means that the graph part that is reachable via edges
@@ -268,12 +268,12 @@ struct node_s
and triangle. The drawing of ellipses is much slower than the drawing
of the other shapes.
Default is box. */
- enum shape_e shape;
+ enum shape shape;
/* textmode specifies the adjustment of the text within the border of a
node. The possibilities are center, left.justify and right.justify.
Default is center. */
- enum textmode_e textmode;
+ enum textmode textmode;
/* borderwidth specifies the thickness of the node's border in pixels.
color is the background color of the node. If none is given, the
@@ -284,13 +284,13 @@ struct node_s
/* node color.
Default is white or transparent, */
- enum color_e color;
+ enum color color;
/* textcolor is the color for the label text. bordercolor is the color
of the border. Default color is the textcolor. info1, info2, info3
combines additional text labels with a node or a folded graph. info1,
Default is black. */
- enum color_e textcolor;
+ enum color textcolor;
/* info2, info3 can be selected from the menu. The corresponding text
labels can be shown by mouse clicks on nodes.
@@ -299,14 +299,14 @@ struct node_s
/* Node border color.
Default is textcolor. */
- enum color_e bordercolor;
+ enum color bordercolor;
/* Next node node... */
- struct node_s *next;
+ struct node *next;
};
/* typedef alias. */
-typedef struct node_s node_t;
+typedef struct node node;
/*-------------------------------------------------------.
| Edge attributs list. Structure that describes an edge. |
@@ -322,7 +322,7 @@ enum edge_type
};
/* Structs enum definitions for edges. */
-enum linestyle_e
+enum linestyle
{
continuous,
dashed,
@@ -330,15 +330,15 @@ enum linestyle_e
invisible
};
-enum arrowstyle_e
+enum arrowstyle
{
solid,
line,
none
};
-/* The struct edge_s itself. */
-struct edge_s
+/* The struct edge itself. */
+struct edge
{
/* Edge type.
@@ -365,7 +365,7 @@ struct edge_s
drawn. The attributes of its shape (color, thickness) are ignored.
To draw a dashed or dotted line needs more time than solid lines.
Default is continuous. */
- enum linestyle_e linestyle;
+ enum linestyle linestyle;
/* Thickness is the thickness of an edge.
Default is 2. */
@@ -379,7 +379,7 @@ struct edge_s
/* color is the color of the edge.
Default is black. */
- enum color_e color;
+ enum color color;
/* textcolor is the color of the label of the edge. arrowcolor,
backarrowcolor is the color of the arrow head and of the backarrow
@@ -388,15 +388,15 @@ struct edge_s
of edges that pull a node into its position. The priority of an edges
corresponds to the strength of the rubberband.
Default is color. */
- enum color_e textcolor;
+ enum color textcolor;
/* Arrow color.
Default is color. */
- enum color_e arrowcolor;
+ enum color arrowcolor;
/* BackArrow color.
Default is color. */
- enum color_e backarrowcolor;
+ enum color backarrowcolor;
/* arrowsize, backarrowsize The arrow head is a right-angled, isosceles
triangle and the cathetuses have length arrowsize.
@@ -415,10 +415,10 @@ struct edge_s
backarrowstyle is the style of the backarrow head. Styles are none,
i.e. no arrow head, solid, and line.
Default is solid. */
- enum arrowstyle_e arrowstyle;
+ enum arrowstyle arrowstyle;
/* Default is none. */
- enum arrowstyle_e backarrowstyle;
+ enum arrowstyle backarrowstyle;
/* Default is 1. */
int priority;
@@ -448,20 +448,20 @@ struct edge_s
/*
** Next edge node...
*/
- struct edge_s *next;
+ struct edge *next;
};
/*
** typedef alias.
*/
-typedef struct edge_s edge_t;
+typedef struct edge edge;
/*--------------------------------------------------------.
| Graph attributs list. Structure that describes a graph. |
`--------------------------------------------------------*/
-struct graph_s
+struct graph
{
/* Graph title or name.
Title specifies the name (a string) associated with the graph. The
@@ -501,19 +501,19 @@ struct graph_s
index 2, green has index 3, etc.
Default is white for background and white or transparent for summary
nodes. */
- enum color_e color;
+ enum color color;
/* Textcolor.
need explainations ???
defalut is black for summary nodes. */
- enum color_e textcolor;
+ enum color textcolor;
/* Bordercolor is the color of the summary node's border. Default color
is the textcolor. width, height are width and height of the
displayed part of the window of the outermost graph in pixels, or
width and height of the summary node of inner subgraphs.
Default is the defalut of the textcolor. */
- enum color_e bordercolor;
+ enum color bordercolor;
/* Width, height are width and height of the displayed part of the
window of the outermost graph in pixels, or width and height of the
@@ -541,22 +541,22 @@ struct graph_s
Defalut value is 0 */
int folding;
- /* Shrink, stretch gives the shrinking and stretching factor for the
- graph's representation (default is 1, 1). ((stretch=shrink) \Lambda
+ /* Shrink, expand gives the shrinking and expanding factor for the
+ graph's representation (default is 1, 1). ((expand=shrink) \Lambda
100) is the scaling of the graph in percentage, e.g.,
- (stretch,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size,
- (stretch,shrink) = (1,2) is half size, (stretch,shrink) = (2,1) is
+ (expand,shrink) = (1,1) or (2,2) or (3,3) : : : is normal size,
+ (expand,shrink) = (1,2) is half size, (expand,shrink) = (2,1) is
double size. For subgraphs, it is also the scaling factor of the
summary node. The scaling factor can also be specified by scaling:
float (here, scaling 1.0 means normal size). */
int shrink;
- int stretch;
+ int expand;
/* textmode specifies the adjustment of the text within the border of a
summary node. The possibilities are center, left.justify and
right.justify.
Default value is center.*/
- enum textmode_e textmode;
+ enum textmode textmode;
/* Shape can be specified for subgraphs only. It is the shape of the
subgraph summary node that appears if the subgraph is folded: box,
@@ -575,7 +575,7 @@ struct graph_s
influences only the order of the child nodes at a node, but not the
order of the whole level.
Defalut is box, other: rhomb, ellipse, triangle. */
- enum shape_e shape;
+ enum shape shape;
/* Vertical order is the level position (rank) of the summary node of an
inner subgraph, if this subgraph is folded. We can also specify
@@ -605,7 +605,7 @@ struct graph_s
int xmax;
int ymax;
- /* xy-base: specify the upper left corner coordonates of the graph
+ /* xy-base: specify the upper left corner coordinates of the graph
relatively to the root window.
Defaults are 5, 5. */
int xbase;
@@ -661,13 +661,13 @@ struct graph_s
additional text labels. The names are used in the menus.
defaults are 1,2,3...
By default, no class names. */
- struct classname_s *classname;
+ struct classname *classname;
/* Infoname allows to introduce names for the additional text labels.
The names are used in the menus.
Infoname is given by an integer and a string.
The default value is NULL. */
- struct infoname_s *infoname;
+ struct infoname *infoname;
/* Colorentry allows to fill the color map. A color is a triplet of integer
values for the red/green/blue-part. Each integer is between 0 (off) and
@@ -675,7 +675,7 @@ struct graph_s
colorentry 75 : 70 130 180 sets the map entry 75 to steel blue. This
color can be used by specifying just the number 75.
Default id NULL. */
- struct colorentry_s *colorentry;
+ struct colorentry *colorentry;
/* layoutalgorithm chooses different graph layout algorithms
Possibilities are maxdepth, mindepth, maxdepthslow, mindepthslow,
@@ -703,7 +703,7 @@ struct graph_s
trees. It is much faster on such tree-like graphs and results in a
balanced layout.
Default is normal. */
- enum layoutalgorithm_e layoutalgorithm;
+ enum layoutalgorithm layoutalgorithm;
/* Layout downfactor, layout upfactor, layout nearfactor The layout
algorithm partitions the set of edges into edges pointing upward,
@@ -731,40 +731,40 @@ struct graph_s
labels and then partitions the graph, which yield a more compact
layout, but may have more crossings.
Default is no. */
- enum decision_e late_edge_labels;
+ enum decision late_edge_labels;
/* Display edge labels yes means display labels and no means don't
display edge labels.
Default vaule is no. */
- enum decision_e display_edge_labels;
+ enum decision display_edge_labels;
/* Dirty edge labels yes enforces a fast layout of edge labels, which
may very ugly because several labels may be drawn at the same place.
Dirty edge labels cannot be used if splines are used.
Default is no.
*/
- enum decision_e dirty_edge_labels;
+ enum decision dirty_edge_labels;
/* Finetuning no switches the fine tuning phase of the graph layout
algorithm off, while it is on as default. The fine tuning phase
tries to give all edges the same length.
Default is yes. */
- enum decision_e finetuning;
+ enum decision finetuning;
/* Ignore singles yes hides all nodes which would appear single and
unconnected from the remaining graph. Such nodes have no edge at all
and are sometimes very ugly. Default is to show all nodes.
Default is no. */
- enum decision_e ignore_singles;
+ enum decision ignore_singles;
- /* Straight phase yes initiates an additional phase that tries to avoid
+ /* Long straight phase yes initiates an additional phase that tries to avoid
bendings in long edges.
Long edges are laid out by long straight vertical lines with
gradient 90 degree. Thus, this phase is not very appropriate for
normal layout, but it is recommended, if an orthogonal layout is
selected (see manhattan.edges).
Default is no. */
- enum decision_e straight_phase;
+ enum decision long_straight_phase;
/* priority phase yes replaces the normal pendulum method by a
specialized method: It forces straight long edges with 90 degree,
@@ -772,7 +772,7 @@ struct graph_s
tune phase of the priority method. This phase is also recommended,
if an orthogonal layout is selected (see manhattan.edges).
Default is no. */
- enum decision_e priority_phase;
+ enum decision priority_phase;
/* manhattan edges yes switches the orthogonal layout on. Orthogonal
layout (or manhattan layout) means that all edges consist of line
@@ -784,7 +784,7 @@ struct graph_s
on, too, unless priority layout and straight line tuning are
switched off explicitly.
Default is no. */
- enum decision_e manhattan_edges;
+ enum decision manhattan_edges;
/* Smanhattan edges yes switches a specialized orthogonal layout on:
Here, all horizontal edge segments between two levels share the same
@@ -793,12 +793,12 @@ struct graph_s
looks nice for trees but might be too confusing in general, because
the location of an edge might be ambiguously.
Default is no. */
- enum decision_e smanhattan_edges;
+ enum decision smanhattan_edges;
/* Near edges no suppresses near edges and bent near edges in the
graph layout.
Default is yes. */
- enum decision_e near_edges;
+ enum decision near_edges;
/* Orientation specifies the orientation of the graph: top.to.bottom,
bottom.to.top, left.to.right or right.to.left. Note: the normal
@@ -807,7 +807,7 @@ struct graph_s
is left to right, the attribute xlspace is not the horizontal but
the vertical distance between lines, etc.
Default is to_to_bottom. */
- enum orientation_e orientation;
+ enum orientation orientation;
/* Node alignment specified the vertical alignment of nodes at the
horizontal reference line of the levels. If top is specified, the
@@ -815,7 +815,7 @@ struct graph_s
the bottoms have the same y-coordinate, on center the nodes are
centered at the levels.
Default is center. */
- enum alignement_e node_alignement;
+ enum alignment node_alignment;
/* Port sharing no suppresses the sharing of ports of edges at the
nodes. Normally, if multiple edges are adjacent to the same node,
@@ -827,7 +827,7 @@ struct graph_s
is used, each edge has its own port, i.e. its own place where it is
adjacent to the node.
Default is yes. */
- enum decision_e port_sharing;
+ enum decision port_sharing;
/* Arrow mode fixed (default) should be used, if port sharing is used,
because then, only a fixed set of rotations for the arrow heads are
@@ -838,7 +838,7 @@ struct graph_s
arrow mode is fixed, then the arrow head is rotated only in steps of
45 degree, and only one arrow head occurs at each port.
Default is fixed. */
- enum arrow_mode_e arrow_mode;
+ enum arrow_mode arrow_mode;
/* Treefactor The algorithm tree for downward laid out trees tries to
produce a medium dense, balanced tree-like layout. If the tree
@@ -868,21 +868,21 @@ struct graph_s
different nodes are not very probable, thus the crossing reduction
phase 2 might be very fast.
Default is bary. */
- enum crossing_type_e crossing_weight;
+ enum crossing_type crossing_weight;
/* Crossing phase2 is the most time consuming phase of the crossing
reduction. In this phase, the nodes that happen to have equal
crossing weights are permuted. By specifying no, this phase is
suppressed.
Default is yes. */
- enum decision_e crossing_phase2;
+ enum decision crossing_phase2;
/* Crossing optimization is a postprocessing phase after the normal
crossing reduction: we try to optimize locally, by exchanging pairs
of nodes to reduce the crossings. Although this phase is not very
time consuming, it can be suppressed by specifying no.
Default is yes. */
- enum decision_e crossing_optimization;
+ enum decision crossing_optimization;
/* View allows to select the fisheye views. Because
of the fixed size of the window that shows the graph, we normally
@@ -907,15 +907,15 @@ struct graph_s
selected that shows the whole graph, and with fpfish the fixed
radius polar fisheye is selected.
Defalut is normal view. */
- enum view_e view;
+ enum view view;
/* Edges no suppresses the drawing of edges.
Default is yes. */
- enum decision_e edges;
+ enum decision edges;
/* Nodes no suppresses the drawing of nodes.
Default is yes. */
- enum decision_e nodes;
+ enum decision nodes;
/* Splines specifies whether splines are used to draw edges (yes or no).
As default, polygon segments are used to draw edges, because this is
@@ -923,7 +923,7 @@ struct graph_s
validated, and is very slow. Its use is mainly to prepare high
quality PostScript output for very small graphs.
Default is no. */
- enum decision_e splines;
+ enum decision splines;
/* Bmax set the maximal number of iterations that are done for the
reduction of edge bendings.
@@ -976,44 +976,44 @@ struct graph_s
/* Generic values.
*/
- node_t node;
- edge_t edge;
+ node node;
+ edge edge;
/* List of nodes declared.
Pointer. */
- node_t *node_list;
+ node *node_list;
/* List of edges declared.
Pointer. */
- edge_t *edge_list;
+ edge *edge_list;
};
/* Graph typedefs. */
-typedef struct graph_s graph_t;
+typedef struct graph graph;
-void new_graph (graph_t *g);
-void new_node (node_t *node);
-void new_edge (edge_t *edge);
+void new_graph (graph *g);
+void new_node (node *n);
+void new_edge (edge *e);
-void add_node (graph_t *graph, node_t *node);
-void add_edge (graph_t *graph, edge_t *edge);
+void add_node (graph *g, node *n);
+void add_edge (graph *g, edge *e);
-void add_colorentry (graph_t *g, int color_idx, int red_cp,
+void add_colorentry (graph *g, int color_idx, int red_cp,
int green_cp, int blue_cp);
-void add_classname (graph_t *g, int val, const char *name);
-void add_infoname (graph_t *g, int val, const char *name);
+void add_classname (graph *g, int val, const char *name);
+void add_infoname (graph *g, int val, const char *name);
void open_node (FILE *fout);
-void output_node (node_t *node, FILE *fout);
+void output_node (node *n, FILE *fout);
void close_node (FILE *fout);
-void open_edge (edge_t *edge, FILE *fout);
-void output_edge (edge_t *edge, FILE *fout);
+void open_edge (edge *e, FILE *fout);
+void output_edge (edge *e, FILE *fout);
void close_edge (FILE *fout);
void open_graph (FILE *fout);
-void output_graph (graph_t *graph, FILE *fout);
-void close_graph (graph_t *graph, FILE *fout);
+void output_graph (graph *g, FILE *fout);
+void close_graph (graph *g, FILE *fout);
#endif /* VCG_H_ */
Index: src/vcg_defaults.h
===================================================================
RCS file: /cvsroot/bison/bison/src/vcg_defaults.h,v
retrieving revision 1.3
diff -p -u -r1.3 vcg_defaults.h
--- src/vcg_defaults.h 4 Oct 2001 14:55:21 -0000 1.3
+++ src/vcg_defaults.h 11 Dec 2002 05:09:26 -0000
@@ -42,7 +42,7 @@
# define G_FOLDING 0
# define G_SHRINK 1
-# define G_STRETCH 1
+# define G_EXPAND 1
# define G_TEXTMODE centered
# define G_SHAPE box
@@ -81,14 +81,14 @@
# define G_DIRTY_EDGE_LABELS no
# define G_FINETUNING yes
# define G_IGNORE_SINGLES no
-# define G_STRAIGHT_PHASE no
+# define G_LONG_STRAIGHT_PHASE no
# define G_PRIORITY_PHASE no
# define G_MANHATTAN_EDGES no
# define G_SMANHATTAN_EDGES no
# define G_NEAR_EDGES yes
# define G_ORIENTATION top_to_bottom
-# define G_NODE_ALIGNEMENT center
+# define G_NODE_ALIGNMENT center
# define G_PORT_SHARING yes
# define G_ARROW_MODE fixed
# define G_TREEFACTOR 0.5
@@ -129,7 +129,7 @@
# define N_HEIGHT -1 /* also. */
# define N_SHRINK 1
-# define N_STRETCH 1
+# define N_EXPAND 1
# define N_FOLDING -1 /* no explicit default value. */
Index: tests/calc.at
===================================================================
RCS file: /cvsroot/bison/bison/tests/calc.at,v
retrieving revision 1.48
diff -p -u -r1.48 calc.at
--- tests/calc.at 29 Nov 2002 08:45:14 -0000 1.48
+++ tests/calc.at 11 Dec 2002 05:09:26 -0000
@@ -50,9 +50,9 @@ AT_DATA_GRAMMAR([calc.y],
extern void perror (const char *s);
/* Exercise pre-prologue dependency to %union. */
-typedef int value_t;
+typedef int value;
-static value_t global_result = 0;
+static value global_result = 0;
static int global_count = 0;
%}
@@ -60,7 +60,7 @@ static int global_count = 0;
/* Exercise %union. */
%union
{
- value_t ival;
+ value ival;
};
%{
@@ -95,7 +95,7 @@ static int power (int base, int exponent
- %location & %pure & %glr
- %location & %pure & %yacc & %parse-param. */
static void yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
- ]AT_PARAM_IF([value_t *result, int *count, ])[
+ ]AT_PARAM_IF([value *result, int *count, ])[
const char *s
);
static int yylex (LEX_FORMALS);
@@ -149,7 +149,7 @@ static FILE *yyin;
static void
yyerror (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *yylloc, ])[
- ]AT_PARAM_IF([value_t *result, int *count, ])[
+ ]AT_PARAM_IF([value *result, int *count, ])[
const char *s
)
{
@@ -288,7 +288,7 @@ power (int base, int exponent)
int
main (int argc, const char **argv)
{
- value_t result = 0;
+ value result = 0;
int count = 0;
int status;
@@ -562,7 +562,7 @@ AT_CHECK_CALC_LALR([%error-verbose %debu
AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc])
-AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc %parse-param {value_t *result} %parse-param
{int *count}])
+AT_CHECK_CALC_LALR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param
{int *count}])
# ----------------------- #
@@ -597,4 +597,4 @@ AT_CHECK_CALC_GLR([%error-verbose %debug
AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc])
-AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc %parse-param {value_t *result} %parse-param
{int *count}])
+AT_CHECK_CALC_GLR([%pure-parser %error-verbose %debug %locations %defines
%name-prefix="calc" %verbose %yacc %parse-param {value *result} %parse-param
{int *count}])
Index: tests/input.at
===================================================================
RCS file: /cvsroot/bison/bison/tests/input.at,v
retrieving revision 1.23
diff -p -u -r1.23 input.at
--- tests/input.at 7 Dec 2002 06:15:55 -0000 1.23
+++ tests/input.at 11 Dec 2002 05:09:26 -0000
@@ -132,7 +132,7 @@ char apostrophe = '\'';
%{
/* Exercise pre-prologue dependency to %union. */
-typedef int value_t;
+typedef int value;
%}
/* Exercise M4 quoting: '@:>@@:>@', 0. */
@@ -140,13 +140,13 @@ typedef int value_t;
/* Also exercise %union. */
%union
{
- value_t ival; /* A comment to exercise an old bug. */
+ value ival; /* A comment to exercise an old bug. */
};
/* Exercise post-prologue dependency to %union. */
%{
-static YYSTYPE value_t_as_yystype (value_t val);
+static YYSTYPE value_as_yystype (value val);
/* Exercise quotes in declarations. */
char quote[] = "@:>@@:>@,";
@@ -179,7 +179,7 @@ output: '#' 'o' 'u' 't' 'p' 'u' 't' ' ';
/* Exercise M4 quoting: '@:>@@:>@', @<:@, 2. */
static YYSTYPE
-value_t_as_yystype (value_t val)
+value_as_yystype (value val)
{
YYSTYPE res;
res.ival = val;
@@ -192,7 +192,7 @@ yylex (void)
static const char *input = "@<:@address@hidden@address@hidden@&address@hidden
#output "; /* "
*/
- yylval = value_t_as_yystype (*input);
+ yylval = value_as_yystype (*input);
return *input++;
}
@@ -206,7 +206,7 @@ yyerror (const char *msg)
# Pacify Emacs'font-lock-mode: "
AT_DATA([main.c],
-[[typedef int value_t;
+[[typedef int value;
#include "input.h"
int yyparse (void);
--- /dev/null 2002-12-11 05:01:02.000000000 +0000
+++ lib/get-errno.c 2002-12-09 18:41:00.963080000 +0000
@@ -0,0 +1,45 @@
+/* get-errno.h - get and set errno.
+
+ Copyright (C) 2002 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+/* Written by Paul Eggert. */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <errno.h>
+
+#include "get-errno.h"
+
+/* Get and set errno. A source file that needs to set or get errno,
+ but doesn't need to test for specific errno values, can use these
+ functions to avoid namespace pollution. For example, a file that
+ defines EQUAL should not include <errno.h>, since <errno.h> might
+ define EQUAL; such a file can include <get-errno.h> instead. */
+
+int
+get_errno (void)
+{
+ return errno;
+}
+
+void
+set_errno (int e)
+{
+ errno = e;
+}
--- /dev/null 2002-12-11 05:01:02.000000000 +0000
+++ lib/get-errno.h 2002-12-09 18:18:48.662090000 +0000
@@ -0,0 +1,20 @@
+/* get-errno.h - get and set errno.
+
+ Copyright (C) 2002 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+extern int get_errno (void);
+extern void set_errno (int);
--- src/struniq.c.~1.4.~ 2002-11-19 08:03:33.000000000 +0000
+++ src/uniqstr.c 2002-12-09 18:14:36.203080000 +0000
@@ -19,59 +19,61 @@
Boston, MA 02111-1307, USA. */
#include "system.h"
-#include "quotearg.h"
-#include "error.h"
-#include "hash.h"
-#include "struniq.h"
+
+#include <error.h>
+#include <hash.h>
+#include <quotearg.h>
+
+#include "uniqstr.h"
/*-----------------------.
-| A struniq hash table. |
+| A uniqstr hash table. |
`-----------------------*/
-/* Initial capacity of struniq hash table. */
+/* Initial capacity of uniqstr hash table. */
#define HT_INITIAL_CAPACITY 257
-static struct hash_table *struniqs_table = NULL;
+static struct hash_table *uniqstrs_table = NULL;
/*-------------------------------------.
-| Create the struniq for S if needed. |
+| Create the uniqstr for S if needed. |
`-------------------------------------*/
-struniq_t
-struniq_new (const char *s)
+uniqstr
+uniqstr_new (const char *s)
{
- struniq_t res = hash_lookup (struniqs_table, s);
+ uniqstr res = hash_lookup (uniqstrs_table, s);
if (!res)
{
/* First insertion in the hash. */
res = xstrdup (s);
- hash_insert (struniqs_table, res);
+ hash_insert (uniqstrs_table, res);
}
return res;
}
/*------------------------------.
-| Abort if S is not a struniq. |
+| Abort if S is not a uniqstr. |
`------------------------------*/
void
-struniq_assert (const char *s)
+uniqstr_assert (const char *s)
{
- if (!hash_lookup (struniqs_table, s))
+ if (!hash_lookup (uniqstrs_table, s))
{
- error (0, 0, "not a struniq: %s", quotearg (s));
+ error (0, 0, "not a uniqstr: %s", quotearg (s));
abort ();
}
}
/*--------------------.
-| Print the struniq. |
+| Print the uniqstr. |
`--------------------*/
static bool
-struniq_print (const struniq_t s)
+uniqstr_print (const uniqstr s)
{
fprintf (stderr, "%s\n", s);
return true;
@@ -79,47 +81,47 @@
/*-----------------------.
-| A struniq hash table. |
+| A uniqstr hash table. |
`-----------------------*/
static bool
-hash_compare_struniq_t (const struniq_t m1, const struniq_t m2)
+hash_compare_uniqstr (const uniqstr m1, const uniqstr m2)
{
return strcmp (m1, m2) == 0;
}
static unsigned int
-hash_struniq_t (const struniq_t m, unsigned int tablesize)
+hash_uniqstr (const uniqstr m, unsigned int tablesize)
{
return hash_string (m, tablesize);
}
/* A function to apply to each symbol. */
-typedef bool (*struniq_processor_t) (const struniq_t);
+typedef bool (*uniqstr_processor) (const uniqstr);
/*----------------------------.
-| Create the struniqs table. |
+| Create the uniqstrs table. |
`----------------------------*/
void
-struniqs_new (void)
+uniqstrs_new (void)
{
- struniqs_table = hash_initialize (HT_INITIAL_CAPACITY,
+ uniqstrs_table = hash_initialize (HT_INITIAL_CAPACITY,
NULL,
- (Hash_hasher) hash_struniq_t,
- (Hash_comparator) hash_compare_struniq_t,
+ (Hash_hasher) hash_uniqstr,
+ (Hash_comparator) hash_compare_uniqstr,
(Hash_data_freer) free);
}
/*-------------------------------------.
-| Perform a task on all the struniqs. |
+| Perform a task on all the uniqstrs. |
`-------------------------------------*/
static void
-struniqs_do (struniq_processor_t processor, void *processor_data)
+uniqstrs_do (uniqstr_processor processor, void *processor_data)
{
- hash_do_for_each (struniqs_table,
+ hash_do_for_each (uniqstrs_table,
(Hash_processor) processor,
processor_data);
}
@@ -130,18 +132,18 @@
`-----------------*/
void
-struniqs_print (void)
+uniqstrs_print (void)
{
- struniqs_do (struniq_print, NULL);
+ uniqstrs_do (uniqstr_print, NULL);
}
/*--------------------.
-| Free the struniqs. |
+| Free the uniqstrs. |
`--------------------*/
void
-struniqs_free (void)
+uniqstrs_free (void)
{
- hash_free (struniqs_table);
+ hash_free (uniqstrs_table);
}
--- src/struniq.h.~1.4.~ 2002-11-19 08:03:33.000000000 +0000
+++ src/uniqstr.h 2002-12-09 08:48:45.939086000 +0000
@@ -18,35 +18,35 @@
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-#ifndef STRUNIQ_H_
-# define STRUNIQ_H_
+#ifndef UNIQSTR_H_
+# define UNIQSTR_H_
-/*------------------------------------------------------.
-| struniq_t -- pointers to unique copies of C strings. |
-`------------------------------------------------------*/
+/*-----------------------------------------.
+| Pointers to unique copies of C strings. |
+`-----------------------------------------*/
-typedef const char *struniq_t;
+typedef char const *uniqstr;
-/* Return the struniq for S. */
-struniq_t struniq_new (const char *s);
+/* Return the uniqstr for S. */
+uniqstr uniqstr_new (char const *s);
-/* Two struniq have the same value iff they are the same. */
-#define STRUNIQ_EQ(S1, S2) ((S1) == (S2))
+/* Two uniqstr have the same value iff they are the same. */
+#define UNIQSTR_EQ(S1, S2) ((S1) == (S2))
/*--------------------------------------.
| Initializing, destroying, debugging. |
`--------------------------------------*/
/* Create the string table. */
-void struniqs_new (void);
+void uniqstrs_new (void);
-/* Die if S is not a struniq. */
-void struniq_assert (const char *s);
+/* Die if S is not a uniqstr. */
+void uniqstr_assert (const char *s);
/* Free all the memory allocated for symbols. */
-void struniqs_free (void);
+void uniqstrs_free (void);
/* Report them all. */
-void struniqs_print (void);
+void uniqstrs_print (void);
-#endif /* !STRUNIQ_H_ */
+#endif /* ! defined UNIQSTR_H_ */
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- Bison fixes to avoid namespace collisions with POSIX, etc.,
Paul Eggert <=