[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
FYI: 15-gary-symtab-structure-renaming.patch
|
From: |
Gary V. Vaughan |
|
Subject: |
FYI: 15-gary-symtab-structure-renaming.patch |
|
Date: |
Wed, 18 Jun 2003 17:29:11 +0100 |
|
User-agent: |
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.4) Gecko/20030529 |
Applied to HEAD.
--
())_. Gary V. Vaughan gary@(oranda.demon.co.uk|gnu.org)
( '/ Research Scientist http://www.oranda.demon.co.uk ,_())____
/ )= GNU Hacker http://www.gnu.org/software/libtool \' `&
`(_~)_ Tech' Author http://sources.redhat.com/autobook =`---d__/
Index: ChangeLog
from Gary V. Vaughan <address@hidden>
Renamed some of the types and their accessors to make more sense.
Now we have a SYMTAB in which we store SYMBOLs, and each SYMBOL
has a stack of SYMBOL_VALUEs.
* m4/m4module.h (m4_token, m4_get_token_type, m4_get_token_text)
(m4_get_token_func, m4_token_copy): Renamed to m4_symbol_value,
m4_get_symbol_value_type, m4_get_symbol_value_text,
m4_get_symbol_value_func and m4_symbol_value_copy respectively.
Changed all callers.
(m4_symbol_type): s/M4_TOKEN_/M4_SYMBOL_/
(m4_get_token_type): Renamed
* m4/input.c (m4_next_token): Renamed to m4__next_token, and moved
to the internal api.
* m4/m4private.h: s/TOKEN_ARG_/SYMBOL_ARG_/
s/TOKEN_/VALUE_/
(m4__symtab_init, m4__symtab_exit): Removed prototypes.
(m4_token_arg): Renamed to m4_symbol_arg. Changed all callers.
(m4__token_type): Moved here from m4module.h.
(m4__next_token): Renamed from m4_next_token.
* m4/symtab.c: Removed some of the parameterised macro support
functions for modularisation later.
(m4_token_copy): Renamed to m4_symbol_value_copy, and use new
m4_hash_dup to perform a true deep copy of the SRC.
(arg_copy): Callback for m4_symbol_value_copy.
* utility.c (m4_token_get_type, m4_token_text, m4_token_func):
Renamed to m4_get_symbol_value_type, m4_get_symbol_value_text and
m4_get_symbol_value_func. Changed all callers.
2003-06-18 Gary V. Vaughan <address@hidden>
Index: m4/debug.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/debug.c,v
retrieving revision 1.11
diff -u -p -u -r1.11 debug.c
--- m4/debug.c 13 Oct 2001 08:56:48 -0000 1.11
+++ m4/debug.c 18 Jun 2003 16:21:32 -0000
@@ -326,7 +326,7 @@ m4_trace_prepre (const char *name, int i
/* Format the parts of a trace line, that can be made before the macro is
actually expanded. Used from expand_macro (). */
void
-m4_trace_pre (const char *name, int id, int argc, m4_token **argv)
+m4_trace_pre (const char *name, int id, int argc, m4_symbol_value **argv)
{
int i;
const m4_builtin *bp;
@@ -343,14 +343,14 @@ m4_trace_pre (const char *name, int id,
if (i != 1)
m4_trace_format (", ");
- switch (TOKEN_TYPE (argv[i]))
+ switch (VALUE_TYPE (argv[i]))
{
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
m4_trace_format ("%l%S%r", M4ARG (i));
break;
- case M4_TOKEN_FUNC:
- bp = m4_builtin_find_by_func (NULL, TOKEN_FUNC (argv[i]));
+ case M4_SYMBOL_FUNC:
+ bp = m4_builtin_find_by_func (NULL, VALUE_FUNC (argv[i]));
if (bp == NULL)
{
M4ERROR ((warning_status, 0, "\
@@ -360,7 +360,7 @@ INTERNAL ERROR: Builtin not found in bui
m4_trace_format ("<%s>", bp->name);
break;
- case M4_TOKEN_VOID:
+ case M4_SYMBOL_VOID:
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: Bad token data type (m4_trace_pre
())"));
abort ();
@@ -380,7 +380,7 @@ INTERNAL ERROR: Builtin not found in bui
/* Format the final part of a trace line and print it all. Used from
expand_macro (). */
void
-m4_trace_post (const char *name, int id, int argc, m4_token **argv,
+m4_trace_post (const char *name, int id, int argc, m4_symbol_value **argv,
const char *expanded)
{
if (debug_level & M4_DEBUG_TRACE_CALL)
Index: m4/input.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/input.c,v
retrieving revision 1.25
diff -u -p -u -r1.25 input.c
--- m4/input.c 17 Jun 2003 15:17:45 -0000 1.25
+++ m4/input.c 18 Jun 2003 16:21:32 -0000
@@ -70,7 +70,7 @@ static int file_peek (void);
static int file_read (void);
static void file_unget (int ch);
static void file_clean (void);
-static void init_builtin_token (m4_token *td);
+static void init_builtin_token (m4_symbol_value *token);
static int builtin_peek (void);
static int builtin_read (void);
static int match_input (const unsigned char *s);
@@ -306,12 +306,12 @@ static struct input_funcs builtin_funcs
};
void
-m4_push_builtin (m4_token *td)
+m4_push_builtin (m4_symbol_value *token)
{
input_block *i;
/* Make sure we were passed a builtin function type token. */
- assert (TOKEN_TYPE (td) == M4_TOKEN_FUNC);
+ assert (VALUE_TYPE (token) == M4_SYMBOL_FUNC);
if (next != NULL)
{
@@ -323,12 +323,12 @@ m4_push_builtin (m4_token *td)
sizeof (struct input_block));
i->funcs = &builtin_funcs;
- i->u.u_b.func = TOKEN_FUNC (td);
- i->u.u_b.handle = TOKEN_HANDLE (td);
- i->u.u_b.arg_signature= TOKEN_ARG_SIGNATURE (td);
- i->u.u_b.min_args = TOKEN_MIN_ARGS (td);
- i->u.u_b.max_args = TOKEN_MAX_ARGS (td);
- i->u.u_b.flags = TOKEN_FLAGS (td);
+ i->u.u_b.func = VALUE_FUNC (token);
+ i->u.u_b.handle = VALUE_HANDLE (token);
+ i->u.u_b.arg_signature= VALUE_ARG_SIGNATURE (token);
+ i->u.u_b.min_args = VALUE_MIN_ARGS (token);
+ i->u.u_b.max_args = VALUE_MAX_ARGS (token);
+ i->u.u_b.flags = VALUE_FLAGS (token);
i->u.u_b.read = FALSE;
i->prev = isp;
@@ -518,7 +518,7 @@ m4_pop_wrapup (void)
/* When a BUILTIN token is seen, next_token () uses init_builtin_token
to retrieve the value of the function pointer. */
static void
-init_builtin_token (m4_token *td)
+init_builtin_token (m4_symbol_value *token)
{
if (isp->funcs->read_func != builtin_read)
{
@@ -527,13 +527,13 @@ init_builtin_token (m4_token *td)
abort ();
}
- TOKEN_TYPE (td) = M4_TOKEN_FUNC;
- TOKEN_FUNC (td) = isp->u.u_b.func;
- TOKEN_HANDLE (td) = isp->u.u_b.handle;
- TOKEN_FLAGS (td) = isp->u.u_b.flags;
- TOKEN_ARG_SIGNATURE(td) = isp->u.u_b.arg_signature;
- TOKEN_MIN_ARGS (td) = isp->u.u_b.min_args;
- TOKEN_MAX_ARGS (td) = isp->u.u_b.max_args;
+ VALUE_TYPE (token) = M4_SYMBOL_FUNC;
+ VALUE_FUNC (token) = isp->u.u_b.func;
+ VALUE_HANDLE (token) = isp->u.u_b.handle;
+ VALUE_FLAGS (token) = isp->u.u_b.flags;
+ VALUE_ARG_SIGNATURE(token) = isp->u.u_b.arg_signature;
+ VALUE_MIN_ARGS (token) = isp->u.u_b.min_args;
+ VALUE_MAX_ARGS (token) = isp->u.u_b.max_args;
}
@@ -738,12 +738,12 @@ m4_input_exit (void)
that is not a part of any of the previous types.
M4_next_token () returns the token type, and passes back a pointer to the
- token data through TD. The token text is collected on the obstack
+ token data through VALUE. The token text is collected on the obstack
token_stack, which never contains more than one token text at a time.
- The storage pointed to by the fields in TD is therefore subject to
+ The storage pointed to by the fields in VALUE is therefore subject to
change the next time next_token () is called. */
m4__token_type
-m4_next_token (m4_token *td)
+m4__next_token (m4_symbol_value *token)
{
int ch;
int quote_level;
@@ -765,10 +765,10 @@ m4_next_token (m4_token *td)
if (ch == CHAR_BUILTIN) /* BUILTIN TOKEN */
{
- init_builtin_token (td);
+ init_builtin_token (token);
(void) next_char ();
#ifdef DEBUG_INPUT
- print_token ("next_token", M4_TOKEN_MACDEF, td);
+ print_token ("next_token", M4_TOKEN_MACDEF, token);
#endif
return M4_TOKEN_MACDEF;
}
@@ -939,15 +939,15 @@ m4_next_token (m4_token *td)
obstack_1grow (&token_stack, '\0');
- bzero (td, sizeof (m4_token));
+ bzero (token, sizeof (m4_symbol_value));
- TOKEN_TYPE (td) = M4_TOKEN_TEXT;
- TOKEN_TEXT (td) = obstack_finish (&token_stack);
- TOKEN_MIN_ARGS (td) = -1;
- TOKEN_MAX_ARGS (td) = -1;
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (token) = obstack_finish (&token_stack);
+ VALUE_MIN_ARGS (token) = -1;
+ VALUE_MAX_ARGS (token) = -1;
#ifdef DEBUG_INPUT
- print_token("next_token", type, td);
+ print_token("next_token", type, token);
#endif
return type;
@@ -960,29 +960,29 @@ m4_next_token (m4_token *td)
static void lex_debug (void);
int
-m4_print_token (const char *s, m4__token_type type, m4_token *token)
+m4_print_token (const char *s, m4__token_type type, m4_symbol_value *token)
{
fprintf (stderr, "%s: ", s);
switch (type)
{ /* TOKSW */
case M4_TOKEN_SIMPLE:
- fprintf (stderr, "char\t\"%s\"\n", TOKEN_TEXT (token));
+ fprintf (stderr, "char\t\"%s\"\n", VALUE_TEXT (token));
break;
case M4_TOKEN_WORD:
- fprintf (stderr, "word\t\"%s\"\n", TOKEN_TEXT (token));
+ fprintf (stderr, "word\t\"%s\"\n", VALUE_TEXT (token));
break;
case M4_TOKEN_STRING:
- fprintf (stderr, "string\t\"%s\"\n", TOKEN_TEXT (token));
+ fprintf (stderr, "string\t\"%s\"\n", VALUE_TEXT (token));
break;
case M4_TOKEN_SPACE:
- fprintf (stderr, "space\t\"%s\"\n", TOKEN_TEXT (token));
+ fprintf (stderr, "space\t\"%s\"\n", VALUE_TEXT (token));
break;
case M4_TOKEN_MACDEF:
- fprintf (stderr, "builtin 0x%x\n", (int) TOKEN_FUNC (token));
+ fprintf (stderr, "builtin 0x%x\n", (int) VALUE_FUNC (token));
break;
case M4_TOKEN_EOF:
@@ -1000,7 +1000,7 @@ static void
lex_debug (void)
{
m4__token_type type;
- m4_token token;
+ m4_symbol_value token;
while ((type = next_token (&token)) != NULL)
print_token ("lex", type, &token);
Index: m4/m4module.h
===================================================================
RCS file: /cvsroot/m4/m4/m4/m4module.h,v
retrieving revision 1.48
diff -u -p -u -r1.48 m4module.h
--- m4/m4module.h 17 Jun 2003 15:17:45 -0000 1.48
+++ m4/m4module.h 18 Jun 2003 16:21:32 -0000
@@ -32,11 +32,11 @@ BEGIN_C_DECLS
typedef struct m4 m4;
typedef struct m4_symbol m4_symbol;
-typedef struct m4_token m4_token;
+typedef struct m4_symbol_value m4_symbol_value;
typedef struct m4_hash m4_symtab;
-typedef void m4_builtin_func (m4 *, struct obstack *, int, m4_token **);
+typedef void m4_builtin_func (m4 *, struct obstack *, int, m4_symbol_value **);
typedef void *m4_module_func (const char *);
typedef struct {
@@ -94,15 +94,15 @@ typedef int m4_symtab_apply_func (m4_sym
extern m4_symtab *m4_symtab_create (size_t);
extern void m4_symtab_delete (m4_symtab*);
-extern int m4_symtab_apply (m4_symtab*, m4_symtab_apply_func*, void*);
+extern void * m4_symtab_apply (m4_symtab*, m4_symtab_apply_func*, void*);
#define m4_symtab_apply(symtab, func, userdata)
\
(m4_hash_apply ((m4_hash*)(symtab), (m4_hash_apply_func*)(func), (userdata)))
extern m4_symbol *m4_symbol_lookup (m4_symtab*, const char *);
-extern m4_symbol *m4_symbol_pushdef (m4_symtab*, const char *, m4_token *);
-extern m4_symbol *m4_symbol_define (m4_symtab*, const char *, m4_token *);
+extern m4_symbol *m4_symbol_pushdef (m4_symtab*, const char *, m4_symbol_value
*);
+extern m4_symbol *m4_symbol_define (m4_symtab*, const char *, m4_symbol_value
*);
extern void m4_symbol_popdef (m4_symtab*, const char *);
extern void m4_symbol_delete (m4_symtab*, const char *);
@@ -113,22 +113,12 @@ extern void m4_symbol_delete (m4_
extern void m4_set_symbol_traced (m4_symtab*, const char *);
-/* Various different token types. */
-typedef enum {
- M4_TOKEN_EOF, /* end of file */
- M4_TOKEN_NONE, /* discardable token */
- M4_TOKEN_STRING, /* a quoted string */
- M4_TOKEN_SPACE, /* whitespace */
- M4_TOKEN_WORD, /* an identifier */
- M4_TOKEN_SIMPLE, /* a single character */
- M4_TOKEN_MACDEF /* a macros definition (see "defn") */
-} m4__token_type;
/* The data for a token, a macro argument, and a macro definition. */
typedef enum {
- M4_TOKEN_VOID,
- M4_TOKEN_TEXT,
- M4_TOKEN_FUNC
+ M4_SYMBOL_VOID,
+ M4_SYMBOL_TEXT,
+ M4_SYMBOL_FUNC
} m4_symbol_type;
@@ -141,19 +131,19 @@ extern const m4_builtin *m4_builtin_find
extern const m4_builtin *m4_builtin_find_by_func (
const m4_builtin *, m4_builtin_func *);
-extern m4__token_type m4_token_get_type (m4_token *);
-extern char *m4_token_text (m4_token *);
-extern m4_builtin_func *m4_token_func (m4_token *);
+extern m4_symbol_type m4_get_symbol_value_type (m4_symbol_value *);
+extern char *m4_get_symbol_value_text (m4_symbol_value *);
+extern m4_builtin_func *m4_get_symbol_value_func (m4_symbol_value *);
-#define M4ARG(i) (argc > (i) ? m4_token_text (argv[i]) : "")
+#define M4ARG(i) (argc > (i) ? m4_get_symbol_value_text (argv[i]) : "")
#define M4BUILTIN(name) \
static void CONC(builtin_, name) \
- (m4 *context, struct obstack *obs, int argc, m4_token **argv);
+ (m4 *context, struct obstack *obs, int argc, m4_symbol_value **argv);
#define M4BUILTIN_HANDLER(name) \
static void CONC(builtin_, name) \
- (m4 *context, struct obstack *obs, int argc, m4_token **argv)
+ (m4 *context, struct obstack *obs, int argc, m4_symbol_value **argv)
#define M4INIT_HANDLER(name) \
void CONC(name, CONC(_LTX_, m4_init_module)) \
@@ -209,12 +199,12 @@ extern m4_string ecomm;
#define DEF_BCOMM "#"
#define DEF_ECOMM "\n"
-extern boolean m4_bad_argc (int, m4_token **, int, int);
+extern boolean m4_bad_argc (int, m4_symbol_value **, int, int);
extern const char *m4_skip_space (const char *);
-extern boolean m4_numeric_arg (int, m4_token **, int, int *);
+extern boolean m4_numeric_arg (int, m4_symbol_value **, int, int *);
extern void m4_shipout_int (struct obstack *, int);
extern void m4_shipout_string (struct obstack*, const char*, int, boolean);
-extern void m4_dump_args (struct obstack *obs, int argc, m4_token **argv,
const char *sep, boolean quoted);
+extern void m4_dump_args (struct obstack *obs, int argc, m4_symbol_value
**argv, const char *sep, boolean quoted);
@@ -318,8 +308,8 @@ extern boolean m4_debug_set_output (cons
extern void m4_debug_message_prefix (void);
extern void m4_trace_prepre (const char *, int);
-extern void m4_trace_pre (const char *, int, int, m4_token **);
-extern void m4_trace_post (const char *, int, int, m4_token **,
+extern void m4_trace_pre (const char *, int, int, m4_symbol_value **);
+extern void m4_trace_post (const char *, int, int, m4_symbol_value **,
const char *);
/* Exit code from last "syscmd" command. */
@@ -330,10 +320,10 @@ extern const char *m4_expand_ranges (con
extern void m4_expand_input (m4 *context);
extern void m4_call_macro (m4_symbol *symbol, m4 *context,
struct obstack *obs, int argc,
- m4_token **argv);
+ m4_symbol_value **argv);
extern void m4_process_macro (m4_symbol *symbol, m4 *context,
struct obstack *obs, int argc,
- m4_token **argv);
+ m4_symbol_value **argv);
@@ -411,15 +401,14 @@ extern int m4_current_line;
extern void m4_input_init (void);
extern void m4_input_exit (void);
extern int m4_peek_input (void);
-extern m4__token_type m4_next_token (m4_token *);
-extern void m4_token_copy (m4_token *dest, m4_token *src);
+extern void m4_symbol_value_copy (m4_symbol_value *dest, m4_symbol_value
*src);
extern void m4_skip_line (void);
/* push back input */
extern void m4_push_file (FILE *, const char *);
extern void m4_push_single (int ch);
-extern void m4_push_builtin (m4_token *);
+extern void m4_push_builtin (m4_symbol_value *);
extern struct obstack *m4_push_string_init (void);
extern const char *m4_push_string_finish (void);
extern void m4_push_wrapup (const char *);
@@ -480,7 +469,7 @@ struct m4_dump_symbol_data
};
extern int m4_dump_symbol (const void *name, void *symbol, void *data);
-extern void m4_dump_symbols (m4 *context, struct m4_dump_symbol_data *data,
int argc, m4_token **argv, boolean complain);
+extern void m4_dump_symbols (m4 *context, struct m4_dump_symbol_data *data,
int argc, m4_symbol_value **argv, boolean complain);
Index: m4/m4private.h
===================================================================
RCS file: /cvsroot/m4/m4/m4/m4private.h,v
retrieving revision 1.22
diff -u -p -u -r1.22 m4private.h
--- m4/m4private.h 16 Jun 2003 16:29:06 -0000 1.22
+++ m4/m4private.h 18 Jun 2003 16:21:32 -0000
@@ -58,9 +58,7 @@ extern void m4__module_exit (m4 *con
/* --- SYMBOL TABLE MANAGEMENT --- */
-extern void m4__symtab_init (void);
extern void m4__symtab_remove_module_references (m4_symtab*, lt_dlhandle);
-extern void m4__symtab_exit (void);
/* TRUE iff strlen(rquote) == strlen(lquote) == 1 */
@@ -72,23 +70,23 @@ extern boolean m4__single_comments;
/* TRUE iff some character has M4_SYNTAX_ESCAPE */
extern boolean m4__use_macro_escape;
-struct m4_token_arg {
+struct m4_symbol_arg {
int index;
int flags;
char * default_val;
};
-#define TOKEN_ARG_INDEX(A) ((A)->index)
-#define TOKEN_ARG_FLAGS(A) ((A)->flags)
-#define TOKEN_ARG_DEFAULT(A) ((A)->default_val)
+#define SYMBOL_ARG_INDEX(A) ((A)->index)
+#define SYMBOL_ARG_FLAGS(A) ((A)->flags)
+#define SYMBOL_ARG_DEFAULT(A) ((A)->default_val)
-/* m4_token_arg.flags bit masks: */
+/* m4_symbol_arg.flags bit masks: */
-#define TOKEN_ARG_REST_BIT (1 << 0)
-#define TOKEN_ARG_KEY_BIT (1 << 1)
+#define SYMBOL_ARG_REST_BIT (1 << 0)
+#define SYMBOL_ARG_KEY_BIT (1 << 1)
-struct m4_token {
- m4_token * next;
+struct m4_symbol_value {
+ m4_symbol_value * next;
lt_dlhandle handle;
int flags;
@@ -102,20 +100,20 @@ struct m4_token {
} u;
};
-#define TOKEN_NEXT(T) ((T)->next)
-#define TOKEN_HANDLE(T) ((T)->handle)
-#define TOKEN_FLAGS(T) ((T)->flags)
-#define TOKEN_ARG_SIGNATURE(T) ((T)->arg_signature)
-#define TOKEN_MIN_ARGS(T) ((T)->min_args)
-#define TOKEN_MAX_ARGS(T) ((T)->max_args)
-#define TOKEN_TYPE(T) ((T)->type)
-#define TOKEN_TEXT(T) ((T)->u.text)
-#define TOKEN_FUNC(T) ((T)->u.func)
+#define VALUE_NEXT(T) ((T)->next)
+#define VALUE_HANDLE(T) ((T)->handle)
+#define VALUE_FLAGS(T) ((T)->flags)
+#define VALUE_ARG_SIGNATURE(T) ((T)->arg_signature)
+#define VALUE_MIN_ARGS(T) ((T)->min_args)
+#define VALUE_MAX_ARGS(T) ((T)->max_args)
+#define VALUE_TYPE(T) ((T)->type)
+#define VALUE_TEXT(T) ((T)->u.text)
+#define VALUE_FUNC(T) ((T)->u.func)
-/* m4_token.flags bit masks: */
+/* m4_symbol_value.flags bit masks: */
-#define TOKEN_MACRO_ARGS_BIT (1 << 0)
-#define TOKEN_BLIND_ARGS_BIT (1 << 1)
+#define VALUE_MACRO_ARGS_BIT (1 << 0)
+#define VALUE_BLIND_ARGS_BIT (1 << 1)
#define BIT_TEST(flags, bit) (((flags) & (bit)) == (bit))
#define BIT_SET(flags, bit) ((flags) |= (bit))
@@ -125,27 +123,41 @@ struct m4_token {
/* Redefine the exported function to this faster
macro based version for internal use by the m4 code. */
#undef M4ARG
-#define M4ARG(i) (argc > (i) ? TOKEN_TEXT (argv[i]) : "")
+#define M4ARG(i) (argc > (i) ? VALUE_TEXT (argv[i]) : "")
struct m4_symbol
{
- boolean traced;
- m4_token * token;
+ boolean traced;
+ m4_symbol_value * value;
};
#define SYMBOL_TRACED(S) ((S)->traced)
-#define SYMBOL_TOKEN(S) ((S)->token)
+#define SYMBOL_VALUE(S) ((S)->value)
-#define SYMBOL_NEXT(S) (TOKEN_NEXT (SYMBOL_TOKEN (S)))
-#define SYMBOL_HANDLE(S) (TOKEN_HANDLE (SYMBOL_TOKEN (S)))
-#define SYMBOL_FLAGS(S) (TOKEN_FLAGS (SYMBOL_TOKEN (S)))
-#define SYMBOL_ARG_SIGNATURE(S) (TOKEN_ARG_SIGNATURE (SYMBOL_TOKEN (S)))
-#define SYMBOL_MIN_ARGS(S) (TOKEN_MIN_ARGS (SYMBOL_TOKEN (S)))
-#define SYMBOL_MAX_ARGS(S) (TOKEN_MAX_ARGS (SYMBOL_TOKEN (S)))
-#define SYMBOL_TYPE(S) (TOKEN_TYPE (SYMBOL_TOKEN (S)))
-#define SYMBOL_TEXT(S) (TOKEN_TEXT (SYMBOL_TOKEN (S)))
-#define SYMBOL_FUNC(S) (TOKEN_FUNC (SYMBOL_TOKEN (S)))
+#define SYMBOL_NEXT(S) (VALUE_NEXT (SYMBOL_VALUE (S)))
+#define SYMBOL_HANDLE(S) (VALUE_HANDLE (SYMBOL_VALUE (S)))
+#define SYMBOL_FLAGS(S) (VALUE_FLAGS (SYMBOL_VALUE (S)))
+#define SYMBOL_ARG_SIGNATURE(S) (VALUE_ARG_SIGNATURE (SYMBOL_VALUE (S)))
+#define SYMBOL_MIN_ARGS(S) (VALUE_MIN_ARGS (SYMBOL_VALUE (S)))
+#define SYMBOL_MAX_ARGS(S) (VALUE_MAX_ARGS (SYMBOL_VALUE (S)))
+#define SYMBOL_TYPE(S) (VALUE_TYPE (SYMBOL_VALUE (S)))
+#define SYMBOL_TEXT(S) (VALUE_TEXT (SYMBOL_VALUE (S)))
+#define SYMBOL_FUNC(S) (VALUE_FUNC (SYMBOL_VALUE (S)))
+
+
+/* Various different token types. */
+typedef enum {
+ M4_TOKEN_EOF, /* end of file */
+ M4_TOKEN_NONE, /* discardable token */
+ M4_TOKEN_STRING, /* a quoted string */
+ M4_TOKEN_SPACE, /* whitespace */
+ M4_TOKEN_WORD, /* an identifier */
+ M4_TOKEN_SIMPLE, /* a single character */
+ M4_TOKEN_MACDEF /* a macros definition (see "defn") */
+} m4__token_type;
+
+extern m4__token_type m4__next_token (m4_symbol_value *);
Index: m4/macro.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/macro.c,v
retrieving revision 1.26
diff -u -p -u -r1.26 macro.c
--- m4/macro.c 17 Jun 2003 15:17:45 -0000 1.26
+++ m4/macro.c 18 Jun 2003 16:21:32 -0000
@@ -30,9 +30,9 @@ static void collect_arguments (m4 *co
static void expand_macro (m4 *context, const char *name,
m4_symbol *symbol);
static void expand_token (m4 *context, struct obstack *obs,
- m4__token_type type, m4_token *token);
+ m4__token_type type, m4_symbol_value *token);
static boolean expand_argument (m4 *context, struct obstack *obs,
- m4_token *argp);
+ m4_symbol_value *argp);
/* Current recursion level in expand_macro (). */
int m4_expansion_level = 0;
@@ -45,9 +45,9 @@ void
m4_expand_input (m4 *context)
{
m4__token_type type;
- m4_token token;
+ m4_symbol_value token;
- while ((type = m4_next_token (&token)) != M4_TOKEN_EOF)
+ while ((type = m4__next_token (&token)) != M4_TOKEN_EOF)
expand_token (context, (struct obstack *) NULL, type, &token);
}
@@ -58,10 +58,10 @@ m4_expand_input (m4 *context)
the text are just copied to the output. */
static void
expand_token (m4 *context, struct obstack *obs,
- m4__token_type type, m4_token *token)
+ m4__token_type type, m4_symbol_value *token)
{
m4_symbol *symbol;
- char *text = xstrdup (TOKEN_TEXT (token));
+ char *text = xstrdup (VALUE_TEXT (token));
switch (type)
{ /* TOKSW */
@@ -84,9 +84,9 @@ expand_token (m4 *context, struct obstac
symbol = m4_symbol_lookup (M4SYMTAB, textp);
if (symbol == NULL
- || SYMBOL_TYPE (symbol) == M4_TOKEN_VOID
- || (SYMBOL_TYPE (symbol) == M4_TOKEN_FUNC
- && BIT_TEST (SYMBOL_FLAGS (symbol), TOKEN_BLIND_ARGS_BIT)
+ || SYMBOL_TYPE (symbol) == M4_SYMBOL_VOID
+ || (SYMBOL_TYPE (symbol) == M4_SYMBOL_FUNC
+ && BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_BLIND_ARGS_BIT)
&& !M4_IS_OPEN (m4_peek_input ())))
{
m4_shipout_text (obs, text, strlen (text));
@@ -114,21 +114,21 @@ expand_token (m4 *context, struct obstac
the last for the active macro call. The arguments are built on the
obstack OBS, indirectly through expand_token (). */
static boolean
-expand_argument (m4 *context, struct obstack *obs, m4_token *argp)
+expand_argument (m4 *context, struct obstack *obs, m4_symbol_value *argp)
{
m4__token_type type;
- m4_token token;
+ m4_symbol_value token;
char *text;
int paren_level = 0;
const char *current_file = m4_current_file;
int current_line = m4_current_line;
- TOKEN_TYPE (argp) = M4_TOKEN_VOID;
+ VALUE_TYPE (argp) = M4_SYMBOL_VOID;
/* Skip leading white space. */
do
{
- type = m4_next_token (&token);
+ type = m4__next_token (&token);
}
while (type == M4_TOKEN_SPACE);
@@ -137,7 +137,7 @@ expand_argument (m4 *context, struct obs
switch (type)
{ /* TOKSW */
case M4_TOKEN_SIMPLE:
- text = TOKEN_TEXT (&token);
+ text = VALUE_TEXT (&token);
if ((M4_IS_COMMA (*text) || M4_IS_CLOSE (*text)) && paren_level == 0)
{
@@ -145,12 +145,12 @@ expand_argument (m4 *context, struct obs
obstack_1grow (obs, '\0');
text = obstack_finish (obs);
- if (TOKEN_TYPE (argp) == M4_TOKEN_VOID)
+ if (VALUE_TYPE (argp) == M4_SYMBOL_VOID)
{
- TOKEN_TYPE (argp) = M4_TOKEN_TEXT;
- TOKEN_TEXT (argp) = text;
+ VALUE_TYPE (argp) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (argp) = text;
}
- return (boolean) (M4_IS_COMMA (*TOKEN_TEXT (&token)));
+ return (boolean) (M4_IS_COMMA (*VALUE_TEXT (&token)));
}
if (M4_IS_OPEN (*text))
@@ -173,7 +173,7 @@ expand_argument (m4 *context, struct obs
case M4_TOKEN_MACDEF:
if (obstack_object_size (obs) == 0)
- m4_token_copy (argp, &token);
+ m4_symbol_value_copy (argp, &token);
break;
default:
@@ -182,7 +182,7 @@ expand_argument (m4 *context, struct obs
abort ();
}
- type = m4_next_token (&token);
+ type = m4__next_token (&token);
}
}
@@ -199,7 +199,7 @@ expand_macro (m4 *context, const char *n
{
struct obstack arguments;
struct obstack argptr;
- m4_token **argv;
+ m4_symbol_value **argv;
int argc;
struct obstack *expansion;
const char *expanded;
@@ -225,8 +225,8 @@ ERROR: Recursion limit of %d exceeded, u
collect_arguments (context, name, symbol, &argptr, &arguments);
- argc = obstack_object_size (&argptr) / sizeof (m4_token *);
- argv = (m4_token **) obstack_finish (&argptr);
+ argc = obstack_object_size (&argptr) / sizeof (m4_symbol_value *);
+ argv = (m4_symbol_value **) obstack_finish (&argptr);
if (traced)
m4_trace_pre (name, my_call_id, argc, argv);
@@ -254,33 +254,33 @@ collect_arguments (m4 *context, const ch
struct obstack *argptr, struct obstack *arguments)
{
int ch; /* lookahead for ( */
- m4_token token;
- m4_token *tokenp;
+ m4_symbol_value token;
+ m4_symbol_value *tokenp;
boolean more_args;
boolean groks_macro_args;
- groks_macro_args = BIT_TEST (SYMBOL_FLAGS (symbol), TOKEN_MACRO_ARGS_BIT);
+ groks_macro_args = BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_MACRO_ARGS_BIT);
- TOKEN_TYPE (&token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (&token) = (char *) name;
- tokenp = (m4_token *) obstack_copy (arguments, (void *) &token,
+ VALUE_TYPE (&token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (&token) = (char *) name;
+ tokenp = (m4_symbol_value *) obstack_copy (arguments, (void *) &token,
sizeof (token));
obstack_grow (argptr, (void *) &tokenp, sizeof (tokenp));
ch = m4_peek_input ();
if (M4_IS_OPEN(ch))
{
- m4_next_token (&token); /* gobble parenthesis */
+ m4__next_token (&token); /* gobble parenthesis */
do
{
more_args = expand_argument (context, arguments, &token);
- if (!groks_macro_args && TOKEN_TYPE (&token) == M4_TOKEN_FUNC)
+ if (!groks_macro_args && VALUE_TYPE (&token) == M4_SYMBOL_FUNC)
{
- TOKEN_TYPE (&token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (&token) = "";
+ VALUE_TYPE (&token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (&token) = "";
}
- tokenp = (m4_token *)
+ tokenp = (m4_symbol_value *)
obstack_copy (arguments, (void *) &token, sizeof (token));
obstack_grow (argptr, (void *) &tokenp, sizeof (tokenp));
}
@@ -297,19 +297,19 @@ collect_arguments (m4 *context, const ch
the obstack EXPANSION. Macro tracing is also handled here. */
void
m4_call_macro (m4_symbol *symbol, m4 *context, struct obstack *expansion,
- int argc, m4_token **argv)
+ int argc, m4_symbol_value **argv)
{
switch (SYMBOL_TYPE (symbol))
{
- case M4_TOKEN_FUNC:
+ case M4_SYMBOL_FUNC:
(*SYMBOL_FUNC (symbol)) (context, expansion, argc, argv);
break;
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
m4_process_macro (symbol, context, expansion, argc, argv);
break;
- case M4_TOKEN_VOID:
+ case M4_SYMBOL_VOID:
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: Bad symbol type in call_macro ()"));
abort ();
@@ -323,7 +323,7 @@ m4_call_macro (m4_symbol *symbol, m4 *co
as usual. */
void
m4_process_macro (m4_symbol *symbol, m4 *context, struct obstack *obs,
- int argc, m4_token **argv)
+ int argc, m4_symbol_value **argv)
{
const unsigned char *text;
int i;
@@ -383,13 +383,13 @@ m4_process_macro (m4_symbol *symbol, m4
if (*endp)
{
- struct m4_token_arg **arg
- = (struct m4_token_arg **)
+ struct m4_symbol_arg **arg
+ = (struct m4_symbol_arg **)
m4_hash_lookup (SYMBOL_ARG_SIGNATURE (symbol), key);
if (arg)
{
- i = TOKEN_ARG_INDEX (*arg);
+ i = SYMBOL_ARG_INDEX (*arg);
if (i < argc)
m4_shipout_string (obs, M4ARG (i), 0, FALSE);
Index: m4/module.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/module.c,v
retrieving revision 1.21
diff -u -p -u -r1.21 module.c
--- m4/module.c 17 Jun 2003 15:17:45 -0000 1.21
+++ m4/module.c 18 Jun 2003 16:21:32 -0000
@@ -127,19 +127,19 @@ m4_set_module_builtin_table (m4 *context
for (bp = table; bp->name != NULL; bp++)
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
char * name;
- TOKEN_TYPE (token) = M4_TOKEN_FUNC;
- TOKEN_FUNC (token) = bp->func;
- TOKEN_HANDLE (token) = handle;
- TOKEN_MIN_ARGS (token) = bp->min_args;
- TOKEN_MAX_ARGS (token) = bp->max_args;
+ VALUE_TYPE (token) = M4_SYMBOL_FUNC;
+ VALUE_FUNC (token) = bp->func;
+ VALUE_HANDLE (token) = handle;
+ VALUE_MIN_ARGS (token) = bp->min_args;
+ VALUE_MAX_ARGS (token) = bp->max_args;
if (bp->groks_macro_args)
- BIT_SET (TOKEN_FLAGS (token), TOKEN_MACRO_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (token), VALUE_MACRO_ARGS_BIT);
if (bp->blind_if_no_args)
- BIT_SET (TOKEN_FLAGS (token), TOKEN_BLIND_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (token), VALUE_BLIND_ARGS_BIT);
if (prefix_all_builtins)
{
@@ -180,11 +180,11 @@ m4_set_module_macro_table (m4 *context,
for (mp = table; mp->name != NULL; mp++)
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
- TOKEN_TYPE (token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (token) = xstrdup (mp->value);
- TOKEN_HANDLE (token) = handle;
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (token) = xstrdup (mp->value);
+ VALUE_HANDLE (token) = handle;
m4_symbol_pushdef (M4SYMTAB, mp->name, token);
}
Index: m4/symtab.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/symtab.c,v
retrieving revision 1.37
diff -u -p -u -r1.37 symtab.c
--- m4/symtab.c 17 Jun 2003 15:17:45 -0000 1.37
+++ m4/symtab.c 18 Jun 2003 16:21:32 -0000
@@ -28,7 +28,7 @@
symbol is represented by `struct m4_symbol', which is stored in the hash
table keyed by the symbol name. As a special case, to facilitate the
"pushdef" and "popdef" builtins, the value stored against each key is a
- stack of `struct m4_token'. All the value entries for a symbol name are
+ stack of `struct m4_symbol_value'. All the value entries for a symbol name
are
simply ordered on the stack by age. The most recently pushed definition
will then always be the first found.
@@ -43,16 +43,15 @@
value stacks) are invisible to the users of this module. */
#define M4_SYMTAB_DEFAULT_SIZE 2047
-#define M4_ARG_SIGNATURE_DEFAULT_SIZE 7
static m4_symbol *symtab_fetch (m4_symtab*, const char *);
static void symbol_popval (m4_symbol *symbol);
-static int symbol_destroy (m4_hash *hash, const void *name,
+static void * symbol_destroy (m4_hash *hash, const void *name,
void *symbol, void *ignored);
-static int arg_destroy (m4_hash *hash, const void *name,
+static void * arg_destroy (m4_hash *hash, const void *name,
void *arg, void *ignored);
-static m4_hash * arg_signature_parse (const char *name, const char *param);
-
+static void * arg_copy (m4_hash *src, const void *name,
+ void *arg, m4_hash *dest);
/* -- SYMBOL TABLE MANAGEMENT --
@@ -108,25 +107,25 @@ m4__symtab_remove_module_references (m4_
assert (handle);
/* Traverse each symbol name in the hash table. */
- while ((place = m4_hash_iterator_next (symtab, place)))
+ while ((place = m4_get_hash_iterator_next (symtab, place)))
{
- m4_symbol *symbol = (m4_symbol *) m4_hash_iterator_value (place);
- m4_token *data = SYMBOL_TOKEN (symbol);
+ m4_symbol *symbol = (m4_symbol *) m4_get_hash_iterator_value (place);
+ m4_symbol_value *data = SYMBOL_VALUE (symbol);
/* For symbols that have token data... */
if (data)
{
/* Purge any shadowed references. */
- while (TOKEN_NEXT (data))
+ while (VALUE_NEXT (data))
{
- m4_token *next = TOKEN_NEXT (data);
+ m4_symbol_value *next = VALUE_NEXT (data);
- if (TOKEN_HANDLE (next) == handle)
+ if (VALUE_HANDLE (next) == handle)
{
- TOKEN_NEXT (data) = TOKEN_NEXT (next);
+ VALUE_NEXT (data) = VALUE_NEXT (next);
- if (TOKEN_TYPE (next) == M4_TOKEN_TEXT)
- XFREE (TOKEN_TEXT (next));
+ if (VALUE_TYPE (next) == M4_SYMBOL_TEXT)
+ XFREE (VALUE_TEXT (next));
XFREE (next);
}
else
@@ -135,17 +134,17 @@ m4__symtab_remove_module_references (m4_
/* Purge the live reference if necessary. */
if (SYMBOL_HANDLE (symbol) == handle)
- m4_symbol_popdef (symtab, m4_hash_iterator_key (place));
+ m4_symbol_popdef (symtab, m4_get_hash_iterator_key (place));
}
}
}
-/* This callback is used exclusively by m4__symtab_exit(), to cleanup
+/* This callback is used exclusively by m4_symtab_delete(), to cleanup
the memory used by the symbol table. As such, the trace bit is reset
on every symbol so that m4_symbol_popdef() doesn't try to preserve
the table entry. */
-static int
+static void *
symbol_destroy (m4_hash *hash, const void *name, void *symbol, void *ignored)
{
char *key = xstrdup ((char *) name);
@@ -157,7 +156,7 @@ symbol_destroy (m4_hash *hash, const voi
XFREE (key);
- return 0;
+ return NULL;
}
@@ -176,7 +175,7 @@ m4_symbol_lookup (m4_symtab *symtab, con
/* If just searching, return status of search -- if only an empty
struct is returned, that is treated as a failed lookup. */
- return (psymbol && SYMBOL_TOKEN (*psymbol)) ? *psymbol : 0;
+ return (psymbol && SYMBOL_VALUE (*psymbol)) ? *psymbol : 0;
}
@@ -184,7 +183,7 @@ m4_symbol_lookup (m4_symtab *symtab, con
associated with NAME, push the new VALUE on top of the value stack
for this symbol. Otherwise create a new association. */
m4_symbol *
-m4_symbol_pushdef (m4_symtab *symtab, const char *name, m4_token *value)
+m4_symbol_pushdef (m4_symtab *symtab, const char *name, m4_symbol_value *value)
{
m4_symbol *symbol;
@@ -193,10 +192,10 @@ m4_symbol_pushdef (m4_symtab *symtab, co
assert (value);
symbol = symtab_fetch (symtab, name);
- TOKEN_NEXT (value) = SYMBOL_TOKEN (symbol);
- SYMBOL_TOKEN (symbol) = value;
+ VALUE_NEXT (value) = SYMBOL_VALUE (symbol);
+ SYMBOL_VALUE (symbol) = value;
- assert (SYMBOL_TOKEN (symbol));
+ assert (SYMBOL_VALUE (symbol));
return symbol;
}
@@ -204,7 +203,7 @@ m4_symbol_pushdef (m4_symtab *symtab, co
/* Return the symbol associated with NAME in the symbol table, creating
a new symbol if necessary. In either case set the symbol's VALUE. */
m4_symbol *
-m4_symbol_define (m4_symtab *symtab, const char *name, m4_token *value)
+m4_symbol_define (m4_symtab *symtab, const char *name, m4_symbol_value *value)
{
m4_symbol *symbol;
@@ -213,13 +212,13 @@ m4_symbol_define (m4_symtab *symtab, con
assert (value);
symbol = symtab_fetch (symtab, name);
- if (SYMBOL_TOKEN (symbol))
+ if (SYMBOL_VALUE (symbol))
symbol_popval (symbol);
- TOKEN_NEXT (value) = SYMBOL_TOKEN (symbol);
- SYMBOL_TOKEN (symbol) = value;
+ VALUE_NEXT (value) = SYMBOL_VALUE (symbol);
+ SYMBOL_VALUE (symbol) = value;
- assert (SYMBOL_TOKEN (symbol));
+ assert (SYMBOL_VALUE (symbol));
return symbol;
}
@@ -253,7 +252,7 @@ m4_symbol_popdef (m4_symtab *symtab, con
/* Only remove the hash table entry if the last value in the
symbol value stack was successfully removed. */
- if (!SYMBOL_TOKEN (*psymbol))
+ if (!SYMBOL_VALUE (*psymbol))
if (no_gnu_extensions || !SYMBOL_TRACED (*psymbol))
{
XFREE (*psymbol);
@@ -265,190 +264,84 @@ m4_symbol_popdef (m4_symtab *symtab, con
static void
symbol_popval (m4_symbol *symbol)
{
- m4_token *stale;
+ m4_symbol_value *stale;
assert (symbol);
- stale = SYMBOL_TOKEN (symbol);
+ stale = SYMBOL_VALUE (symbol);
if (stale)
{
- SYMBOL_TOKEN (symbol) = TOKEN_NEXT (stale);
+ SYMBOL_VALUE (symbol) = VALUE_NEXT (stale);
- if (TOKEN_ARG_SIGNATURE (stale))
+ if (VALUE_ARG_SIGNATURE (stale))
{
- m4_hash_apply (TOKEN_ARG_SIGNATURE (stale), arg_destroy, NULL);
- m4_hash_delete (TOKEN_ARG_SIGNATURE (stale));
+ m4_hash_apply (VALUE_ARG_SIGNATURE (stale), arg_destroy, NULL);
+ m4_hash_delete (VALUE_ARG_SIGNATURE (stale));
}
- if (TOKEN_TYPE (stale) == M4_TOKEN_TEXT)
- XFREE (TOKEN_TEXT (stale));
+ if (VALUE_TYPE (stale) == M4_SYMBOL_TEXT)
+ XFREE (VALUE_TEXT (stale));
XFREE (stale);
}
}
/* Callback used by m4_symbol_popdef () to release the memory used
by values in the arg_signature hash. */
-static int
+static void *
arg_destroy (m4_hash *hash, const void *name, void *arg, void *ignored)
{
- struct m4_token_arg *token_arg = (struct m4_token_arg *) arg;
+ struct m4_symbol_arg *token_arg = (struct m4_symbol_arg *) arg;
assert (name);
assert (hash);
- if (TOKEN_ARG_DEFAULT (token_arg))
- XFREE (TOKEN_ARG_DEFAULT (token_arg));
+ if (SYMBOL_ARG_DEFAULT (token_arg))
+ XFREE (SYMBOL_ARG_DEFAULT (token_arg));
xfree (token_arg);
xfree (m4_hash_remove (hash, (const char *) name));
- return 0;
-}
-
-#if 0
-m4_symbol *
-m4_symbol_push_token (m4_symtab *symtab, const char *name, m4_token *token)
-{
- m4_token *next;
-
- assert (symtab);
- assert (name);
- assert (token);
-
- /* If it's a function, it must have come from a module. */
- assert ((TOKEN_TYPE (token) != M4_TOKEN_FUNC) || TOKEN_HANDLE (token));
-
-#if M4PARAMS
- const char *openp = NULL;
- const char *params = NULL;
-
- if (!no_gnu_extensions)
- {
- /* If name contains an open paren, then parse before that paren
- as the actual name, and the rest as a formal parameter list. */
- size_t len = 0;
- for (openp = name; *openp && !M4_IS_OPEN (*openp); ++openp)
- ++len;
-
- if (*openp)
- {
- name = xstrzdup (name, len);
- params = 1+ openp;
- }
- }
-
- if (params)
- {
- /* Make a hash table to map formal parameter names to
- argv offsets, and store that in the symbol's token. */
- TOKEN_ARG_SIGNATURE (token) = arg_signature_parse (name, params);
- }
-#endif
-
- SYMBOL_TOKEN (symbol) = token;
-
-#if M4PARAMS
- /* If we split name on open paren, free the copied substring. */
- if (params)
- xfree ((char *) name);
-#endif
-
- return symbol;
+ return NULL;
}
-#endif
void
-m4_token_copy (m4_token *dest, m4_token *src)
+m4_symbol_value_copy (m4_symbol_value *dest, m4_symbol_value *src)
{
- m4_token *next;
+ m4_symbol_value *next;
assert (dest);
assert (src);
- if (TOKEN_TYPE (dest) == M4_TOKEN_TEXT)
- xfree (TOKEN_TEXT (dest));
+ if (VALUE_TYPE (dest) == M4_SYMBOL_TEXT)
+ xfree (VALUE_TEXT (dest));
-#if M4PARAMS
- if (TOKEN_ARG_SIGNATURE (dest))
+ if (VALUE_ARG_SIGNATURE (dest))
{
- m4_hash_apply (TOKEN_ARG_SIGNATURE (dest), arg_destroy, NULL);
- m4_hash_delete (TOKEN_ARG_SIGNATURE (dest));
+ m4_hash_apply (VALUE_ARG_SIGNATURE (dest), arg_destroy, NULL);
+ m4_hash_delete (VALUE_ARG_SIGNATURE (dest));
}
-#endif
/* Copy the token contents over, being careful to preserve
the next pointer. */
- next = TOKEN_NEXT (dest);
- bcopy (src, dest, sizeof (m4_token));
- TOKEN_NEXT (dest) = next;
+ next = VALUE_NEXT (dest);
+ bcopy (src, dest, sizeof (m4_symbol_value));
+ VALUE_NEXT (dest) = next;
/* Caller is supposed to free text token strings, so we have to
copy the string not just its address in that case. */
- if (TOKEN_TYPE (src) == M4_TOKEN_TEXT)
- TOKEN_TEXT (dest) = xstrdup (TOKEN_TEXT (src));
+ if (VALUE_TYPE (src) == M4_SYMBOL_TEXT)
+ VALUE_TEXT (dest) = xstrdup (VALUE_TEXT (src));
-#if M4PARAMS
- if (TOKEN_ARG_SIGNATURE (src))
- TOKEN_ARG_SIGNATURE (dest) = m4_hash_dup (TOKEN_ARG_SIGNATURE (token));
-#endif
+ if (VALUE_ARG_SIGNATURE (src))
+ VALUE_ARG_SIGNATURE (dest) = m4_hash_dup (VALUE_ARG_SIGNATURE (src),
+ arg_copy);
}
-#if M4PARAMS
-static m4_hash *
-arg_signature_parse (const char *name, const char *params)
+static void *
+arg_copy (m4_hash *src, const void *name, void *arg, m4_hash *dest)
{
- m4_hash *arg_signature;
- const char *commap;
- int offset;
-
- assert (params);
-
- arg_signature = m4_hash_new (M4_ARG_SIGNATURE_DEFAULT_SIZE,
- m4_hash_string_hash, m4_hash_string_cmp);
-
- for (offset = 1; *params && !M4_IS_CLOSE (*params); ++offset)
- {
- size_t len = 0;
-
- /* Skip leading whitespace. */
- while (M4_IS_SPACE (*params))
- ++params;
-
- for (commap = params; *commap && M4_IS_IDENT (*commap); ++commap)
- ++len;
-
- /* Skip trailing whitespace. */
- while (M4_IS_SPACE (*commap))
- ++commap;
-
- if (!M4_IS_COMMA (*commap) && !M4_IS_CLOSE (*commap))
- M4ERROR ((EXIT_FAILURE, 0,
- _("Error: %s: syntax error in parameter list at char `%c'"),
- name, *commap));
-
- /* Skip parameter delimiter. */
- if (M4_IS_COMMA (*commap))
- ++commap;
-
- if (len)
- {
- struct m4_token_arg *arg = XCALLOC (struct m4_token_arg, 1);
-
- TOKEN_ARG_INDEX (arg) = offset;
-
- m4_hash_insert (arg_signature, xstrzdup (params, len), arg);
-
- params = commap;
- }
- }
-
- if (!M4_IS_CLOSE (*commap))
- M4WARN ((warning_status, 0,
- _("Warning: %s: unterminated parameter list"), name));
-
- return arg_signature;
+ m4_hash_insert ((m4_hash *) dest, name, arg);
+ return NULL;
}
-#endif
-
#ifdef DEBUG_SYM
@@ -463,11 +356,11 @@ symtab_dump (m4_symtab *symtab)
{
m4_hash_iterator *place = 0;
- while ((place = m4_hash_iterator_next ((m4_hash *) symtab, place)))
+ while ((place = m4_get_hash_iterator_next ((m4_hash *) symtab, place)))
{
- const char *symbol_name = (const char *) m4_hash_iterator_key
(place);
- m4_symbol *symbol = m4_hash_iterator_value (place);
- m4_token *token = SYMBOL_TOKEN (symbol);
+ const char *symbol_name = (const char *)
m4_get_hash_iterator_key (place);
+ m4_symbol *symbol = m4_get_hash_iterator_value (place);
+ m4_symbol_value *token = SYMBOL_VALUE (symbol);
int flags = token ? SYMBOL_FLAGS (symbol) : 0;
lt_dlhandle handle = token ? SYMBOL_HANDLE (symbol) : 0;
const char *module_name = handle ? m4_get_module_name (handle)
: "NONE";
@@ -482,76 +375,29 @@ symtab_dump (m4_symtab *symtab)
else
switch (SYMBOL_TYPE (symbol))
{
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
fputs (SYMBOL_TEXT (symbol), stderr);
break;
- case M4_TOKEN_FUNC:
+ case M4_SYMBOL_FUNC:
bp = m4_builtin_find_by_func (m4_get_module_builtin_table (handle),
SYMBOL_FUNC (symbol));
fprintf (stderr, "<%s>",
bp ? bp->name : "!ERROR!");
break;
- case M4_TOKEN_VOID:
+ case M4_SYMBOL_VOID:
fputs ("<!VOID!>", stderr);
break;
}
fputc ('\n', stderr);
}
}
-
-static void
-symtab_debug (m4_symtab *symtab)
-{
- m4__token_type type;
- m4_token token;
- const char *text;
- m4_symbol *symbol;
- int delete;
-
- while ((type = m4_next_token (&token)) != M4_TOKEN_EOF)
- {
- if (type != M4_TOKEN_WORD)
- continue;
- text = TOKEN_TEXT (&token);
- if (*text == '_')
- {
- delete = 1;
- text++;
- }
- else
- delete = 0;
-
- symbol = m4_symbol_lookup (symtab, text);
-
- if (symbol == NULL)
- printf (_("Name `%s' is unknown\n"), text);
-
- if (delete)
- m4_symbol_delete (symtab, text);
- else
- symtab_fetch (symtab, text);
- }
- m4_symtab_apply (symtab, symtab_print_list, NULL);
-}
-
-static int
-symtab_print_list (m4_hash *hash, const void *name, void *symbol,
- void *ignored)
-{
- printf ("\tname %s, addr %#x, flags: %d %s\n",
- (char *) name, (unsigned) symbol,
- SYMBOL_FLAGS ((m4_symbol *) symbol),
- SYMBOL_TRACED ((m4_symbol *) symbol) ? " traced" : "<none>");
- return 0;
-}
-
#endif /* DEBUG_SYM */
/* Define these functions at the end, so that calls in the file use the
faster macro version from m4module.h. */
#undef m4_symtab_apply
-int
+void *
m4_symtab_apply (m4_symtab *symtab, m4_symtab_apply_func *func, void *userdata)
{
return m4_hash_apply ((m4_hash *) symtab, (m4_hash_apply_func *) func,
Index: m4/utility.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/utility.c,v
retrieving revision 1.25
diff -u -p -u -r1.25 utility.c
--- m4/utility.c 16 Jun 2003 10:43:45 -0000 1.25
+++ m4/utility.c 18 Jun 2003 16:21:32 -0000
@@ -75,22 +75,22 @@ m4_string ecomm;
Since they are functions the caller does not need access to the
internal data structure, so they are safe to export for use in
external modules. */
-m4__token_type
-m4_token_get_type (m4_token *name)
+m4_symbol_type
+m4_get_symbol_value_type (m4_symbol_value *name)
{
- return TOKEN_TYPE (name);
+ return VALUE_TYPE (name);
}
char *
-m4_token_text (m4_token *name)
+m4_get_symbol_value_text (m4_symbol_value *name)
{
- return TOKEN_TEXT (name);
+ return VALUE_TEXT (name);
}
m4_builtin_func *
-m4_token_func (m4_token *name)
+m4_get_symbol_value_func (m4_symbol_value *name)
{
- return TOKEN_FUNC (name);
+ return VALUE_FUNC (name);
}
@@ -101,7 +101,7 @@ m4_token_func (m4_token *name)
applicable, MAX is the maximum number, negative if not applicable.
ARGC, MIN, and MAX count ARGV[0], the name of the macro. */
boolean
-m4_bad_argc (int argc, m4_token **argv, int min, int max)
+m4_bad_argc (int argc, m4_symbol_value **argv, int min, int max)
{
if (min > 0 && argc < min)
{
@@ -135,7 +135,7 @@ m4_skip_space (const char *arg)
VALUEP. If the conversion fails, print error message for macro.
Return TRUE iff conversion succeeds. */
boolean
-m4_numeric_arg (int argc, m4_token **argv, int arg, int *valuep)
+m4_numeric_arg (int argc, m4_symbol_value **argv, int arg, int *valuep)
{
char *endp;
@@ -155,7 +155,7 @@ m4_numeric_arg (int argc, m4_token **arg
/* Print ARGC arguments from the table ARGV to obstack OBS, separated by
SEP, and quoted by the current quotes, if QUOTED is TRUE. */
void
-m4_dump_args (struct obstack *obs, int argc, m4_token **argv,
+m4_dump_args (struct obstack *obs, int argc, m4_symbol_value **argv,
const char *sep, boolean quoted)
{
int i;
@@ -224,7 +224,7 @@ dumpdef_cmp (const void *s1, const void
int
m4_dump_symbol (const void *name, void *symbol, void *data)
{
- if (SYMBOL_TYPE ((m4_symbol *) symbol) != M4_TOKEN_VOID)
+ if (SYMBOL_TYPE ((m4_symbol *) symbol) != M4_SYMBOL_VOID)
{
struct m4_dump_symbol_data *symbol_data
= (struct m4_dump_symbol_data *) data;
@@ -241,7 +241,7 @@ m4_dump_symbol (const void *name, void *
symbols, otherwise, only the specified symbols. */
void
m4_dump_symbols (m4 *context, struct m4_dump_symbol_data *data, int argc,
- m4_token **argv, boolean complain)
+ m4_symbol_value **argv, boolean complain)
{
data->base = (const char **) obstack_base (data->obs);
data->size = 0;
@@ -258,7 +258,7 @@ m4_dump_symbols (m4 *context, struct m4_
for (i = 1; i < argc; i++)
{
symbol = m4_symbol_lookup (M4SYMTAB, M4ARG (i));
- if (symbol != NULL && SYMBOL_TYPE (symbol) != M4_TOKEN_VOID)
+ if (symbol != NULL && SYMBOL_TYPE (symbol) != M4_SYMBOL_VOID)
m4_dump_symbol (M4ARG (i), symbol, data);
else if (complain)
M4WARN ((warning_status, 0,
Index: modules/evalparse.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/evalparse.c,v
retrieving revision 1.7
diff -u -p -u -r1.7 evalparse.c
--- modules/evalparse.c 16 Jun 2003 10:43:45 -0000 1.7
+++ modules/evalparse.c 18 Jun 2003 16:21:32 -0000
@@ -770,7 +770,7 @@ simple_term (eval_token et, number *v1)
/* Main entry point, called from "eval" and "mpeval" builtins. */
void
-m4_evaluate (m4 *context, struct obstack *obs, int argc, m4_token **argv)
+m4_evaluate (m4 *context, struct obstack *obs, int argc, m4_symbol_value
**argv)
{
int radix = 10;
int min = 1;
Index: modules/format.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/format.c,v
retrieving revision 1.13
diff -u -p -u -r1.13 format.c
--- modules/format.c 11 Oct 2001 21:09:16 -0000 1.13
+++ modules/format.c 18 Jun 2003 16:21:32 -0000
@@ -50,10 +50,10 @@
/* The main formatting function. Output is placed on the obstack OBS, the
first argument in ARGV is the formatting string, and the rest is
arguments for the string. */
-void format (struct obstack *obs, int argc, m4_token **argv);
+void format (struct obstack *obs, int argc, m4_symbol_value **argv);
void
-format (struct obstack *obs, int argc, m4_token **argv)
+format (struct obstack *obs, int argc, m4_symbol_value **argv)
{
char *fmt; /* format control string */
const char *fstart; /* beginning of current format spec */
Index: modules/gnu.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/gnu.c,v
retrieving revision 1.20
diff -u -p -u -r1.20 gnu.c
--- modules/gnu.c 16 Jun 2003 10:43:45 -0000 1.20
+++ modules/gnu.c 18 Jun 2003 16:21:32 -0000
@@ -120,7 +120,7 @@ m4_macro m4_macro_table[] =
static void substitute (struct obstack *obs, const char *victim,
const char *repl, struct re_registers *regs);
-static void m4_patsubst_do (struct obstack *obs, int argc, m4_token **argv,
+static void m4_patsubst_do (struct obstack *obs, int argc, m4_symbol_value
**argv,
int syntax);
@@ -297,7 +297,7 @@ m4_regexp_compile (const char *caller,
**/
static void
-m4_regexp_do (struct obstack *obs, int argc, m4_token **argv,
+m4_regexp_do (struct obstack *obs, int argc, m4_symbol_value **argv,
int syntax)
{
const char *victim; /* first argument */
@@ -362,7 +362,7 @@ M4BUILTIN_HANDLER (eregexp)
* patsubst(STRING, REGEXP, [REPLACEMENT])
**/
static void
-m4_patsubst_do (struct obstack *obs, int argc, m4_token **argv,
+m4_patsubst_do (struct obstack *obs, int argc, m4_symbol_value **argv,
int syntax)
{
const char *victim; /* first argument */
@@ -477,7 +477,7 @@ M4BUILTIN_HANDLER (symbols)
**/
M4BUILTIN_HANDLER (syncoutput)
{
- if (TOKEN_TYPE (argv[1]) != M4_TOKEN_TEXT)
+ if (VALUE_TYPE (argv[1]) != M4_SYMBOL_TEXT)
return;
if ( M4ARG (1)[0] == '0'
Index: modules/m4.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/m4.c,v
retrieving revision 1.41
diff -u -p -u -r1.41 m4.c
--- modules/m4.c 17 Jun 2003 15:17:45 -0000 1.41
+++ modules/m4.c 18 Jun 2003 16:21:32 -0000
@@ -92,7 +92,7 @@ typedef unsigned long int unumber;
#endif
-static void include (int argc, m4_token **argv,
+static void include (int argc, m4_symbol_value **argv,
boolean silent);
static int set_trace (m4_hash *hash, const void *ignored,
void *symbol, void *userdata);
@@ -148,19 +148,19 @@ M4INIT_HANDLER (m4)
M4BUILTIN_HANDLER (define)
{
- if (TOKEN_TYPE (argv[1]) == M4_TOKEN_TEXT)
+ if (VALUE_TYPE (argv[1]) == M4_SYMBOL_TEXT)
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
if (argc == 2)
{
- TOKEN_TYPE (token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (token) = xstrdup ("");
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (token) = xstrdup ("");
}
else
{
- m4_token_copy (token, argv[2]);
- TOKEN_NEXT (token) = NULL;
+ m4_symbol_value_copy (token, argv[2]);
+ VALUE_NEXT (token) = NULL;
}
m4_symbol_define (M4SYMTAB, M4ARG (1), token);
@@ -178,19 +178,19 @@ M4BUILTIN_HANDLER (undefine)
M4BUILTIN_HANDLER (pushdef)
{
- if (TOKEN_TYPE (argv[1]) == M4_TOKEN_TEXT)
+ if (VALUE_TYPE (argv[1]) == M4_SYMBOL_TEXT)
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
if (argc == 2)
{
- TOKEN_TYPE (token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (token) = xstrdup ("");
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (token) = xstrdup ("");
}
else
{
- m4_token_copy (token, argv[2]);
- TOKEN_NEXT (token) = NULL;
+ m4_symbol_value_copy (token, argv[2]);
+ VALUE_NEXT (token) = NULL;
}
m4_symbol_pushdef (M4SYMTAB, M4ARG (1), token);
@@ -289,12 +289,12 @@ M4BUILTIN_HANDLER (dumpdef)
m4_symbol *symbol = m4_symbol_lookup (M4SYMTAB, data.base[0]);
fprintf (stderr, "%s:\t", data.base[0]);
- assert (SYMBOL_TYPE (symbol) == M4_TOKEN_TEXT
- || SYMBOL_TYPE (symbol) == M4_TOKEN_FUNC
- || SYMBOL_TYPE (symbol) == M4_TOKEN_VOID);
+ assert (SYMBOL_TYPE (symbol) == M4_SYMBOL_TEXT
+ || SYMBOL_TYPE (symbol) == M4_SYMBOL_FUNC
+ || SYMBOL_TYPE (symbol) == M4_SYMBOL_VOID);
switch (SYMBOL_TYPE (symbol))
{
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
if (debug_level & M4_DEBUG_TRACE_QUOTE)
fprintf (stderr, "%s%s%s\n",
lquote.string, SYMBOL_TEXT (symbol), rquote.string);
@@ -302,13 +302,13 @@ M4BUILTIN_HANDLER (dumpdef)
fprintf (stderr, "%s\n", SYMBOL_TEXT (symbol));
break;
- case M4_TOKEN_FUNC:
+ case M4_SYMBOL_FUNC:
bp = m4_builtin_find_by_func (NULL, SYMBOL_FUNC (symbol));
assert (bp);
fprintf (stderr, "<%s>\n", bp->name);
break;
- case M4_TOKEN_VOID:
+ case M4_SYMBOL_VOID:
assert (!"VOID token in m4_dumpdef");
break;
}
@@ -332,15 +332,15 @@ M4BUILTIN_HANDLER (defn)
switch (SYMBOL_TYPE (symbol))
{
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
m4_shipout_string (obs, SYMBOL_TEXT (symbol), 0, TRUE);
return;
- case M4_TOKEN_FUNC:
- m4_push_builtin (SYMBOL_TOKEN (symbol));
+ case M4_SYMBOL_FUNC:
+ m4_push_builtin (SYMBOL_VALUE (symbol));
return;
- case M4_TOKEN_VOID:
+ case M4_SYMBOL_VOID:
assert (!"VOID token in m4_dumpdef");
return;
}
@@ -482,7 +482,7 @@ M4BUILTIN_HANDLER (changecom)
/* Generic include function. Include the file given by the first argument,
if it exists. Complain about inaccesible files iff SILENT is FALSE. */
static void
-include (int argc, m4_token **argv, boolean silent)
+include (int argc, m4_symbol_value **argv, boolean silent)
{
FILE *fp;
char *name = NULL;
Index: src/freeze.c
===================================================================
RCS file: /cvsroot/m4/m4/src/freeze.c,v
retrieving revision 1.28
diff -u -p -u -r1.28 freeze.c
--- src/freeze.c 17 Jun 2003 15:17:45 -0000 1.28
+++ src/freeze.c 18 Jun 2003 16:21:32 -0000
@@ -126,17 +126,17 @@ produce_symbol_dump (FILE *file, m4_hash
{
m4_hash_iterator *place = 0;
- while ((place = m4_hash_iterator_next (hash, place)))
+ while ((place = m4_get_hash_iterator_next (hash, place)))
{
- const char *symbol_name = (const char *) m4_hash_iterator_key
(place);
- m4_symbol *symbol = m4_hash_iterator_value (place);
+ const char *symbol_name = (const char *)
m4_get_hash_iterator_key (place);
+ m4_symbol *symbol = m4_get_hash_iterator_value (place);
lt_dlhandle handle = SYMBOL_HANDLE (symbol);
const char *module_name = handle ? m4_get_module_name (handle)
: NULL;
const m4_builtin *bp;
switch (SYMBOL_TYPE (symbol))
{
- case M4_TOKEN_TEXT:
+ case M4_SYMBOL_TEXT:
fprintf (file, "T%lu,%lu",
(unsigned long) strlen (symbol_name),
(unsigned long) strlen (SYMBOL_TEXT (symbol)));
@@ -151,7 +151,7 @@ produce_symbol_dump (FILE *file, m4_hash
fputc ('\n', file);
break;
- case M4_TOKEN_FUNC:
+ case M4_SYMBOL_FUNC:
bp = m4_builtin_find_by_func
(m4_get_module_builtin_table (SYMBOL_HANDLE (symbol)),
SYMBOL_FUNC (symbol));
@@ -473,18 +473,18 @@ reload_frozen_state (m4 *context, const
if (bp)
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
if (bp->groks_macro_args)
- BIT_SET (TOKEN_FLAGS (token), TOKEN_MACRO_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (token), VALUE_MACRO_ARGS_BIT);
if (bp->blind_if_no_args)
- BIT_SET (TOKEN_FLAGS (token), TOKEN_BLIND_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (token), VALUE_BLIND_ARGS_BIT);
- TOKEN_TYPE (token) = M4_TOKEN_FUNC;
- TOKEN_FUNC (token) = bp->func;
- TOKEN_HANDLE (token) = handle;
- TOKEN_MIN_ARGS (token) = bp->min_args;
- TOKEN_MAX_ARGS (token) = bp->max_args;
+ VALUE_TYPE (token) = M4_SYMBOL_FUNC;
+ VALUE_FUNC (token) = bp->func;
+ VALUE_HANDLE (token) = handle;
+ VALUE_MIN_ARGS (token) = bp->min_args;
+ VALUE_MAX_ARGS (token) = bp->max_args;
m4_symbol_pushdef (M4SYMTAB, string[0], token);
}
@@ -655,7 +655,7 @@ reload_frozen_state (m4 *context, const
/* Enter a macro having an expansion text as a definition. */
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
lt_dlhandle handle = 0;
if (number[2] > 0)
@@ -663,10 +663,10 @@ reload_frozen_state (m4 *context, const
if (strcmp (m4_get_module_name (handle), string[2]) == 0)
break;
- TOKEN_TYPE (token) = M4_TOKEN_TEXT;
- TOKEN_TEXT (token) = xstrdup (string[1]);
- TOKEN_HANDLE (token) = handle;
- TOKEN_MAX_ARGS (token) = -1;
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ VALUE_TEXT (token) = xstrdup (string[1]);
+ VALUE_HANDLE (token) = handle;
+ VALUE_MAX_ARGS (token) = -1;
m4_symbol_pushdef (M4SYMTAB, string[0], token);
}
Index: src/main.c
===================================================================
RCS file: /cvsroot/m4/m4/src/main.c,v
retrieving revision 1.39
diff -u -p -u -r1.39 main.c
--- src/main.c 17 Jun 2003 15:17:45 -0000 1.39
+++ src/main.c 18 Jun 2003 16:21:32 -0000
@@ -432,15 +432,15 @@ warranty; not even for MERCHANTABILITY o
{
case 'D':
{
- m4_token *token = XCALLOC (m4_token, 1);
+ m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
macro_value = strchr (defines->macro, '=');
if (macro_value == NULL)
macro_value = "";
else
*macro_value++ = '\0';
- TOKEN_TEXT (token) = xstrdup (macro_value);
- TOKEN_TYPE (token) = M4_TOKEN_TEXT;
+ VALUE_TEXT (token) = xstrdup (macro_value);
+ VALUE_TYPE (token) = M4_SYMBOL_TEXT;
m4_symbol_pushdef (M4SYMTAB, defines->macro, token);
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- FYI: 15-gary-symtab-structure-renaming.patch,
Gary V. Vaughan <=