[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
FYI: 16-gary-refactor-symbol-api.patch
|
From: |
Gary V. Vaughan |
|
Subject: |
FYI: 16-gary-refactor-symbol-api.patch |
|
Date: |
Wed, 25 Jun 2003 13:42:11 +0100 |
|
User-agent: |
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.4) Gecko/20030617 |
Applied to HEAD about a week ago, but the FYI didn't seem to make it to here
last time.
--
())_. 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>
Tie down the interface to libm4 some more. Make more structures
opaque to modules by moving them to m4private.h, and writing
setters and getters. To win back the speed penalty for doing this
also wrote macroized versions that do know about structure layout
in m4private.h and #include that file into modules when NDEBUG is
defined at compile time. There are still some accessor macros in
m4private.h that need to go, but that is not necessary to clean
the module api up.
* m4/m4module.h (m4_symbol_type): Moved...
* m4/m4private.h (m4__symbol_type): ...to here.
* m4/symtab.c (m4_get_symbol_value, m4_get_symbol_traced)
(m4_set_symbol_traced, m4_set_symbol_name_traced)
(m4_is_symbol_text, m4_is_symbol_func, m4_get_symbol_text)
(m4_get_symbol_func, m4_symbol_value_create)
(m4_symbol_value_delete, m4_set_symbol_value_text)
(m4_set_symbol_value_func): New exported api to symbols.
(m4_get_symbol_value_type): Replaced by m4_is_symbol_value_text
and m4_is_symbol_value_func.
* m4/m4module.h: Prototype these guys.
* m4/module.c (m4_set_module_macro_table)
(m4_set_module_builtin_table): Make these static, there is no
reason to pollute the api with them.
* m4/m4private.h: Reformatting.
(m4_get_symtab): Only define when NDEBUG is defined.
(m4_get_symbol_value, m4_get_symbol_traced)
(m4_set_symbol_traced, m4_set_symbol_name_traced)
(m4_is_symbol_text, m4_is_symbol_func, m4_get_symbol_text)
(m4_get_symbol_func, m4_symbol_value_create)
(m4_symbol_value_delete, m4_set_symbol_value_text)
(m4_set_symbol_value_func): Macro implementations of the new
functions when NDEBUG is defined.
(SYMBOL_TRACED, SYMBOL_VALUE, SYMBOL_TYPE, SYMBOL_TEXT)
(SYMBOL_FUNC, VALUE_TYPE, VALUE_TEXT, VALUE_FUNC): Removed.
Superceded by the above. All callers changed.
(M4ARG): Removed. This is no longer different to the
m4/m4module.h definition.
* modules/gnu.c, modules/m4.c: Only include m4private.h when
NDEBUG is defined. That way we exercise the same (albeit slower)
api that external modules must use.
Index: m4/debug.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/debug.c,v
retrieving revision 1.12
diff -u -p -u -r1.12 debug.c
--- m4/debug.c 18 Jun 2003 16:21:54 -0000 1.12
+++ m4/debug.c 19 Jun 2003 14:50:44 -0000
@@ -343,14 +343,14 @@ m4_trace_pre (const char *name, int id,
if (i != 1)
m4_trace_format (", ");
- switch (VALUE_TYPE (argv[i]))
+ if (m4_is_symbol_value_text (argv[i]))
{
- case M4_SYMBOL_TEXT:
m4_trace_format ("%l%S%r", M4ARG (i));
- break;
-
- case M4_SYMBOL_FUNC:
- bp = m4_builtin_find_by_func (NULL, VALUE_FUNC (argv[i]));
+ }
+ else if (m4_is_symbol_value_func (argv[i]))
+ {
+ bp = m4_builtin_find_by_func (NULL,
+ m4_get_symbol_value_func(argv[i]));
if (bp == NULL)
{
M4ERROR ((warning_status, 0, "\
@@ -358,14 +358,13 @@ INTERNAL ERROR: Builtin not found in bui
abort ();
}
m4_trace_format ("<%s>", bp->name);
- break;
-
- case M4_SYMBOL_VOID:
+ }
+ else
+ {
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: Bad token data type (m4_trace_pre
())"));
abort ();
}
-
}
m4_trace_format (")");
}
@@ -380,8 +379,8 @@ 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_symbol_value **argv,
- const char *expanded)
+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.26
diff -u -p -u -r1.26 input.c
--- m4/input.c 18 Jun 2003 16:21:54 -0000 1.26
+++ m4/input.c 19 Jun 2003 14:50:44 -0000
@@ -311,7 +311,7 @@ m4_push_builtin (m4_symbol_value *token)
input_block *i;
/* Make sure we were passed a builtin function type token. */
- assert (VALUE_TYPE (token) == M4_SYMBOL_FUNC);
+ assert (m4_is_symbol_value_func (token));
if (next != NULL)
{
@@ -323,7 +323,7 @@ m4_push_builtin (m4_symbol_value *token)
sizeof (struct input_block));
i->funcs = &builtin_funcs;
- i->u.u_b.func = VALUE_FUNC (token);
+ i->u.u_b.func = m4_get_symbol_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);
@@ -527,8 +527,7 @@ init_builtin_token (m4_symbol_value *tok
abort ();
}
- VALUE_TYPE (token) = M4_SYMBOL_FUNC;
- VALUE_FUNC (token) = isp->u.u_b.func;
+ m4_set_symbol_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;
@@ -941,9 +940,7 @@ m4__next_token (m4_symbol_value *token)
bzero (token, sizeof (m4_symbol_value));
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (token) = obstack_finish (&token_stack);
- VALUE_MIN_ARGS (token) = -1;
+ m4_set_symbol_value_text (token, obstack_finish (&token_stack));
VALUE_MAX_ARGS (token) = -1;
#ifdef DEBUG_INPUT
Index: m4/m4.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/m4.c,v
retrieving revision 1.1
diff -u -p -u -r1.1 m4.c
--- m4/m4.c 16 Jun 2003 10:43:45 -0000 1.1
+++ m4/m4.c 19 Jun 2003 14:50:44 -0000
@@ -25,7 +25,7 @@ m4_create (void)
{
m4 *context = XMALLOC (m4, 1);
- M4_SYMTAB (context) = m4_symtab_create (0);
+ context->symtab = m4_symtab_create (0);
return context;
}
@@ -35,11 +35,10 @@ m4_delete (m4 *context)
{
assert (context);
- if (M4_SYMTAB (context))
- m4_symtab_delete (M4_SYMTAB (context));
+ if (context->symtab)
+ m4_symtab_delete (context->symtab);
xfree (context);
-
}
#undef m4_get_symtab
@@ -47,6 +46,5 @@ m4_symtab *
m4_get_symtab (m4 *context)
{
assert (context);
-
- return m4_get_symtab (context);
+ return context->symtab;
}
Index: m4/m4module.h
===================================================================
RCS file: /cvsroot/m4/m4/m4/m4module.h,v
retrieving revision 1.49
diff -u -p -u -r1.49 m4module.h
--- m4/m4module.h 18 Jun 2003 16:21:54 -0000 1.49
+++ m4/m4module.h 19 Jun 2003 14:50:44 -0000
@@ -31,20 +31,14 @@ BEGIN_C_DECLS
/* Various declarations. */
typedef struct m4 m4;
-typedef struct m4_symbol m4_symbol;
-typedef struct m4_symbol_value m4_symbol_value;
typedef struct m4_hash m4_symtab;
-
+typedef struct m4_symbol m4_symbol;
+typedef struct m4_symbol_value m4_symbol_value;
typedef void m4_builtin_func (m4 *, struct obstack *, int, m4_symbol_value **);
typedef void *m4_module_func (const char *);
typedef struct {
- unsigned char *string; /* characters of the string */
- size_t length; /* length of the string */
-} m4_string;
-
-typedef struct {
const char *name;
const char *value;
} m4_macro;
@@ -80,10 +74,6 @@ extern const char *m4_get_module_name
extern m4_builtin *m4_get_module_builtin_table (lt_dlhandle);
extern m4_macro *m4_get_module_macro_table (lt_dlhandle);
-extern void m4_set_module_macro_table (m4 *context, lt_dlhandle handle,
- const m4_macro *table);
-extern void m4_set_module_builtin_table (m4 *context, lt_dlhandle handle,
- const m4_builtin *table);
/* --- SYMBOL TABLE MANAGEMENT --- */
@@ -110,17 +100,31 @@ extern void m4_symbol_delete (m4_
while (m4_symbol_lookup ((symtab), (name))) \
m4_symbol_popdef ((symtab), (name)); } M4_STMT_END
-extern void m4_set_symbol_traced (m4_symtab*, const char *);
-
-
-
-/* The data for a token, a macro argument, and a macro definition. */
-typedef enum {
- M4_SYMBOL_VOID,
- M4_SYMBOL_TEXT,
- M4_SYMBOL_FUNC
-} m4_symbol_type;
-
+extern m4_symbol_value *m4_get_symbol_value (m4_symbol *symbol);
+extern boolean m4_get_symbol_traced (m4_symbol*);
+extern boolean m4_set_symbol_traced (m4_symbol*, boolean);
+extern boolean m4_set_symbol_name_traced (m4_symtab*, const char *);
+
+#define m4_is_symbol_text(symbol) \
+ (m4_is_symbol_value_text (m4_get_symbol_value (symbol)))
+#define m4_is_symbol_func(symbol) \
+ (m4_is_symbol_value_func (m4_get_symbol_value (symbol)))
+#define m4_get_symbol_text(symbol) \
+ (m4_get_symbol_value_text (m4_get_symbol_value (symbol)))
+#define m4_get_symbol_func(symbol) \
+ (m4_get_symbol_value_func (m4_get_symbol_value (symbol)))
+
+extern m4_symbol_value *m4_symbol_value_create (void);
+extern void m4_symbol_value_delete (m4_symbol_value *);
+extern void m4_symbol_value_copy (m4_symbol_value *,
+ m4_symbol_value *);
+extern boolean m4_is_symbol_value_text (m4_symbol_value *);
+extern boolean m4_is_symbol_value_func (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 *);
+extern void m4_set_symbol_value_text (m4_symbol_value *, char *);
+extern void m4_set_symbol_value_func (m4_symbol_value *,
+ m4_builtin_func *);
@@ -131,10 +135,6 @@ extern const m4_builtin *m4_builtin_find
extern const m4_builtin *m4_builtin_find_by_func (
const m4_builtin *, m4_builtin_func *);
-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_get_symbol_value_text (argv[i]) : "")
#define M4BUILTIN(name) \
@@ -188,6 +188,11 @@ extern int nesting_limit; /* -L */
extern int discard_comments; /* -c */
/* left and right quote, begin and end comment */
+typedef struct {
+ unsigned char *string; /* characters of the string */
+ size_t length; /* length of the string */
+} m4_string;
+
extern m4_string lquote;
extern m4_string rquote;
@@ -401,7 +406,6 @@ extern int m4_current_line;
extern void m4_input_init (void);
extern void m4_input_exit (void);
extern int m4_peek_input (void);
-extern void m4_symbol_value_copy (m4_symbol_value *dest, m4_symbol_value
*src);
extern void m4_skip_line (void);
/* push back input */
Index: m4/m4private.h
===================================================================
RCS file: /cvsroot/m4/m4/m4/m4private.h,v
retrieving revision 1.23
diff -u -p -u -r1.23 m4private.h
--- m4/m4private.h 18 Jun 2003 16:21:54 -0000 1.23
+++ m4/m4private.h 19 Jun 2003 14:50:44 -0000
@@ -25,8 +25,18 @@
#endif
#include <assert.h>
-#include <m4module.h>
+#include "m4module.h"
+
+typedef enum {
+ M4_SYMBOL_VOID,
+ M4_SYMBOL_TEXT,
+ M4_SYMBOL_FUNC
+} m4__symbol_type;
+
+#define BIT_TEST(flags, bit) (((flags) & (bit)) == (bit))
+#define BIT_SET(flags, bit) ((flags) |= (bit))
+#define BIT_RESET(flags, bit) ((flags) &= ~(bit))
/* --- CONTEXT MANAGEMENT --- */
@@ -35,10 +45,9 @@ struct m4 {
m4_symtab *symtab;
};
-#define M4_SYMTAB(context) ((context)->symtab)
-
-#define m4_get_symtab(context) ((context)->symtab)
-
+#ifdef NDEBUG
+# define m4_get_symtab(context) ((context)->symtab)
+#endif
/* --- MODULE MANAGEMENT --- */
@@ -58,33 +67,12 @@ extern void m4__module_exit (m4 *con
/* --- SYMBOL TABLE MANAGEMENT --- */
-extern void m4__symtab_remove_module_references (m4_symtab*, lt_dlhandle);
-
-
-/* TRUE iff strlen(rquote) == strlen(lquote) == 1 */
-extern boolean m4__single_quotes;
-
-/* TRUE iff strlen(bcomm) == strlen(ecomm) == 1 */
-extern boolean m4__single_comments;
-
-/* TRUE iff some character has M4_SYNTAX_ESCAPE */
-extern boolean m4__use_macro_escape;
-
-struct m4_symbol_arg {
- int index;
- int flags;
- char * default_val;
+struct m4_symbol
+{
+ boolean traced;
+ m4_symbol_value * value;
};
-#define SYMBOL_ARG_INDEX(A) ((A)->index)
-#define SYMBOL_ARG_FLAGS(A) ((A)->flags)
-#define SYMBOL_ARG_DEFAULT(A) ((A)->default_val)
-
-/* m4_symbol_arg.flags bit masks: */
-
-#define SYMBOL_ARG_REST_BIT (1 << 0)
-#define SYMBOL_ARG_KEY_BIT (1 << 1)
-
struct m4_symbol_value {
m4_symbol_value * next;
lt_dlhandle handle;
@@ -93,7 +81,7 @@ struct m4_symbol_value {
m4_hash * arg_signature;
int min_args, max_args;
- m4_symbol_type type;
+ m4__symbol_type type;
union {
char * text;
m4_builtin_func * func;
@@ -106,45 +94,68 @@ struct m4_symbol_value {
#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)
+
+#define SYMBOL_NEXT(S) (VALUE_NEXT ((S)->value))
+#define SYMBOL_HANDLE(S) (VALUE_HANDLE ((S)->value))
+#define SYMBOL_FLAGS(S) (VALUE_FLAGS ((S)->value))
+#define SYMBOL_ARG_SIGNATURE(S) (VALUE_ARG_SIGNATURE ((S)->value))
+#define SYMBOL_MIN_ARGS(S) (VALUE_MIN_ARGS ((S)->value))
+#define SYMBOL_MAX_ARGS(S) (VALUE_MAX_ARGS ((S)->value))
+
+#ifdef NDEBUG
+# define m4_get_symbol_traced(S) ((S)->traced)
+# define m4_set_symbol_traced(S, V) ((S)->traced = (V))
+
+# define m4_symbol_value_create() (XCALLOC (m4_symbol_value, 1))
+# define m4_symbol_value_delete(V) (XFREE (V))
+
+# define m4_is_symbol_value_text(V) ((V)->type == M4_SYMBOL_TEXT)
+# define m4_is_symbol_value_func(V) ((V)->type == M4_SYMBOL_FUNC)
+# define m4_get_symbol_value_text(V) ((V)->u.text)
+# define m4_get_symbol_value_func(V) ((V)->u.func)
+
+# define m4_set_symbol_value_text(V, T) \
+ ((V)->type = M4_SYMBOL_TEXT, (V)->u.text = (T))
+# define m4_set_symbol_value_func(V, F) \
+ ((V)->type = M4_SYMBOL_FUNC, (V)->u.func = (F))
+#endif
+
+
/* m4_symbol_value.flags bit masks: */
#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))
-#define BIT_RESET(flags, bit) ((flags) &= ~(bit))
+struct m4_symbol_arg {
+ int index;
+ int flags;
+ char * default_val;
+};
-/* Redefine the exported function to this faster
- macro based version for internal use by the m4 code. */
-#undef M4ARG
-#define M4ARG(i) (argc > (i) ? VALUE_TEXT (argv[i]) : "")
+#define SYMBOL_ARG_INDEX(A) ((A)->index)
+#define SYMBOL_ARG_FLAGS(A) ((A)->flags)
+#define SYMBOL_ARG_DEFAULT(A) ((A)->default_val)
+/* m4_symbol_arg.flags bit masks: */
-struct m4_symbol
-{
- boolean traced;
- m4_symbol_value * value;
-};
+#define SYMBOL_ARG_REST_BIT (1 << 0)
+#define SYMBOL_ARG_KEY_BIT (1 << 1)
+
+extern void m4__symtab_remove_module_references (m4_symtab*, lt_dlhandle);
-#define SYMBOL_TRACED(S) ((S)->traced)
-#define SYMBOL_VALUE(S) ((S)->value)
-#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)))
+
+/* TRUE iff strlen(rquote) == strlen(lquote) == 1 */
+extern boolean m4__single_quotes;
+
+/* TRUE iff strlen(bcomm) == strlen(ecomm) == 1 */
+extern boolean m4__single_comments;
+
+/* TRUE iff some character has M4_SYNTAX_ESCAPE */
+extern boolean m4__use_macro_escape;
/* Various different token types. */
typedef enum {
Index: m4/macro.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/macro.c,v
retrieving revision 1.27
diff -u -p -u -r1.27 macro.c
--- m4/macro.c 18 Jun 2003 16:21:54 -0000 1.27
+++ m4/macro.c 19 Jun 2003 14:50:44 -0000
@@ -61,7 +61,7 @@ expand_token (m4 *context, struct obstac
m4__token_type type, m4_symbol_value *token)
{
m4_symbol *symbol;
- char *text = xstrdup (VALUE_TEXT (token));
+ char *text = xstrdup (m4_get_symbol_value_text (token));
switch (type)
{ /* TOKSW */
@@ -84,8 +84,8 @@ expand_token (m4 *context, struct obstac
symbol = m4_symbol_lookup (M4SYMTAB, textp);
if (symbol == NULL
- || SYMBOL_TYPE (symbol) == M4_SYMBOL_VOID
- || (SYMBOL_TYPE (symbol) == M4_SYMBOL_FUNC
+ || symbol->value->type == M4_SYMBOL_VOID
+ || (symbol->value->type == M4_SYMBOL_FUNC
&& BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_BLIND_ARGS_BIT)
&& !M4_IS_OPEN (m4_peek_input ())))
{
@@ -123,7 +123,7 @@ expand_argument (m4 *context, struct obs
const char *current_file = m4_current_file;
int current_line = m4_current_line;
- VALUE_TYPE (argp) = M4_SYMBOL_VOID;
+ argp->type = M4_SYMBOL_VOID;
/* Skip leading white space. */
do
@@ -137,7 +137,7 @@ expand_argument (m4 *context, struct obs
switch (type)
{ /* TOKSW */
case M4_TOKEN_SIMPLE:
- text = VALUE_TEXT (&token);
+ text = m4_get_symbol_value_text (&token);
if ((M4_IS_COMMA (*text) || M4_IS_CLOSE (*text)) && paren_level == 0)
{
@@ -145,12 +145,11 @@ expand_argument (m4 *context, struct obs
obstack_1grow (obs, '\0');
text = obstack_finish (obs);
- if (VALUE_TYPE (argp) == M4_SYMBOL_VOID)
+ if (argp->type == M4_SYMBOL_VOID)
{
- VALUE_TYPE (argp) = M4_SYMBOL_TEXT;
- VALUE_TEXT (argp) = text;
+ m4_set_symbol_value_text (argp, text);
}
- return (boolean) (M4_IS_COMMA (*VALUE_TEXT (&token)));
+ return (boolean) (M4_IS_COMMA (*m4_get_symbol_value_text
(&token)));
}
if (M4_IS_OPEN (*text))
@@ -215,7 +214,8 @@ ERROR: Recursion limit of %d exceeded, u
macro_call_id++;
my_call_id = macro_call_id;
- traced = (boolean) ((debug_level & M4_DEBUG_TRACE_ALL) || SYMBOL_TRACED
(symbol));
+ traced = (boolean) ((debug_level & M4_DEBUG_TRACE_ALL)
+ || m4_get_symbol_traced (symbol));
obstack_init (&argptr);
obstack_init (&arguments);
@@ -261,8 +261,7 @@ collect_arguments (m4 *context, const ch
groks_macro_args = BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_MACRO_ARGS_BIT);
- VALUE_TYPE (&token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (&token) = (char *) name;
+ m4_set_symbol_value_text (&token, (char *) name);
tokenp = (m4_symbol_value *) obstack_copy (arguments, (void *) &token,
sizeof (token));
obstack_grow (argptr, (void *) &tokenp, sizeof (tokenp));
@@ -275,10 +274,9 @@ collect_arguments (m4 *context, const ch
{
more_args = expand_argument (context, arguments, &token);
- if (!groks_macro_args && VALUE_TYPE (&token) == M4_SYMBOL_FUNC)
+ if (!groks_macro_args && m4_is_symbol_value_func (&token))
{
- VALUE_TYPE (&token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (&token) = "";
+ m4_set_symbol_value_text (&token, "");
}
tokenp = (m4_symbol_value *)
obstack_copy (arguments, (void *) &token, sizeof (token));
@@ -299,17 +297,16 @@ void
m4_call_macro (m4_symbol *symbol, m4 *context, struct obstack *expansion,
int argc, m4_symbol_value **argv)
{
- switch (SYMBOL_TYPE (symbol))
+ if (m4_is_symbol_text (symbol))
{
- case M4_SYMBOL_FUNC:
- (*SYMBOL_FUNC (symbol)) (context, expansion, argc, argv);
- break;
-
- case M4_SYMBOL_TEXT:
m4_process_macro (symbol, context, expansion, argc, argv);
- break;
-
- case M4_SYMBOL_VOID:
+ }
+ else if (m4_is_symbol_func (symbol))
+ {
+ (*m4_get_symbol_func (symbol)) (context, expansion, argc, argv);
+ }
+ else
+ {
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: Bad symbol type in call_macro ()"));
abort ();
@@ -328,7 +325,7 @@ m4_process_macro (m4_symbol *symbol, m4
const unsigned char *text;
int i;
- for (text = SYMBOL_TEXT (symbol); *text != '\0';)
+ for (text = m4_get_symbol_text (symbol); *text != '\0';)
{
if (*text != '$')
{
Index: m4/module.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/module.c,v
retrieving revision 1.22
diff -u -p -u -r1.22 module.c
--- m4/module.c 18 Jun 2003 16:21:54 -0000 1.22
+++ m4/module.c 19 Jun 2003 14:50:44 -0000
@@ -52,13 +52,13 @@
* NULL on failure or else a libtool module handle for the newly mapped
* vm segment containing the module code. If the module is not already
* loaded, m4_module_load() retrieves its value for the symbol
- * `m4_builtin_table', which is installed using m4_set_module_builtin_table().
+ * `m4_builtin_table', which is installed using set_module_builtin_table().
*
* In addition to builtin functions, you can also define static macro
* expansions in the `m4_macro_table' symbol. If you define this symbol
* in your modules, it should be an array of `m4_macro's, mapping macro
* names to the expansion text. Any macros defined in `m4_macro_table'
- * are installed into the M4 symbol table with m4_set_module_macro_table().
+ * are installed into the M4 symbol table with set_module_macro_table().
*
* Each time a module is loaded, the module function prototyped as
* "M4INIT_HANDLER (<module name>)" is called, if defined. Any value
@@ -90,6 +90,9 @@ static int module_remove (m4 *conte
static void module_close (m4 *context, lt_dlhandle handle,
struct obstack *obs);
+static void m4_set_module_macro_table (m4*, lt_dlhandle, const m4_macro*);
+static void m4_set_module_builtin_table (m4*, lt_dlhandle, const m4_builtin*);
+
static lt_dlcaller_id caller_id = 0;
const char *
@@ -116,30 +119,30 @@ m4_get_module_builtin_table (lt_dlhandle
return data ? data->builtin_table : 0;
}
-void
-m4_set_module_builtin_table (m4 *context, lt_dlhandle handle,
+static void
+set_module_builtin_table (m4 *context, lt_dlhandle handle,
const m4_builtin *table)
{
const m4_builtin *bp;
+ assert (context);
assert (handle);
assert (table);
for (bp = table; bp->name != NULL; bp++)
{
- m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
+ m4_symbol_value *value = m4_symbol_value_create ();
char * name;
- 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_set_symbol_value_func (value, bp->func);
+ VALUE_HANDLE (value) = handle;
+ VALUE_MIN_ARGS (value) = bp->min_args;
+ VALUE_MAX_ARGS (value) = bp->max_args;
if (bp->groks_macro_args)
- BIT_SET (VALUE_FLAGS (token), VALUE_MACRO_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (value), VALUE_MACRO_ARGS_BIT);
if (bp->blind_if_no_args)
- BIT_SET (VALUE_FLAGS (token), VALUE_BLIND_ARGS_BIT);
+ BIT_SET (VALUE_FLAGS (value), VALUE_BLIND_ARGS_BIT);
if (prefix_all_builtins)
{
@@ -153,7 +156,7 @@ m4_set_module_builtin_table (m4 *context
name = (char *) bp->name;
- m4_symbol_pushdef (M4SYMTAB, name, token);
+ m4_symbol_pushdef (M4SYMTAB, name, value);
if (prefix_all_builtins)
xfree (name);
@@ -172,21 +175,24 @@ m4_get_module_macro_table (lt_dlhandle h
return data ? data->macro_table : 0;
}
-void
-m4_set_module_macro_table (m4 *context, lt_dlhandle handle,
+static void
+set_module_macro_table (m4 *context, lt_dlhandle handle,
const m4_macro *table)
{
const m4_macro *mp;
+ assert (context);
+ assert (handle);
+ assert (table);
+
for (mp = table; mp->name != NULL; mp++)
{
- m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
+ m4_symbol_value *value = m4_symbol_value_create ();
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (token) = xstrdup (mp->value);
- VALUE_HANDLE (token) = handle;
+ m4_set_symbol_value_text (value, xstrdup (mp->value));
+ VALUE_HANDLE (value) = handle;
- m4_symbol_pushdef (M4SYMTAB, mp->name, token);
+ m4_symbol_pushdef (M4SYMTAB, mp->name, value);
}
}
@@ -213,13 +219,15 @@ m4_module_load (m4 *context, const char
}
else if (info->ref_count == 1)
{
- const m4_builtin *builtin_table = m4_get_module_builtin_table
(handle);
- const m4_macro *macro_table = m4_get_module_macro_table (handle);
+ const m4_builtin *builtin_table
+ = m4_get_module_builtin_table (handle);
+ const m4_macro *macro_table
+ = m4_get_module_macro_table (handle);
/* Install the macro functions. */
if (builtin_table)
{
- m4_set_module_builtin_table (context, handle, builtin_table);
+ set_module_builtin_table (context, handle, builtin_table);
#ifdef DEBUG_MODULES
M4_DEBUG_MESSAGE1("module %s: builtins loaded", name);
#endif /* DEBUG_MODULES */
@@ -228,7 +236,7 @@ m4_module_load (m4 *context, const char
/* Install the user macros. */
if (macro_table)
{
- m4_set_module_macro_table (context, handle, macro_table);
+ set_module_macro_table (context, handle, macro_table);
#ifdef DEBUG_MODULES
M4_DEBUG_MESSAGE1("module %s: macros loaded", name);
#endif /* DEBUG_MODULES */
Index: m4/symtab.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/symtab.c,v
retrieving revision 1.38
diff -u -p -u -r1.38 symtab.c
--- m4/symtab.c 18 Jun 2003 16:21:54 -0000 1.38
+++ m4/symtab.c 19 Jun 2003 14:50:44 -0000
@@ -53,6 +53,7 @@ static void * arg_destroy (m4_hash *h
static void * arg_copy (m4_hash *src, const void *name,
void *arg, m4_hash *dest);
+
/* -- SYMBOL TABLE MANAGEMENT --
@@ -110,7 +111,7 @@ m4__symtab_remove_module_references (m4_
while ((place = m4_get_hash_iterator_next (symtab, place)))
{
m4_symbol *symbol = (m4_symbol *) m4_get_hash_iterator_value (place);
- m4_symbol_value *data = SYMBOL_VALUE (symbol);
+ m4_symbol_value *data = m4_get_symbol_value (symbol);
/* For symbols that have token data... */
if (data)
@@ -124,8 +125,8 @@ m4__symtab_remove_module_references (m4_
{
VALUE_NEXT (data) = VALUE_NEXT (next);
- if (VALUE_TYPE (next) == M4_SYMBOL_TEXT)
- XFREE (VALUE_TEXT (next));
+ if (next->type == M4_SYMBOL_TEXT)
+ xfree (m4_get_symbol_value_text (next));
XFREE (next);
}
else
@@ -149,7 +150,7 @@ symbol_destroy (m4_hash *hash, const voi
{
char *key = xstrdup ((char *) name);
- SYMBOL_TRACED ((m4_symbol *) symbol) = FALSE;
+ m4_set_symbol_traced ((m4_symbol *) symbol, FALSE);
while (key && m4_hash_lookup (hash, key))
m4_symbol_popdef ((m4_symtab *) hash, key);
@@ -175,7 +176,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_VALUE (*psymbol)) ? *psymbol : 0;
+ return (psymbol && m4_get_symbol_value (*psymbol)) ? *psymbol : 0;
}
@@ -192,10 +193,10 @@ m4_symbol_pushdef (m4_symtab *symtab, co
assert (value);
symbol = symtab_fetch (symtab, name);
- VALUE_NEXT (value) = SYMBOL_VALUE (symbol);
- SYMBOL_VALUE (symbol) = value;
+ VALUE_NEXT (value) = m4_get_symbol_value (symbol);
+ symbol->value = value;
- assert (SYMBOL_VALUE (symbol));
+ assert (m4_get_symbol_value (symbol));
return symbol;
}
@@ -212,31 +213,17 @@ m4_symbol_define (m4_symtab *symtab, con
assert (value);
symbol = symtab_fetch (symtab, name);
- if (SYMBOL_VALUE (symbol))
+ if (m4_get_symbol_value (symbol))
symbol_popval (symbol);
- VALUE_NEXT (value) = SYMBOL_VALUE (symbol);
- SYMBOL_VALUE (symbol) = value;
+ VALUE_NEXT (value) = m4_get_symbol_value (symbol);
+ symbol->value = value;
- assert (SYMBOL_VALUE (symbol));
+ assert (m4_get_symbol_value (symbol));
return symbol;
}
-void
-m4_set_symbol_traced (m4_symtab *symtab, const char *name)
-{
- m4_symbol *symbol;
-
- assert (symtab);
- assert (name);
-
- symbol = symtab_fetch (symtab, name);
-
- SYMBOL_TRACED (symbol) = TRUE;
-}
-
-
/* Pop the topmost value stack entry from the symbol associated with
NAME, deleting it from the table entirely if that was the last
remaining value in the stack. */
@@ -252,8 +239,8 @@ 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_VALUE (*psymbol))
- if (no_gnu_extensions || !SYMBOL_TRACED (*psymbol))
+ if (!m4_get_symbol_value (*psymbol))
+ if (no_gnu_extensions || !m4_get_symbol_traced (*psymbol))
{
XFREE (*psymbol);
xfree (m4_hash_remove ((m4_hash *) symtab, name));
@@ -268,19 +255,19 @@ symbol_popval (m4_symbol *symbol)
assert (symbol);
- stale = SYMBOL_VALUE (symbol);
+ stale = m4_get_symbol_value (symbol);
if (stale)
{
- SYMBOL_VALUE (symbol) = VALUE_NEXT (stale);
+ symbol->value = VALUE_NEXT (stale);
if (VALUE_ARG_SIGNATURE (stale))
{
m4_hash_apply (VALUE_ARG_SIGNATURE (stale), arg_destroy, NULL);
m4_hash_delete (VALUE_ARG_SIGNATURE (stale));
}
- if (VALUE_TYPE (stale) == M4_SYMBOL_TEXT)
- XFREE (VALUE_TEXT (stale));
+ if (m4_is_symbol_value_text (stale))
+ xfree (m4_get_symbol_value_text (stale));
XFREE (stale);
}
}
@@ -311,8 +298,8 @@ m4_symbol_value_copy (m4_symbol_value *d
assert (dest);
assert (src);
- if (VALUE_TYPE (dest) == M4_SYMBOL_TEXT)
- xfree (VALUE_TEXT (dest));
+ if (m4_is_symbol_value_text (dest))
+ xfree (m4_get_symbol_value_text (dest));
if (VALUE_ARG_SIGNATURE (dest))
{
@@ -320,7 +307,7 @@ m4_symbol_value_copy (m4_symbol_value *d
m4_hash_delete (VALUE_ARG_SIGNATURE (dest));
}
- /* Copy the token contents over, being careful to preserve
+ /* Copy the valuecontents over, being careful to preserve
the next pointer. */
next = VALUE_NEXT (dest);
bcopy (src, dest, sizeof (m4_symbol_value));
@@ -328,8 +315,8 @@ m4_symbol_value_copy (m4_symbol_value *d
/* Caller is supposed to free text token strings, so we have to
copy the string not just its address in that case. */
- if (VALUE_TYPE (src) == M4_SYMBOL_TEXT)
- VALUE_TEXT (dest) = xstrdup (VALUE_TEXT (src));
+ if (m4_is_symbol_value_text (src))
+ m4_set_symbol_value_text (dest, xstrdup (m4_get_symbol_value_text (src)));
if (VALUE_ARG_SIGNATURE (src))
VALUE_ARG_SIGNATURE (dest) = m4_hash_dup (VALUE_ARG_SIGNATURE (src),
@@ -343,6 +330,124 @@ arg_copy (m4_hash *src, const void *name
return NULL;
}
+boolean
+m4_set_symbol_name_traced (m4_symtab *symtab, const char *name)
+{
+ m4_symbol *symbol;
+
+ assert (symtab);
+ assert (name);
+
+ symbol = symtab_fetch (symtab, name);
+
+ return m4_set_symbol_traced (symbol, TRUE);
+}
+
+/* Define these functions at the end, so that calls in the file use the
+ faster macro version from m4module.h. */
+#undef m4_symtab_apply
+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,
+ userdata);
+}
+
+/* Pop all values from the symbol associated with NAME. */
+#undef m4_symbol_delete
+void
+m4_symbol_delete (m4_symtab *symtab, const char *name)
+{
+ while (m4_symbol_lookup (symtab, name))
+ m4_symbol_popdef (symtab, name);
+}
+
+#undef m4_get_symbol_traced
+boolean
+m4_get_symbol_traced (m4_symbol *symbol)
+{
+ assert (symbol);
+ return symbol->traced;
+}
+
+#undef m4_set_symbol_traced
+boolean
+m4_set_symbol_traced (m4_symbol *symbol, boolean value)
+{
+ assert (symbol);
+ return symbol->traced = value;
+}
+
+#undef m4_symbol_value_create
+m4_symbol_value *
+m4_symbol_value_create (void)
+{
+ return XCALLOC (m4_symbol_value, 1);
+}
+
+#undef m4_get_symbol_value
+m4_symbol_value *
+m4_get_symbol_value (m4_symbol *symbol)
+{
+ assert (symbol);
+ return symbol->value;
+}
+
+#undef m4_is_symbol_value_text
+boolean
+m4_is_symbol_value_text (m4_symbol_value *value)
+{
+ assert (value);
+ return (value->type == M4_SYMBOL_TEXT);
+}
+
+#undef m4_is_symbol_value_func
+boolean
+m4_is_symbol_value_func (m4_symbol_value *value)
+{
+ assert (value);
+ return (value->type == M4_SYMBOL_FUNC);
+}
+
+#undef m4_get_symbol_value_text
+char *
+m4_get_symbol_value_text (m4_symbol_value *value)
+{
+ assert (value);
+ return value->u.text;
+}
+
+#undef m4_get_symbol_value_func
+m4_builtin_func *
+m4_get_symbol_value_func (m4_symbol_value *value)
+{
+ assert (value);
+ return value->u.func;
+}
+
+#undef m4_set_symbol_value_text
+void
+m4_set_symbol_value_text (m4_symbol_value *value, char *text)
+{
+ assert (value);
+ assert (text);
+
+ value->type = M4_SYMBOL_TEXT;
+ value->u.text = text;
+}
+
+#undef m4_set_symbol_value_func
+void
+m4_set_symbol_value_func (m4_symbol_value *value, m4_builtin_func *func)
+{
+ assert (value);
+ assert (func);
+
+ value->type = M4_SYMBOL_FUNC;
+ value->u.func = func;
+}
+
+
#ifdef DEBUG_SYM
@@ -360,7 +465,7 @@ symtab_dump (m4_symtab *symtab)
{
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);
+ m4_symbol_value *token = m4_get_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";
@@ -368,20 +473,20 @@ symtab_dump (m4_symtab *symtab)
fprintf (stderr, "%10s: (%d%s) %s=",
module_name, flags,
- SYMBOL_TRACED (symbol) ? "!" : "", symbol_name);
+ m4_get_symbol_traced (symbol) ? "!" : "", symbol_name);
if (!token)
fputs ("<!UNDEFINED!>", stderr);
else
- switch (SYMBOL_TYPE (symbol))
+ switch (symbol->value->type)
{
case M4_SYMBOL_TEXT:
- fputs (SYMBOL_TEXT (symbol), stderr);
+ fputs (m4_get_symbol_text (symbol), stderr);
break;
case M4_SYMBOL_FUNC:
bp = m4_builtin_find_by_func (m4_get_module_builtin_table (handle),
- SYMBOL_FUNC (symbol));
+ m4_get_symbol_func (symbol));
fprintf (stderr, "<%s>",
bp ? bp->name : "!ERROR!");
break;
@@ -393,22 +498,3 @@ symtab_dump (m4_symtab *symtab)
}
}
#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
-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,
- userdata);
-}
-
-/* Pop all values from the symbol associated with NAME. */
-#undef m4_symbol_delete
-void
-m4_symbol_delete (m4_symtab *symtab, const char *name)
-{
- while (m4_symbol_lookup (symtab, name))
- m4_symbol_popdef (symtab, name);
-}
Index: m4/utility.c
===================================================================
RCS file: /cvsroot/m4/m4/m4/utility.c,v
retrieving revision 1.26
diff -u -p -u -r1.26 utility.c
--- m4/utility.c 18 Jun 2003 16:21:54 -0000 1.26
+++ m4/utility.c 19 Jun 2003 14:50:44 -0000
@@ -71,30 +71,6 @@ m4_string bcomm;
m4_string ecomm;
-/* Addressable function versions of the macros defined in m4private.h.
- 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_symbol_type
-m4_get_symbol_value_type (m4_symbol_value *name)
-{
- return VALUE_TYPE (name);
-}
-
-char *
-m4_get_symbol_value_text (m4_symbol_value *name)
-{
- return VALUE_TEXT (name);
-}
-
-m4_builtin_func *
-m4_get_symbol_value_func (m4_symbol_value *name)
-{
- return VALUE_FUNC (name);
-}
-
-
-
/* Give friendly warnings if a builtin macro is passed an
inappropriate number of arguments. ARGC/ARGV are the arguments,
MIN is the minimum number of acceptable arguments, negative if not
@@ -224,7 +200,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_SYMBOL_VOID)
+ if (((m4_symbol *) symbol)->value->type != M4_SYMBOL_VOID)
{
struct m4_dump_symbol_data *symbol_data
= (struct m4_dump_symbol_data *) data;
@@ -258,7 +234,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_SYMBOL_VOID)
+ if (symbol != NULL && symbol->value->type != M4_SYMBOL_VOID)
m4_dump_symbol (M4ARG (i), symbol, data);
else if (complain)
M4WARN ((warning_status, 0,
Index: modules/gnu.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/gnu.c,v
retrieving revision 1.21
diff -u -p -u -r1.21 gnu.c
--- modules/gnu.c 18 Jun 2003 16:21:55 -0000 1.21
+++ modules/gnu.c 19 Jun 2003 14:50:44 -0000
@@ -27,7 +27,7 @@
# include <stdlib.h>
#endif
-#include "m4module.h"
+#include <m4module.h>
#if HAVE_ERRNO_H
# include <errno.h>
@@ -36,7 +36,10 @@
int errno;
#endif
-#include "m4private.h"
+#ifdef NDEBUG
+# include "m4private.h"
+#endif
+
#include "regex.h"
#define RE_SYNTAX_BRE RE_SYNTAX_EMACS
@@ -477,17 +480,17 @@ M4BUILTIN_HANDLER (symbols)
**/
M4BUILTIN_HANDLER (syncoutput)
{
- if (VALUE_TYPE (argv[1]) != M4_SYMBOL_TEXT)
- return;
-
- if ( M4ARG (1)[0] == '0'
- || M4ARG (1)[0] == 'n'
- || (M4ARG (1)[0] == 'o' && M4ARG (1)[1] == 'f'))
- sync_output = 0;
- else if ( M4ARG (1)[0] == '1'
- || M4ARG (1)[0] == 'y'
- || (M4ARG (1)[0] == 'o' && M4ARG (1)[1] == 'n'))
- sync_output = 1;
+ if (m4_is_symbol_value_text (argv[1]))
+ {
+ if ( M4ARG (1)[0] == '0'
+ || M4ARG (1)[0] == 'n'
+ || (M4ARG (1)[0] == 'o' && M4ARG (1)[1] == 'f'))
+ sync_output = 0;
+ else if ( M4ARG (1)[0] == '1'
+ || M4ARG (1)[0] == 'y'
+ || (M4ARG (1)[0] == 'o' && M4ARG (1)[1] == 'n'))
+ sync_output = 1;
+ }
}
Index: modules/m4.c
===================================================================
RCS file: /cvsroot/m4/m4/modules/m4.c,v
retrieving revision 1.42
diff -u -p -u -r1.42 m4.c
--- modules/m4.c 18 Jun 2003 16:21:55 -0000 1.42
+++ modules/m4.c 19 Jun 2003 14:50:44 -0000
@@ -32,13 +32,17 @@
extern int errno;
#endif
+#include <assert.h>
+
#include <m4module.h>
+#ifdef NDEBUG
/* Include this header for speed, which gives us direct access to
the fields of internal structures at the expense of maintaining
interface/implementation separation. The builtins in this file
are the core of m4 and must be optimised for speed. */
-#include "m4private.h"
+# include "m4private.h"
+#endif
/* Rename exported symbols for dlpreload()ing. */
#define m4_builtin_table m4_LTX_m4_builtin_table
@@ -94,7 +98,7 @@ typedef unsigned long int unumber;
static void include (int argc, m4_symbol_value **argv,
boolean silent);
-static int set_trace (m4_hash *hash, const void *ignored,
+static void * set_trace (m4_hash *hash, const void *ignored,
void *symbol, void *userdata);
static const char *ntoa (number value, int radix);
static void numb_obstack (struct obstack *obs, const number value,
@@ -148,22 +152,16 @@ M4INIT_HANDLER (m4)
M4BUILTIN_HANDLER (define)
{
- if (VALUE_TYPE (argv[1]) == M4_SYMBOL_TEXT)
+ if (m4_is_symbol_value_text (argv[1]))
{
- m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
+ m4_symbol_value *value = m4_symbol_value_create ();
if (argc == 2)
- {
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (token) = xstrdup ("");
- }
+ m4_set_symbol_value_text (value, xstrdup (""));
else
- {
- m4_symbol_value_copy (token, argv[2]);
- VALUE_NEXT (token) = NULL;
- }
+ m4_symbol_value_copy (value, argv[2]);
- m4_symbol_define (M4SYMTAB, M4ARG (1), token);
+ m4_symbol_define (M4SYMTAB, M4ARG (1), value);
}
}
@@ -178,22 +176,16 @@ M4BUILTIN_HANDLER (undefine)
M4BUILTIN_HANDLER (pushdef)
{
- if (VALUE_TYPE (argv[1]) == M4_SYMBOL_TEXT)
+ if (m4_is_symbol_value_text (argv[1]))
{
- m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
+ m4_symbol_value *value = m4_symbol_value_create ();
if (argc == 2)
- {
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (token) = xstrdup ("");
- }
+ m4_set_symbol_value_text (value, xstrdup (""));
else
- {
- m4_symbol_value_copy (token, argv[2]);
- VALUE_NEXT (token) = NULL;
- }
+ m4_symbol_value_copy (value, argv[2]);
- m4_symbol_pushdef (M4SYMTAB, M4ARG (1), token);
+ m4_symbol_pushdef (M4SYMTAB, M4ARG (1), value);
}
}
@@ -289,28 +281,26 @@ 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_SYMBOL_TEXT
- || SYMBOL_TYPE (symbol) == M4_SYMBOL_FUNC
- || SYMBOL_TYPE (symbol) == M4_SYMBOL_VOID);
- switch (SYMBOL_TYPE (symbol))
+
+ if (m4_is_symbol_text (symbol))
{
- case M4_SYMBOL_TEXT:
if (debug_level & M4_DEBUG_TRACE_QUOTE)
fprintf (stderr, "%s%s%s\n",
- lquote.string, SYMBOL_TEXT (symbol), rquote.string);
+ lquote.string, m4_get_symbol_text (symbol),
+ rquote.string);
else
- fprintf (stderr, "%s\n", SYMBOL_TEXT (symbol));
- break;
-
- case M4_SYMBOL_FUNC:
- bp = m4_builtin_find_by_func (NULL, SYMBOL_FUNC (symbol));
+ fprintf (stderr, "%s\n", m4_get_symbol_text (symbol));
+ }
+ else if (m4_is_symbol_func (symbol))
+ {
+ bp = m4_builtin_find_by_func (NULL,
+ m4_get_symbol_func (symbol));
assert (bp);
fprintf (stderr, "<%s>\n", bp->name);
- break;
-
- case M4_SYMBOL_VOID:
- assert (!"VOID token in m4_dumpdef");
- break;
+ }
+ else
+ {
+ assert (!"illegal token in m4_dumpdef");
}
}
}
@@ -330,22 +320,12 @@ M4BUILTIN_HANDLER (defn)
return;
}
- switch (SYMBOL_TYPE (symbol))
- {
- case M4_SYMBOL_TEXT:
- m4_shipout_string (obs, SYMBOL_TEXT (symbol), 0, TRUE);
- return;
-
- case M4_SYMBOL_FUNC:
- m4_push_builtin (SYMBOL_VALUE (symbol));
- return;
-
- case M4_SYMBOL_VOID:
- assert (!"VOID token in m4_dumpdef");
- return;
- }
-
- assert (!"Bad token data type in m4_defn");
+ if (m4_is_symbol_text (symbol))
+ m4_shipout_string (obs, m4_get_symbol_text (symbol), 0, TRUE);
+ else if (m4_is_symbol_func (symbol))
+ m4_push_builtin (m4_get_symbol_value (symbol));
+ else
+ assert (!"Bad token data type in m4_defn");
}
@@ -571,12 +551,12 @@ M4BUILTIN_HANDLER (m4wrap)
/* Set_trace () is used by "traceon" and "traceoff" to enable and disable
tracing of a macro. It disables tracing if DATA is NULL, otherwise it
enable tracing. */
-static int
+static void *
set_trace (m4_hash *hash, const void *ignored, void *symbol,
void *userdata)
{
- SYMBOL_TRACED ((m4_symbol *) symbol) = (boolean) (userdata != NULL);
- return 0;
+ m4_set_symbol_traced ((m4_symbol *) symbol, (boolean) (userdata != NULL));
+ return NULL;
}
M4BUILTIN_HANDLER (traceon)
Index: src/freeze.c
===================================================================
RCS file: /cvsroot/m4/m4/src/freeze.c,v
retrieving revision 1.29
diff -u -p -u -r1.29 freeze.c
--- src/freeze.c 18 Jun 2003 16:21:55 -0000 1.29
+++ src/freeze.c 19 Jun 2003 14:50:44 -0000
@@ -134,27 +134,26 @@ produce_symbol_dump (FILE *file, m4_hash
const char *module_name = handle ? m4_get_module_name (handle)
: NULL;
const m4_builtin *bp;
- switch (SYMBOL_TYPE (symbol))
+ if (m4_is_symbol_text (symbol))
{
- case M4_SYMBOL_TEXT:
fprintf (file, "T%lu,%lu",
(unsigned long) strlen (symbol_name),
- (unsigned long) strlen (SYMBOL_TEXT (symbol)));
+ (unsigned long) strlen (m4_get_symbol_text (symbol)));
if (handle)
fprintf (file, ",%lu", (unsigned long) strlen (module_name));
fputc ('\n', file);
fputs (symbol_name, file);
- fputs (SYMBOL_TEXT (symbol), file);
+ fputs (m4_get_symbol_text (symbol), file);
if (handle)
fputs (module_name, file);
fputc ('\n', file);
- break;
-
- case M4_SYMBOL_FUNC:
+ }
+ else if (m4_is_symbol_func (symbol))
+ {
bp = m4_builtin_find_by_func
(m4_get_module_builtin_table (SYMBOL_HANDLE (symbol)),
- SYMBOL_FUNC (symbol));
+ m4_get_symbol_func (symbol));
if (bp == NULL)
{
@@ -177,13 +176,12 @@ produce_symbol_dump (FILE *file, m4_hash
if (handle)
fputs (module_name, file);
fputc ('\n', file);
- break;
-
- default:
+ }
+ else
+ {
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: Bad token data type in produce_symbol_dump
()"));
abort ();
- break;
}
}
}
@@ -480,8 +478,7 @@ reload_frozen_state (m4 *context, const
if (bp->blind_if_no_args)
BIT_SET (VALUE_FLAGS (token), VALUE_BLIND_ARGS_BIT);
- VALUE_TYPE (token) = M4_SYMBOL_FUNC;
- VALUE_FUNC (token) = bp->func;
+ m4_set_symbol_value_func (token, bp->func);
VALUE_HANDLE (token) = handle;
VALUE_MIN_ARGS (token) = bp->min_args;
VALUE_MAX_ARGS (token) = bp->max_args;
@@ -663,8 +660,7 @@ reload_frozen_state (m4 *context, const
if (strcmp (m4_get_module_name (handle), string[2]) == 0)
break;
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
- VALUE_TEXT (token) = xstrdup (string[1]);
+ m4_set_symbol_value_text (token, xstrdup (string[1]));
VALUE_HANDLE (token) = handle;
VALUE_MAX_ARGS (token) = -1;
Index: src/main.c
===================================================================
RCS file: /cvsroot/m4/m4/src/main.c,v
retrieving revision 1.40
diff -u -p -u -r1.40 main.c
--- src/main.c 18 Jun 2003 16:21:55 -0000 1.40
+++ src/main.c 19 Jun 2003 14:50:44 -0000
@@ -432,17 +432,16 @@ warranty; not even for MERCHANTABILITY o
{
case 'D':
{
- m4_symbol_value *token = XCALLOC (m4_symbol_value, 1);
+ m4_symbol_value *value = m4_symbol_value_create ();
macro_value = strchr (defines->macro, '=');
if (macro_value == NULL)
macro_value = "";
else
*macro_value++ = '\0';
- VALUE_TEXT (token) = xstrdup (macro_value);
- VALUE_TYPE (token) = M4_SYMBOL_TEXT;
+ m4_set_symbol_value_text (value, xstrdup (macro_value));
- m4_symbol_pushdef (M4SYMTAB, defines->macro, token);
+ m4_symbol_pushdef (M4SYMTAB, defines->macro, value);
}
break;
@@ -451,7 +450,7 @@ warranty; not even for MERCHANTABILITY o
break;
case 't':
- m4_set_symbol_traced (M4SYMTAB, defines->macro);
+ m4_set_symbol_name_traced (M4SYMTAB, defines->macro);
break;
case 'm':
- FYI: 16-gary-refactor-symbol-api.patch,
Gary V. Vaughan <=