This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
RFA: first preprocessor macro expansion files
- From: Jim Blandy <jimb at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Mon, 6 May 2002 17:57:30 -0500 (EST)
- Subject: RFA: first preprocessor macro expansion files
This change just adds the macro table and macro expander files to GDB.
It doesn't have any effect on GDB's behavior. Their .o files will go
into libgdb.a, but since nobody yet calls the functions these files
define, and they have no _initialize functions, they don't end up in
the final GDB executable.
2002-05-06 Jim Blandy <jimb@redhat.com>
Add first preprocessor macro-expansion files.
* macroexp.c, macroexp.h, macrotab.c, macrotab.h: New files.
* Makefile.in (SFILES): Add macrotab.c, macroexp.c.
(splay_tree_h, macroexp_h, macrotab_h): New variable.
(HFILES_NO_SRCDIR): Add macrotab.h, macroexp.h.
(COMMON_OBS): Add macrotab.o, macroexp.o.
(macroexp.o, macrotab.o): New rules.
Index: gdb/macroexp.c
===================================================================
RCS file: gdb/macroexp.c
diff -N gdb/macroexp.c
*** gdb/macroexp.c 1 Jan 1970 00:00:00 -0000
--- gdb/macroexp.c 6 May 2002 22:18:41 -0000
***************
*** 0 ****
--- 1,1169 ----
+ /* C preprocessor macro expansion for GDB.
+ Copyright 2002 Free Software Foundation, Inc.
+ Contributed by Red Hat, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+ #include "defs.h"
+ #include "obstack.h"
+ #include "bcache.h"
+ #include "macrotab.h"
+ #include "macroexp.h"
+ #include "gdb_assert.h"
+
+
+
+ /* A resizeable, substringable string type. */
+
+
+ /* A string type that we can resize, quickly append to, and use to
+ refer to substrings of other strings. */
+ struct macro_buffer
+ {
+ /* An array of characters. The first LEN bytes are the real text,
+ but there are SIZE bytes allocated to the array. If SIZE is
+ zero, then this doesn't point to a malloc'ed block. If SHARED is
+ non-zero, then this buffer is actually a pointer into some larger
+ string, and we shouldn't append characters to it, etc. Because
+ of sharing, we can't assume in general that the text is
+ null-terminated. */
+ char *text;
+
+ /* The number of characters in the string. */
+ int len;
+
+ /* The number of characters allocated to the string. If SHARED is
+ non-zero, this is meaningless; in this case, we set it to zero so
+ that any "do we have room to append something?" tests will fail,
+ so we don't always have to check SHARED before using this field. */
+ int size;
+
+ /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
+ block). Non-zero if TEXT is actually pointing into the middle of
+ some other block, and we shouldn't reallocate it. */
+ int shared;
+
+ /* For detecting token splicing.
+
+ This is the index in TEXT of the first character of the token
+ that abuts the end of TEXT. If TEXT contains no tokens, then we
+ set this equal to LEN. If TEXT ends in whitespace, then there is
+ no token abutting the end of TEXT (it's just whitespace), and
+ again, we set this equal to LEN. We set this to -1 if we don't
+ know the nature of TEXT. */
+ int last_token;
+
+ /* If this buffer is holding the result from get_token, then this
+ is non-zero if it is an identifier token, zero otherwise. */
+ int is_identifier;
+ };
+
+
+ /* Set the macro buffer *B to the empty string, guessing that its
+ final contents will fit in N bytes. (It'll get resized if it
+ doesn't, so the guess doesn't have to be right.) Allocate the
+ initial storage with xmalloc. */
+ static void
+ init_buffer (struct macro_buffer *b, int n)
+ {
+ /* Small value for initial testing. */
+ n = 1;
+
+ b->size = n;
+ if (n > 0)
+ b->text = (char *) xmalloc (n);
+ else
+ b->text = 0;
+ b->len = 0;
+ b->shared = 0;
+ b->last_token = -1;
+ }
+
+
+ /* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
+ shared substring. */
+ static void
+ init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
+ {
+ buf->text = addr;
+ buf->len = len;
+ buf->shared = 1;
+ buf->size = 0;
+ buf->last_token = -1;
+ }
+
+
+ /* Free the text of the buffer B. Raise an error if B is shared. */
+ static void
+ free_buffer (struct macro_buffer *b)
+ {
+ gdb_assert (! b->shared);
+ if (b->size)
+ xfree (b->text);
+ }
+
+
+ /* A cleanup function for macro buffers. */
+ static void
+ cleanup_macro_buffer (void *untyped_buf)
+ {
+ free_buffer ((struct macro_buffer *) untyped_buf);
+ }
+
+
+ /* Resize the buffer B to be at least N bytes long. Raise an error if
+ B shouldn't be resized. */
+ static void
+ resize_buffer (struct macro_buffer *b, int n)
+ {
+ /* We shouldn't be trying to resize shared strings. */
+ gdb_assert (! b->shared);
+
+ if (b->size == 0)
+ b->size = n;
+ else
+ while (b->size <= n)
+ b->size *= 2;
+
+ b->text = xrealloc (b->text, b->size);
+ }
+
+
+ /* Append the character C to the buffer B. */
+ static inline void
+ appendc (struct macro_buffer *b, int c)
+ {
+ int new_len = b->len + 1;
+
+ if (new_len > b->size)
+ resize_buffer (b, new_len);
+
+ b->text[b->len] = c;
+ b->len = new_len;
+ }
+
+
+ /* Append the LEN bytes at ADDR to the buffer B. */
+ static inline void
+ appendmem (struct macro_buffer *b, char *addr, int len)
+ {
+ int new_len = b->len + len;
+
+ if (new_len > b->size)
+ resize_buffer (b, new_len);
+
+ memcpy (b->text + b->len, addr, len);
+ b->len = new_len;
+ }
+
+
+
+ /* Recognizing preprocessor tokens. */
+
+
+ static int
+ is_whitespace (int c)
+ {
+ return (c == ' '
+ || c == '\t'
+ || c == '\n'
+ || c == '\v'
+ || c == '\f');
+ }
+
+
+ static int
+ is_digit (int c)
+ {
+ return ('0' <= c && c <= '9');
+ }
+
+
+ static int
+ is_identifier_nondigit (int c)
+ {
+ return (c == '_'
+ || ('a' <= c && c <= 'z')
+ || ('A' <= c && c <= 'Z'));
+ }
+
+
+ static void
+ set_token (struct macro_buffer *tok, char *start, char *end)
+ {
+ init_shared_buffer (tok, start, end - start);
+ tok->last_token = 0;
+
+ /* Presumed; get_identifier may overwrite this. */
+ tok->is_identifier = 0;
+ }
+
+
+ static int
+ get_comment (struct macro_buffer *tok, char *p, char *end)
+ {
+ if (p + 2 > end)
+ return 0;
+ else if (p[0] == '/'
+ && p[1] == '*')
+ {
+ char *tok_start = p;
+
+ p += 2;
+
+ for (; p < end; p++)
+ if (p + 2 <= end
+ && p[0] == '*'
+ && p[1] == '/')
+ {
+ p += 2;
+ set_token (tok, tok_start, p);
+ return 1;
+ }
+
+ error ("Unterminated comment in macro expansion.");
+ }
+ else if (p[0] == '/'
+ && p[1] == '/')
+ {
+ char *tok_start = p;
+
+ p += 2;
+ for (; p < end; p++)
+ if (*p == '\n')
+ break;
+
+ set_token (tok, tok_start, p);
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+
+ static int
+ get_identifier (struct macro_buffer *tok, char *p, char *end)
+ {
+ if (p < end
+ && is_identifier_nondigit (*p))
+ {
+ char *tok_start = p;
+
+ while (p < end
+ && (is_identifier_nondigit (*p)
+ || is_digit (*p)))
+ p++;
+
+ set_token (tok, tok_start, p);
+ tok->is_identifier = 1;
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+
+ static int
+ get_pp_number (struct macro_buffer *tok, char *p, char *end)
+ {
+ if (p < end
+ && (is_digit (*p)
+ || *p == '.'))
+ {
+ char *tok_start = p;
+
+ while (p < end)
+ {
+ if (is_digit (*p)
+ || is_identifier_nondigit (*p)
+ || *p == '.')
+ p++;
+ else if (p + 2 <= end
+ && strchr ("eEpP.", *p)
+ && (p[1] == '+' || p[1] == '-'))
+ p += 2;
+ else
+ break;
+ }
+
+ set_token (tok, tok_start, p);
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+
+
+ /* If the text starting at P going up to (but not including) END
+ starts with a character constant, set *TOK to point to that
+ character constant, and return 1. Otherwise, return zero.
+ Signal an error if it contains a malformed or incomplete character
+ constant. */
+ static int
+ get_character_constant (struct macro_buffer *tok, char *p, char *end)
+ {
+ /* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
+ But of course, what really matters is that we handle it the same
+ way GDB's C/C++ lexer does. So we call parse_escape in utils.c
+ to handle escape sequences. */
+ if ((p + 1 <= end && *p == '\'')
+ || (p + 2 <= end && p[0] == 'L' && p[1] == '\''))
+ {
+ char *tok_start = p;
+ char *body_start;
+
+ if (*p == '\'')
+ p++;
+ else if (*p == 'L')
+ p += 2;
+ else
+ gdb_assert (0);
+
+ body_start = p;
+ for (;;)
+ {
+ if (p >= end)
+ error ("Unmatched single quote.");
+ else if (*p == '\'')
+ {
+ if (p == body_start)
+ error ("A character constant must contain at least one "
+ "character.");
+ p++;
+ break;
+ }
+ else if (*p == '\\')
+ {
+ p++;
+ parse_escape (&p);
+ }
+ else
+ p++;
+ }
+
+ set_token (tok, tok_start, p);
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+
+ /* If the text starting at P going up to (but not including) END
+ starts with a string literal, set *TOK to point to that string
+ literal, and return 1. Otherwise, return zero. Signal an error if
+ it contains a malformed or incomplete string literal. */
+ static int
+ get_string_literal (struct macro_buffer *tok, char *p, char *end)
+ {
+ if ((p + 1 <= end
+ && *p == '\"')
+ || (p + 2 <= end
+ && p[0] == 'L'
+ && p[1] == '\"'))
+ {
+ char *tok_start = p;
+
+ if (*p == '\"')
+ p++;
+ else if (*p == 'L')
+ p += 2;
+ else
+ gdb_assert (0);
+
+ for (;;)
+ {
+ if (p >= end)
+ error ("Unterminated string in expression.");
+ else if (*p == '\"')
+ {
+ p++;
+ break;
+ }
+ else if (*p == '\n')
+ error ("Newline characters may not appear in string "
+ "constants.");
+ else if (*p == '\\')
+ {
+ p++;
+ parse_escape (&p);
+ }
+ else
+ p++;
+ }
+
+ set_token (tok, tok_start, p);
+ return 1;
+ }
+ else
+ return 0;
+ }
+
+
+ static int
+ get_punctuator (struct macro_buffer *tok, char *p, char *end)
+ {
+ /* Here, speed is much less important than correctness and clarity. */
+
+ /* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1 */
+ static const char * const punctuators[] = {
+ "[", "]", "(", ")", "{", "}", ".", "->",
+ "++", "--", "&", "*", "+", "-", "~", "!",
+ "/", "%", "<<", ">>", "<", ">", "<=", ">=", "==", "!=",
+ "^", "|", "&&", "||",
+ "?", ":", ";", "...",
+ "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
+ ",", "#", "##",
+ "<:", ":>", "<%", "%>", "%:", "%:%:",
+ 0
+ };
+
+ int i;
+
+ if (p + 1 <= end)
+ {
+ for (i = 0; punctuators[i]; i++)
+ {
+ const char *punctuator = punctuators[i];
+
+ if (p[0] == punctuator[0])
+ {
+ int len = strlen (punctuator);
+
+ if (p + len <= end
+ && ! memcmp (p, punctuator, len))
+ {
+ set_token (tok, p, p + len);
+ return 1;
+ }
+ }
+ }
+ }
+
+ return 0;
+ }
+
+
+ /* Peel the next preprocessor token off of SRC, and put it in TOK.
+ Mutate TOK to refer to the first token in SRC, and mutate SRC to
+ refer to the text after that token. SRC must be a shared buffer;
+ the resulting TOK will be shared, pointing into the same string SRC
+ does. Initialize TOK's last_token field. Return non-zero if we
+ succeed, or 0 if we didn't find any more tokens in SRC. */
+ static int
+ get_token (struct macro_buffer *tok,
+ struct macro_buffer *src)
+ {
+ char *p = src->text;
+ char *end = p + src->len;
+
+ gdb_assert (src->shared);
+
+ /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
+
+ preprocessing-token:
+ header-name
+ identifier
+ pp-number
+ character-constant
+ string-literal
+ punctuator
+ each non-white-space character that cannot be one of the above
+
+ We don't have to deal with header-name tokens, since those can
+ only occur after a #include, which we will never see. */
+
+ while (p < end)
+ if (is_whitespace (*p))
+ p++;
+ else if (get_comment (tok, p, end))
+ p += tok->len;
+ else if (get_pp_number (tok, p, end)
+ || get_character_constant (tok, p, end)
+ || get_string_literal (tok, p, end)
+ /* Note: the grammar in the standard seems to be
+ ambiguous: L'x' can be either a wide character
+ constant, or an identifier followed by a normal
+ character constant. By trying `get_identifier' after
+ we try get_character_constant and get_string_literal,
+ we give the wide character syntax precedence. Now,
+ since GDB doesn't handle wide character constants
+ anyway, is this the right thing to do? */
+ || get_identifier (tok, p, end)
+ || get_punctuator (tok, p, end))
+ {
+ /* How many characters did we consume, including whitespace? */
+ int consumed = p - src->text + tok->len;
+ src->text += consumed;
+ src->len -= consumed;
+ return 1;
+ }
+ else
+ {
+ /* We have found a "non-whitespace character that cannot be
+ one of the above." Make a token out of it. */
+ int consumed;
+
+ set_token (tok, p, p + 1);
+ consumed = p - src->text + tok->len;
+ src->text += consumed;
+ src->len -= consumed;
+ return 1;
+ }
+
+ return 0;
+ }
+
+
+
+ /* Appending token strings, with and without splicing */
+
+
+ /* Append the macro buffer SRC to the end of DEST, and ensure that
+ doing so doesn't splice the token at the end of SRC with the token
+ at the beginning of DEST. SRC and DEST must have their last_token
+ fields set. Upon return, DEST's last_token field is set correctly.
+
+ For example:
+
+ If DEST is "(" and SRC is "y", then we can return with
+ DEST set to "(y" --- we've simply appended the two buffers.
+
+ However, if DEST is "x" and SRC is "y", then we must not return
+ with DEST set to "xy" --- that would splice the two tokens "x" and
+ "y" together to make a single token "xy". However, it would be
+ fine to return with DEST set to "x y". Similarly, "<" and "<" must
+ yield "< <", not "<<", etc. */
+ static void
+ append_tokens_without_splicing (struct macro_buffer *dest,
+ struct macro_buffer *src)
+ {
+ int original_dest_len = dest->len;
+ struct macro_buffer dest_tail, new_token;
+
+ gdb_assert (src->last_token != -1);
+ gdb_assert (dest->last_token != -1);
+
+ /* First, just try appending the two, and call get_token to see if
+ we got a splice. */
+ appendmem (dest, src->text, src->len);
+
+ /* If DEST originally had no token abutting its end, then we can't
+ have spliced anything, so we're done. */
+ if (dest->last_token == original_dest_len)
+ {
+ dest->last_token = original_dest_len + src->last_token;
+ return;
+ }
+
+ /* Set DEST_TAIL to point to the last token in DEST, followed by
+ all the stuff we just appended. */
+ init_shared_buffer (&dest_tail,
+ dest->text + dest->last_token,
+ dest->len - dest->last_token);
+
+ /* Re-parse DEST's last token. We know that DEST used to contain
+ at least one token, so if it doesn't contain any after the
+ append, then we must have spliced "/" and "*" or "/" and "/" to
+ make a comment start. (Just for the record, I got this right
+ the first time. This is not a bug fix.) */
+ if (get_token (&new_token, &dest_tail)
+ && (new_token.text + new_token.len
+ == dest->text + original_dest_len))
+ {
+ /* No splice, so we're done. */
+ dest->last_token = original_dest_len + src->last_token;
+ return;
+ }
+
+ /* Okay, a simple append caused a splice. Let's chop dest back to
+ its original length and try again, but separate the texts with a
+ space. */
+ dest->len = original_dest_len;
+ appendc (dest, ' ');
+ appendmem (dest, src->text, src->len);
+
+ init_shared_buffer (&dest_tail,
+ dest->text + dest->last_token,
+ dest->len - dest->last_token);
+
+ /* Try to re-parse DEST's last token, as above. */
+ if (get_token (&new_token, &dest_tail)
+ && (new_token.text + new_token.len
+ == dest->text + original_dest_len))
+ {
+ /* No splice, so we're done. */
+ dest->last_token = original_dest_len + 1 + src->last_token;
+ return;
+ }
+
+ /* As far as I know, there's no case where inserting a space isn't
+ enough to prevent a splice. */
+ internal_error (__FILE__, __LINE__,
+ "unable to avoid splicing tokens during macro expansion");
+ }
+
+
+
+ /* Expanding macros! */
+
+
+ /* A singly-linked list of the names of the macros we are currently
+ expanding --- for detecting expansion loops. */
+ struct macro_name_list {
+ const char *name;
+ struct macro_name_list *next;
+ };
+
+
+ /* Return non-zero if we are currently expanding the macro named NAME,
+ according to LIST; otherwise, return zero.
+
+ You know, it would be possible to get rid of all the NO_LOOP
+ arguments to these functions by simply generating a new lookup
+ function and baton which refuses to find the definition for a
+ particular macro, and otherwise delegates the decision to another
+ function/baton pair. But that makes the linked list of excluded
+ macros chained through untyped baton pointers, which will make it
+ harder to debug. :( */
+ static int
+ currently_rescanning (struct macro_name_list *list, const char *name)
+ {
+ for (; list; list = list->next)
+ if (! strcmp (name, list->name))
+ return 1;
+
+ return 0;
+ }
+
+
+ /* Gather the arguments to a macro expansion.
+
+ NAME is the name of the macro being invoked. (It's only used for
+ printing error messages.)
+
+ Assume that SRC is the text of the macro invocation immediately
+ following the macro name. For example, if we're processing the
+ text foo(bar, baz), then NAME would be foo and SRC will be (bar,
+ baz).
+
+ If SRC doesn't start with an open paren ( token at all, return
+ zero, leave SRC unchanged, and don't set *ARGC_P to anything.
+
+ If SRC doesn't contain a properly terminated argument list, then
+ raise an error.
+
+ Otherwise, return a pointer to the first element of an array of
+ macro buffers referring to the argument texts, and set *ARGC_P to
+ the number of arguments we found --- the number of elements in the
+ array. The macro buffers share their text with SRC, and their
+ last_token fields are initialized. The array is allocated with
+ xmalloc, and the caller is responsible for freeing it.
+
+ NOTE WELL: if SRC starts with a open paren ( token followed
+ immediately by a close paren ) token (e.g., the invocation looks
+ like "foo()"), we treat that as one argument, which happens to be
+ the empty list of tokens. The caller should keep in mind that such
+ a sequence of tokens is a valid way to invoke one-parameter
+ function-like macros, but also a valid way to invoke zero-parameter
+ function-like macros. Eeew.
+
+ Consume the tokens from SRC; after this call, SRC contains the text
+ following the invocation. */
+
+ static struct macro_buffer *
+ gather_arguments (const char *name, struct macro_buffer *src, int *argc_p)
+ {
+ struct macro_buffer tok;
+ int args_len, args_size;
+ struct macro_buffer *args = 0;
+ struct cleanup *back_to = make_cleanup (free_current_contents, &args);
+
+ /* Does SRC start with an opening paren token? Read from a copy of
+ SRC, so SRC itself is unaffected if we don't find an opening
+ paren. */
+ {
+ struct macro_buffer temp;
+ init_shared_buffer (&temp, src->text, src->len);
+
+ if (! get_token (&tok, &temp)
+ || tok.len != 1
+ || tok.text[0] != '(')
+ {
+ discard_cleanups (back_to);
+ return 0;
+ }
+ }
+
+ /* Consume SRC's opening paren. */
+ get_token (&tok, src);
+
+ args_len = 0;
+ args_size = 1; /* small for initial testing */
+ args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
+
+ for (;;)
+ {
+ struct macro_buffer *arg;
+ int depth;
+
+ /* Make sure we have room for the next argument. */
+ if (args_len >= args_size)
+ {
+ args_size *= 2;
+ args = xrealloc (args, sizeof (*args) * args_size);
+ }
+
+ /* Initialize the next argument. */
+ arg = &args[args_len++];
+ set_token (arg, src->text, src->text);
+
+ /* Gather the argument's tokens. */
+ depth = 0;
+ for (;;)
+ {
+ char *start = src->text;
+
+ if (! get_token (&tok, src))
+ error ("Malformed argument list for macro `%s'.", name);
+
+ /* Is tok an opening paren? */
+ if (tok.len == 1 && tok.text[0] == '(')
+ depth++;
+
+ /* Is tok is a closing paren? */
+ else if (tok.len == 1 && tok.text[0] == ')')
+ {
+ /* If it's a closing paren at the top level, then that's
+ the end of the argument list. */
+ if (depth == 0)
+ {
+ discard_cleanups (back_to);
+ *argc_p = args_len;
+ return args;
+ }
+
+ depth--;
+ }
+
+ /* If tok is a comma at top level, then that's the end of
+ the current argument. */
+ else if (tok.len == 1 && tok.text[0] == ',' && depth == 0)
+ break;
+
+ /* Extend the current argument to enclose this token. If
+ this is the current argument's first token, leave out any
+ leading whitespace, just for aesthetics. */
+ if (arg->len == 0)
+ {
+ arg->text = tok.text;
+ arg->len = tok.len;
+ arg->last_token = 0;
+ }
+ else
+ {
+ arg->len = (tok.text + tok.len) - arg->text;
+ arg->last_token = tok.text - arg->text;
+ }
+ }
+ }
+ }
+
+
+ /* The `expand' and `substitute_args' functions both invoke `scan'
+ recursively, so we need a forward declaration somewhere. */
+ static void scan (struct macro_buffer *dest,
+ struct macro_buffer *src,
+ struct macro_name_list *no_loop,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton);
+
+
+ /* Given the macro definition DEF, being invoked with the actual
+ arguments given by ARGC and ARGV, substitute the arguments into the
+ replacement list, and store the result in DEST.
+
+ If it is necessary to expand macro invocations in one of the
+ arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
+ definitions, and don't expand invocations of the macros listed in
+ NO_LOOP. */
+ static void
+ substitute_args (struct macro_buffer *dest,
+ struct macro_definition *def,
+ int argc, struct macro_buffer *argv,
+ struct macro_name_list *no_loop,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton)
+ {
+ /* A macro buffer for the macro's replacement list. */
+ struct macro_buffer replacement_list;
+
+ init_shared_buffer (&replacement_list, (char *) def->replacement,
+ strlen (def->replacement));
+
+ gdb_assert (dest->len == 0);
+ dest->last_token = 0;
+
+ for (;;)
+ {
+ struct macro_buffer tok;
+ char *original_rl_start = replacement_list.text;
+ int substituted = 0;
+
+ /* Find the next token in the replacement list. */
+ if (! get_token (&tok, &replacement_list))
+ break;
+
+ /* Just for aesthetics. If we skipped some whitespace, copy
+ that to DEST. */
+ if (tok.text > original_rl_start)
+ {
+ appendmem (dest, original_rl_start, tok.text - original_rl_start);
+ dest->last_token = dest->len;
+ }
+
+ /* Is this token the stringification operator? */
+ if (tok.len == 1
+ && tok.text[0] == '#')
+ error ("Stringification is not implemented yet.");
+
+ /* Is this token the splicing operator? */
+ if (tok.len == 2
+ && tok.text[0] == '#'
+ && tok.text[1] == '#')
+ error ("Token splicing is not implemented yet.");
+
+ /* Is this token an identifier? */
+ if (tok.is_identifier)
+ {
+ int i;
+
+ /* Is it the magic varargs parameter? */
+ if (tok.len == 11
+ && ! memcmp (tok.text, "__VA_ARGS__", 11))
+ error ("Variable-arity macros not implemented yet.");
+
+ /* Is it one of the parameters? */
+ for (i = 0; i < def->argc; i++)
+ if (tok.len == strlen (def->argv[i])
+ && ! memcmp (tok.text, def->argv[i], tok.len))
+ {
+ struct macro_buffer arg_src;
+
+ /* Expand any macro invocations in the argument text,
+ and append the result to dest. Remember that scan
+ mutates its source, so we need to scan a new buffer
+ referring to the argument's text, not the argument
+ itself. */
+ init_shared_buffer (&arg_src, argv[i].text, argv[i].len);
+ scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
+ substituted = 1;
+ break;
+ }
+ }
+
+ /* If it wasn't a parameter, then just copy it across. */
+ if (! substituted)
+ append_tokens_without_splicing (dest, &tok);
+ }
+ }
+
+
+ /* Expand a call to a macro named ID, whose definition is DEF. Append
+ its expansion to DEST. SRC is the input text following the ID
+ token. We are currently rescanning the expansions of the macros
+ named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
+ LOOKUP_BATON to find definitions for any nested macro references.
+
+ Return 1 if we decided to expand it, zero otherwise. (If it's a
+ function-like macro name that isn't followed by an argument list,
+ we don't expand it.) If we return zero, leave SRC unchanged. */
+ static int
+ expand (const char *id,
+ struct macro_definition *def,
+ struct macro_buffer *dest,
+ struct macro_buffer *src,
+ struct macro_name_list *no_loop,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton)
+ {
+ struct macro_name_list new_no_loop;
+
+ /* Create a new node to be added to the front of the no-expand list.
+ This list is appropriate for re-scanning replacement lists, but
+ it is *not* appropriate for scanning macro arguments; invocations
+ of the macro whose arguments we are gathering *do* get expanded
+ there. */
+ new_no_loop.name = id;
+ new_no_loop.next = no_loop;
+
+ /* What kind of macro are we expanding? */
+ if (def->kind == macro_object_like)
+ {
+ struct macro_buffer replacement_list;
+
+ init_shared_buffer (&replacement_list, (char *) def->replacement,
+ strlen (def->replacement));
+
+ scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
+ return 1;
+ }
+ else if (def->kind == macro_function_like)
+ {
+ struct cleanup *back_to = make_cleanup (null_cleanup, 0);
+ int argc;
+ struct macro_buffer *argv = 0;
+ struct macro_buffer substituted;
+ struct macro_buffer substituted_src;
+
+ if (def->argc >= 1
+ && ! strcmp (def->argv[def->argc - 1], "..."))
+ error ("Varargs macros not implemented yet.");
+
+ make_cleanup (free_current_contents, &argv);
+ argv = gather_arguments (id, src, &argc);
+
+ /* If we couldn't find any argument list, then we don't expand
+ this macro. */
+ if (! argv)
+ {
+ do_cleanups (back_to);
+ return 0;
+ }
+
+ /* Check that we're passing an acceptable number of arguments for
+ this macro. */
+ if (argc != def->argc)
+ {
+ /* Remember that a sequence of tokens like "foo()" is a
+ valid invocation of a macro expecting either zero or one
+ arguments. */
+ if (! (argc == 1
+ && argv[0].len == 0
+ && def->argc == 0))
+ error ("Wrong number of arguments to macro `%s' "
+ "(expected %d, got %d).",
+ id, def->argc, argc);
+ }
+
+ /* Note that we don't expand macro invocations in the arguments
+ yet --- we let subst_args take care of that. Parameters that
+ appear as operands of the stringifying operator "#" or the
+ splicing operator "##" don't get macro references expanded,
+ so we can't really tell whether it's appropriate to macro-
+ expand an argument until we see how it's being used. */
+ init_buffer (&substituted, 0);
+ make_cleanup (cleanup_macro_buffer, &substituted);
+ substitute_args (&substituted, def, argc, argv, no_loop,
+ lookup_func, lookup_baton);
+
+ /* Now `substituted' is the macro's replacement list, with all
+ argument values substituted into it properly. Re-scan it for
+ macro references, but don't expand invocations of this macro.
+
+ We create a new buffer, `substituted_src', which points into
+ `substituted', and scan that. We can't scan `substituted'
+ itself, since the tokenization process moves the buffer's
+ text pointer around, and we still need to be able to find
+ `substituted's original text buffer after scanning it so we
+ can free it. */
+ init_shared_buffer (&substituted_src, substituted.text, substituted.len);
+ scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
+
+ do_cleanups (back_to);
+
+ return 1;
+ }
+ else
+ internal_error (__FILE__, __LINE__, "bad macro definition kind");
+ }
+
+
+ /* If the single token in SRC_FIRST followed by the tokens in SRC_REST
+ constitute a macro invokation not forbidden in NO_LOOP, append its
+ expansion to DEST and return non-zero. Otherwise, return zero, and
+ leave DEST unchanged.
+
+ SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
+ SRC_FIRST must be a string built by get_token. */
+ static int
+ maybe_expand (struct macro_buffer *dest,
+ struct macro_buffer *src_first,
+ struct macro_buffer *src_rest,
+ struct macro_name_list *no_loop,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton)
+ {
+ gdb_assert (src_first->shared);
+ gdb_assert (src_rest->shared);
+ gdb_assert (! dest->shared);
+
+ /* Is this token an identifier? */
+ if (src_first->is_identifier)
+ {
+ /* Make a null-terminated copy of it, since that's what our
+ lookup function expects. */
+ char *id = xmalloc (src_first->len + 1);
+ struct cleanup *back_to = make_cleanup (xfree, id);
+ memcpy (id, src_first->text, src_first->len);
+ id[src_first->len] = 0;
+
+ /* If we're currently re-scanning the result of expanding
+ this macro, don't expand it again. */
+ if (! currently_rescanning (no_loop, id))
+ {
+ /* Does this identifier have a macro definition in scope? */
+ struct macro_definition *def = lookup_func (id, lookup_baton);
+
+ if (def && expand (id, def, dest, src_rest, no_loop,
+ lookup_func, lookup_baton))
+ {
+ do_cleanups (back_to);
+ return 1;
+ }
+ }
+
+ do_cleanups (back_to);
+ }
+
+ return 0;
+ }
+
+
+ /* Expand macro references in SRC, appending the results to DEST.
+ Assume we are re-scanning the result of expanding the macros named
+ in NO_LOOP, and don't try to re-expand references to them.
+
+ SRC must be a shared buffer; DEST must not be one. */
+ static void
+ scan (struct macro_buffer *dest,
+ struct macro_buffer *src,
+ struct macro_name_list *no_loop,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton)
+ {
+ gdb_assert (src->shared);
+ gdb_assert (! dest->shared);
+
+ for (;;)
+ {
+ struct macro_buffer tok;
+ char *original_src_start = src->text;
+
+ /* Find the next token in SRC. */
+ if (! get_token (&tok, src))
+ break;
+
+ /* Just for aesthetics. If we skipped some whitespace, copy
+ that to DEST. */
+ if (tok.text > original_src_start)
+ {
+ appendmem (dest, original_src_start, tok.text - original_src_start);
+ dest->last_token = dest->len;
+ }
+
+ if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
+ /* We didn't end up expanding tok as a macro reference, so
+ simply append it to dest. */
+ append_tokens_without_splicing (dest, &tok);
+ }
+
+ /* Just for aesthetics. If there was any trailing whitespace in
+ src, copy it to dest. */
+ if (src->len)
+ {
+ appendmem (dest, src->text, src->len);
+ dest->last_token = dest->len;
+ }
+ }
+
+
+ char *
+ macro_expand (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton)
+ {
+ struct macro_buffer src, dest;
+ struct cleanup *back_to;
+
+ init_shared_buffer (&src, (char *) source, strlen (source));
+
+ init_buffer (&dest, 0);
+ dest.last_token = 0;
+ back_to = make_cleanup (cleanup_macro_buffer, &dest);
+
+ scan (&dest, &src, 0, lookup_func, lookup_func_baton);
+
+ appendc (&dest, '\0');
+
+ discard_cleanups (back_to);
+ return dest.text;
+ }
+
+
+ char *
+ macro_expand_once (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton)
+ {
+ error ("Expand-once not implemented yet.");
+ }
+
+
+ char *
+ macro_expand_next (char **lexptr,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton)
+ {
+ struct macro_buffer src, dest, tok;
+ struct cleanup *back_to;
+
+ /* Set up SRC to refer to the input text, pointed to by *lexptr. */
+ init_shared_buffer (&src, *lexptr, strlen (*lexptr));
+
+ /* Set up DEST to receive the expansion, if there is one. */
+ init_buffer (&dest, 0);
+ dest.last_token = 0;
+ back_to = make_cleanup (cleanup_macro_buffer, &dest);
+
+ /* Get the text's first preprocessing token. */
+ if (! get_token (&tok, &src))
+ {
+ do_cleanups (back_to);
+ return 0;
+ }
+
+ /* If it's a macro invocation, expand it. */
+ if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
+ {
+ /* It was a macro invocation! Package up the expansion as a
+ null-terminated string and return it. Set *lexptr to the
+ start of the next token in the input. */
+ appendc (&dest, '\0');
+ discard_cleanups (back_to);
+ *lexptr = src.text;
+ return dest.text;
+ }
+ else
+ {
+ /* It wasn't a macro invocation. */
+ do_cleanups (back_to);
+ return 0;
+ }
+ }
Index: gdb/macroexp.h
===================================================================
RCS file: gdb/macroexp.h
diff -N gdb/macroexp.h
*** gdb/macroexp.h 1 Jan 1970 00:00:00 -0000
--- gdb/macroexp.h 6 May 2002 22:18:41 -0000
***************
*** 0 ****
--- 1,90 ----
+ /* Interface to C preprocessor macro expansion for GDB.
+ Copyright 2002 Free Software Foundation, Inc.
+ Contributed by Red Hat, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+
+ #ifndef MACROEXP_H
+ #define MACROEXP_H
+
+ /* A function for looking up preprocessor macro definitions. Return
+ the preprocessor definition of NAME in scope according to BATON, or
+ zero if NAME is not defined as a preprocessor macro.
+
+ The caller must not free or modify the definition returned. It is
+ probably unwise for the caller to hold pointers to it for very
+ long; it probably lives in some objfile's obstacks. */
+ typedef struct macro_definition *(macro_lookup_ftype) (const char *name,
+ void *baton);
+
+
+ /* Expand any preprocessor macros in SOURCE, and return the expanded
+ text. Use LOOKUP_FUNC and LOOKUP_FUNC_BATON to find identifiers'
+ preprocessor definitions. SOURCE is a null-terminated string. The
+ result is a null-terminated string, allocated using xmalloc; it is
+ the caller's responsibility to free it. */
+ char *macro_expand (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);
+
+
+ /* Expand all preprocessor macro references that appear explicitly in
+ SOURCE, but do not expand any new macro references introduced by
+ that first level of expansion. Use LOOKUP_FUNC and
+ LOOKUP_FUNC_BATON to find identifiers' preprocessor definitions.
+ SOURCE is a null-terminated string. The result is a
+ null-terminated string, allocated using xmalloc; it is the caller's
+ responsibility to free it. */
+ char *macro_expand_once (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);
+
+
+ /* If the null-terminated string pointed to by *LEXPTR begins with a
+ macro invocation, return the result of expanding that invocation as
+ a null-terminated string, and set *LEXPTR to the next character
+ after the invocation. The result is completely expanded; it
+ contains no further macro invocations.
+
+ Otherwise, if *LEXPTR does not start with a macro invocation,
+ return zero, and leave *LEXPTR unchanged.
+
+ Use LOOKUP_FUNC and LOOKUP_BATON to find macro definitions.
+
+ If this function returns a string, the caller is responsible for
+ freeing it, using xfree.
+
+ We need this expand-one-token-at-a-time interface in order to
+ accomodate GDB's C expression parser, which may not consume the
+ entire string. When the user enters a command like
+
+ (gdb) break *func+20 if x == 5
+
+ the parser is expected to consume `func+20', and then stop when it
+ sees the "if". But of course, "if" appearing in a character string
+ or as part of a larger identifier doesn't count. So you pretty
+ much have to do tokenization to find the end of the string that
+ needs to be macro-expanded. Our C/C++ tokenizer isn't really
+ designed to be called by anything but the yacc parser engine. */
+ char *macro_expand_next (char **lexptr,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_baton);
+
+
+ #endif /* MACROEXP_H */
Index: gdb/macrotab.c
===================================================================
RCS file: gdb/macrotab.c
diff -N gdb/macrotab.c
*** gdb/macrotab.c 1 Jan 1970 00:00:00 -0000
--- gdb/macrotab.c 6 May 2002 22:18:41 -0000
***************
*** 0 ****
--- 1,862 ----
+ /* C preprocessor macro tables for GDB.
+ Copyright 2002 Free Software Foundation, Inc.
+ Contributed by Red Hat, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+ #include "defs.h"
+ #include "obstack.h"
+ #include "splay-tree.h"
+ #include "symtab.h"
+ #include "symfile.h"
+ #include "objfiles.h"
+ #include "macrotab.h"
+ #include "gdb_assert.h"
+ #include "bcache.h"
+ #include "complaints.h"
+
+
+ /* The macro table structure. */
+
+ struct macro_table
+ {
+ /* The obstack this table's data should be allocated in, or zero if
+ we should use xmalloc. */
+ struct obstack *obstack;
+
+ /* The bcache we should use to hold macro names, argument names, and
+ definitions, or zero if we should use xmalloc. */
+ struct bcache *bcache;
+
+ /* The main source file for this compilation unit --- the one whose
+ name was given to the compiler. This is the root of the
+ #inclusion tree; everything else is #included from here. */
+ struct macro_source_file *main_source;
+
+ /* The table of macro definitions. This is a splay tree (an ordered
+ binary tree that stays balanced, effectively), sorted by macro
+ name. Where a macro gets defined more than once (presumably with
+ an #undefinition in between), we sort the definitions by the
+ order they would appear in the preprocessor's output. That is,
+ if `a.c' #includes `m.h' and then #includes `n.h', and both
+ header files #define X (with an #undef somewhere in between),
+ then the definition from `m.h' appears in our splay tree before
+ the one from `n.h'.
+
+ The splay tree's keys are `struct macro_key' pointers;
+ the values are `struct macro_definition' pointers.
+
+ The splay tree, its nodes, and the keys and values are allocated
+ in obstack, if it's non-zero, or with xmalloc otherwise. The
+ macro names, argument names, argument name arrays, and definition
+ strings are all allocated in bcache, if non-zero, or with xmalloc
+ otherwise. */
+ splay_tree definitions;
+ };
+
+
+
+ /* Allocation and freeing functions. */
+
+ /* Allocate SIZE bytes of memory appropriately for the macro table T.
+ This just checks whether T has an obstack, or whether its pieces
+ should be allocated with xmalloc. */
+ static void *
+ macro_alloc (int size, struct macro_table *t)
+ {
+ if (t->obstack)
+ return obstack_alloc (t->obstack, size);
+ else
+ return xmalloc (size);
+ }
+
+
+ static void
+ macro_free (void *object, struct macro_table *t)
+ {
+ gdb_assert (! t->obstack);
+ xfree (object);
+ }
+
+
+ /* If the macro table T has a bcache, then cache the LEN bytes at ADDR
+ there, and return the cached copy. Otherwise, just xmalloc a copy
+ of the bytes, and return a pointer to that. */
+ static const void *
+ macro_bcache (struct macro_table *t, const void *addr, int len)
+ {
+ if (t->bcache)
+ return bcache (addr, len, t->bcache);
+ else
+ {
+ void *copy = xmalloc (len);
+ memcpy (copy, addr, len);
+ return copy;
+ }
+ }
+
+
+ /* If the macro table T has a bcache, cache the null-terminated string
+ S there, and return a pointer to the cached copy. Otherwise,
+ xmalloc a copy and return that. */
+ static const char *
+ macro_bcache_str (struct macro_table *t, const char *s)
+ {
+ return (char *) macro_bcache (t, s, strlen (s) + 1);
+ }
+
+
+ /* Free a possibly bcached object OBJ. That is, if the macro table T
+ has a bcache, it's an error; otherwise, xfree OBJ. */
+ void
+ macro_bcache_free (struct macro_table *t, void *obj)
+ {
+ gdb_assert (! t->bcache);
+ xfree (obj);
+ }
+
+
+
+ /* Macro tree keys, w/their comparison, allocation, and freeing functions. */
+
+ /* A key in the splay tree. */
+ struct macro_key
+ {
+ /* The table we're in. We only need this in order to free it, since
+ the splay tree library's key and value freeing functions require
+ that the key or value contain all the information needed to free
+ themselves. */
+ struct macro_table *table;
+
+ /* The name of the macro. This is in the table's bcache, if it has
+ one. */
+ const char *name;
+
+ /* The source file and line number where the definition's scope
+ begins. This is also the line of the definition itself. */
+ struct macro_source_file *start_file;
+ int start_line;
+
+ /* The first source file and line after the definition's scope.
+ (That is, the scope does not include this endpoint.) If end_file
+ is zero, then the definition extends to the end of the
+ compilation unit. */
+ struct macro_source_file *end_file;
+ int end_line;
+ };
+
+
+ /* Return the #inclusion depth of the source file FILE. This is the
+ number of #inclusions it took to reach this file. For the main
+ source file, the #inclusion depth is zero; for a file it #includes
+ directly, the depth would be one; and so on. */
+ static int
+ inclusion_depth (struct macro_source_file *file)
+ {
+ int depth;
+
+ for (depth = 0; file->included_by; depth++)
+ file = file->included_by;
+
+ return depth;
+ }
+
+
+ /* Compare two source locations (from the same compilation unit).
+ This is part of the comparison function for the tree of
+ definitions.
+
+ LINE1 and LINE2 are line numbers in the source files FILE1 and
+ FILE2. Return a value:
+ - less than zero if {LINE,FILE}1 comes before {LINE,FILE}2,
+ - greater than zero if {LINE,FILE}1 comes after {LINE,FILE}2, or
+ - zero if they are equal.
+
+ When the two locations are in different source files --- perhaps
+ one is in a header, while another is in the main source file --- we
+ order them by where they would appear in the fully pre-processed
+ sources, where all the #included files have been substituted into
+ their places. */
+ static int
+ compare_locations (struct macro_source_file *file1, int line1,
+ struct macro_source_file *file2, int line2)
+ {
+ /* We want to treat positions in an #included file as coming *after*
+ the line containing the #include, but *before* the line after the
+ include. As we walk up the #inclusion tree toward the main
+ source file, we update fileX and lineX as we go; includedX
+ indicates whether the original position was from the #included
+ file. */
+ int included1 = 0;
+ int included2 = 0;
+
+ /* If a file is zero, that means "end of compilation unit." Handle
+ that specially. */
+ if (! file1)
+ {
+ if (! file2)
+ return 0;
+ else
+ return 1;
+ }
+ else if (! file2)
+ return -1;
+
+ /* If the two files are not the same, find their common ancestor in
+ the #inclusion tree. */
+ if (file1 != file2)
+ {
+ /* If one file is deeper than the other, walk up the #inclusion
+ chain until the two files are at least at the same *depth*.
+ Then, walk up both files in synchrony until they're the same
+ file. That file is the common ancestor. */
+ int depth1 = inclusion_depth (file1);
+ int depth2 = inclusion_depth (file2);
+
+ /* Only one of these while loops will ever execute in any given
+ case. */
+ while (depth1 > depth2)
+ {
+ line1 = file1->included_at_line;
+ file1 = file1->included_by;
+ included1 = 1;
+ depth1--;
+ }
+ while (depth2 > depth1)
+ {
+ line2 = file2->included_at_line;
+ file2 = file2->included_by;
+ included2 = 1;
+ depth2--;
+ }
+
+ /* Now both file1 and file2 are at the same depth. Walk toward
+ the root of the tree until we find where the branches meet. */
+ while (file1 != file2)
+ {
+ line1 = file1->included_at_line;
+ file1 = file1->included_by;
+ /* At this point, we know that the case the includedX flags
+ are trying to deal with won't come up, but we'll just
+ maintain them anyway. */
+ included1 = 1;
+
+ line2 = file2->included_at_line;
+ file2 = file2->included_by;
+ included2 = 1;
+
+ /* Sanity check. If file1 and file2 are really from the
+ same compilation unit, then they should both be part of
+ the same tree, and this shouldn't happen. */
+ gdb_assert (file1 && file2);
+ }
+ }
+
+ /* Now we've got two line numbers in the same file. */
+ if (line1 == line2)
+ {
+ /* They can't both be from #included files. Then we shouldn't
+ have walked up this far. */
+ gdb_assert (! included1 || ! included2);
+
+ /* Any #included position comes after a non-#included position
+ with the same line number in the #including file. */
+ if (included1)
+ return 1;
+ else if (included2)
+ return -1;
+ else
+ return 0;
+ }
+ else
+ return line1 - line2;
+ }
+
+
+ /* Compare a macro key KEY against NAME, the source file FILE, and
+ line number LINE.
+
+ Sort definitions by name; for two definitions with the same name,
+ place the one whose definition comes earlier before the one whose
+ definition comes later.
+
+ Return -1, 0, or 1 if key comes before, is identical to, or comes
+ after NAME, FILE, and LINE. */
+ static int
+ key_compare (struct macro_key *key,
+ const char *name, struct macro_source_file *file, int line)
+ {
+ int names = strcmp (key->name, name);
+ if (names)
+ return names;
+
+ return compare_locations (key->start_file, key->start_line,
+ file, line);
+ }
+
+
+ /* The macro tree comparison function, typed for the splay tree
+ library's happiness. */
+ static int
+ macro_tree_compare (splay_tree_key untyped_key1,
+ splay_tree_key untyped_key2)
+ {
+ struct macro_key *key1 = (struct macro_key *) untyped_key1;
+ struct macro_key *key2 = (struct macro_key *) untyped_key2;
+
+ return key_compare (key1, key2->name, key2->start_file, key2->start_line);
+ }
+
+
+ /* Construct a new macro key node for a macro in table T whose name is
+ NAME, and whose scope starts at LINE in FILE; register the name in
+ the bcache. */
+ static struct macro_key *
+ new_macro_key (struct macro_table *t,
+ const char *name,
+ struct macro_source_file *file,
+ int line)
+ {
+ struct macro_key *k = macro_alloc (sizeof (*k), t);
+
+ memset (k, 0, sizeof (*k));
+ k->table = t;
+ k->name = macro_bcache_str (t, name);
+ k->start_file = file;
+ k->start_line = line;
+ k->end_file = 0;
+
+ return k;
+ }
+
+
+ static void
+ macro_tree_delete_key (void *untyped_key)
+ {
+ struct macro_key *key = (struct macro_key *) untyped_key;
+
+ macro_bcache_free (key->table, (char *) key->name);
+ macro_free (key, key->table);
+ }
+
+
+
+ /* Building and querying the tree of #included files. */
+
+
+ /* Allocate and initialize a new source file structure. */
+ static struct macro_source_file *
+ new_source_file (struct macro_table *t,
+ const char *filename)
+ {
+ /* Get space for the source file structure itself. */
+ struct macro_source_file *f = macro_alloc (sizeof (*f), t);
+
+ memset (f, 0, sizeof (*f));
+ f->table = t;
+ f->filename = macro_bcache_str (t, filename);
+ f->includes = 0;
+
+ return f;
+ }
+
+
+ /* Free a source file, and all the source files it #included. */
+ static void
+ free_macro_source_file (struct macro_source_file *src)
+ {
+ struct macro_source_file *child, *next_child;
+
+ /* Free this file's children. */
+ for (child = src->includes; child; child = next_child)
+ {
+ next_child = child->next_included;
+ free_macro_source_file (child);
+ }
+
+ macro_bcache_free (src->table, (char *) src->filename);
+ macro_free (src, src->table);
+ }
+
+
+ struct macro_source_file *
+ macro_set_main (struct macro_table *t,
+ const char *filename)
+ {
+ /* You can't change a table's main source file. What would that do
+ to the tree? */
+ gdb_assert (! t->main_source);
+
+ t->main_source = new_source_file (t, filename);
+
+ return t->main_source;
+ }
+
+
+ struct macro_source_file *
+ macro_main (struct macro_table *t)
+ {
+ gdb_assert (t->main_source);
+
+ return t->main_source;
+ }
+
+
+ struct macro_source_file *
+ macro_include (struct macro_source_file *source,
+ int line,
+ const char *included)
+ {
+ struct macro_source_file *new;
+ struct macro_source_file **link;
+
+ /* Find the right position in SOURCE's `includes' list for the new
+ file. Scan until we find the first file we shouldn't follow ---
+ which is therefore the file we should directly precede --- or
+ reach the end of the list. */
+ for (link = &source->includes;
+ *link && line < (*link)->included_at_line;
+ link = &(*link)->next_included)
+ ;
+
+ /* Did we find another file already #included at the same line as
+ the new one? */
+ if (*link && line == (*link)->included_at_line)
+ {
+ /* This means the compiler is emitting bogus debug info. (GCC
+ circa March 2002 did this.) It also means that the splay
+ tree ordering function, macro_tree_compare, will abort,
+ because it can't tell which #inclusion came first. But GDB
+ should tolerate bad debug info. So:
+
+ First, squawk. */
+ static struct complaint bogus_inclusion_line = {
+ "both `%s' and `%s' allegedly #included at %s:%d", 0, 0
+ };
+
+ complain (&bogus_inclusion_line,
+ included, (*link)->filename, source->filename, line);
+
+ /* Now, choose a new, unoccupied line number for this
+ #inclusion, after the alleged #inclusion line. */
+ while (*link && line == (*link)->included_at_line)
+ {
+ /* This line number is taken, so try the next line. */
+ line++;
+ link = &(*link)->next_included;
+ }
+ }
+
+ /* At this point, we know that LINE is an unused line number, and
+ *LINK points to the entry an #inclusion at that line should
+ precede. */
+ new = new_source_file (source->table, included);
+ new->included_by = source;
+ new->included_at_line = line;
+ new->next_included = *link;
+ *link = new;
+
+ return new;
+ }
+
+
+ struct macro_source_file *
+ macro_lookup_inclusion (struct macro_source_file *source, const char *name)
+ {
+ /* Is SOURCE itself named NAME? */
+ if (! strcmp (name, source->filename))
+ return source;
+
+ /* The filename in the source structure is probably a full path, but
+ NAME could be just the final component of the name. */
+ {
+ int name_len = strlen (name);
+ int src_name_len = strlen (source->filename);
+
+ /* We do mean < here, and not <=; if the lengths are the same,
+ then the strcmp above should have triggered, and we need to
+ check for a slash here. */
+ if (name_len < src_name_len
+ && source->filename[src_name_len - name_len - 1] == '/'
+ && ! strcmp (name, source->filename + src_name_len - name_len))
+ return source;
+ }
+
+ /* It's not us. Try all our children, and return the lowest. */
+ {
+ struct macro_source_file *child;
+ struct macro_source_file *best = 0;
+ int best_depth;
+
+ for (child = source->includes; child; child = child->next_included)
+ {
+ struct macro_source_file *result
+ = macro_lookup_inclusion (child, name);
+
+ if (result)
+ {
+ int result_depth = inclusion_depth (result);
+
+ if (! best || result_depth < best_depth)
+ {
+ best = result;
+ best_depth = result_depth;
+ }
+ }
+ }
+
+ return best;
+ }
+ }
+
+
+
+ /* Registering and looking up macro definitions. */
+
+
+ /* Construct a definition for a macro in table T. Cache all strings,
+ and the macro_definition structure itself, in T's bcache. */
+ static struct macro_definition *
+ new_macro_definition (struct macro_table *t,
+ enum macro_kind kind,
+ int argc, const char **argv,
+ const char *replacement)
+ {
+ struct macro_definition *d = macro_alloc (sizeof (*d), t);
+
+ memset (d, 0, sizeof (*d));
+ d->table = t;
+ d->kind = kind;
+ d->replacement = macro_bcache_str (t, replacement);
+
+ if (kind == macro_function_like)
+ {
+ int i;
+ const char **cached_argv;
+ int cached_argv_size = argc * sizeof (*cached_argv);
+
+ /* Bcache all the arguments. */
+ cached_argv = alloca (cached_argv_size);
+ for (i = 0; i < argc; i++)
+ cached_argv[i] = macro_bcache_str (t, argv[i]);
+
+ /* Now bcache the array of argument pointers itself. */
+ d->argv = macro_bcache (t, cached_argv, cached_argv_size);
+ d->argc = argc;
+ }
+
+ /* We don't bcache the entire definition structure because it's got
+ a pointer to the macro table in it; since each compilation unit
+ has its own macro table, you'd only get bcache hits for identical
+ definitions within a compilation unit, which seems unlikely.
+
+ "So, why do macro definitions have pointers to their macro tables
+ at all?" Well, when the splay tree library wants to free a
+ node's value, it calls the value freeing function with nothing
+ but the value itself. It makes the (apparently reasonable)
+ assumption that the value carries enough information to free
+ itself. But not all macro tables have bcaches, so not all macro
+ definitions would be bcached. There's no way to tell whether a
+ given definition is bcached without knowing which table the
+ definition belongs to. ... blah. The thing's only sixteen
+ bytes anyway, and we can still bcache the name, args, and
+ definition, so we just don't bother bcaching the definition
+ structure itself. */
+ return d;
+ }
+
+
+ /* Free a macro definition. */
+ static void
+ macro_tree_delete_value (void *untyped_definition)
+ {
+ struct macro_definition *d = (struct macro_definition *) untyped_definition;
+ struct macro_table *t = d->table;
+
+ if (d->kind == macro_function_like)
+ {
+ int i;
+
+ for (i = 0; i < d->argc; i++)
+ macro_bcache_free (t, (char *) d->argv[i]);
+ macro_bcache_free (t, (char **) d->argv);
+ }
+
+ macro_bcache_free (t, (char *) d->replacement);
+ macro_free (d, t);
+ }
+
+
+ /* Find the splay tree node for the definition of NAME at LINE in
+ SOURCE, or zero if there is none. */
+ static splay_tree_node
+ find_definition (const char *name,
+ struct macro_source_file *file,
+ int line)
+ {
+ struct macro_table *t = file->table;
+ splay_tree_node n;
+
+ /* Construct a macro_key object, just for the query. */
+ struct macro_key query;
+
+ query.name = name;
+ query.start_file = file;
+ query.start_line = line;
+ query.end_file = 0;
+
+ n = splay_tree_lookup (t->definitions, (splay_tree_key) &query);
+ if (! n)
+ {
+ /* It's okay for us to do two queries like this: the real work
+ of the searching is done when we splay, and splaying the tree
+ a second time at the same key is a constant time operation.
+ If this still bugs you, you could always just extend the
+ splay tree library with a predecessor-or-equal operation, and
+ use that. */
+ splay_tree_node pred = splay_tree_predecessor (t->definitions,
+ (splay_tree_key) &query);
+
+ if (pred)
+ {
+ /* Make sure this predecessor actually has the right name.
+ We just want to search within a given name's definitions. */
+ struct macro_key *found = (struct macro_key *) pred->key;
+
+ if (! strcmp (found->name, name))
+ n = pred;
+ }
+ }
+
+ if (n)
+ {
+ struct macro_key *found = (struct macro_key *) n->key;
+
+ /* Okay, so this definition has the right name, and its scope
+ begins before the given source location. But does its scope
+ end after the given source location? */
+ if (compare_locations (file, line, found->end_file, found->end_line) < 0)
+ return n;
+ else
+ return 0;
+ }
+ else
+ return 0;
+ }
+
+
+ /* If NAME already has a definition in scope at LINE in FILE, and
+ return the key. Otherwise, return zero. */
+ static struct macro_key *
+ check_for_redefinition (struct macro_source_file *source, int line,
+ const char *name)
+ {
+ splay_tree_node n = find_definition (name, source, line);
+
+ /* This isn't really right. There's nothing wrong with redefining a
+ macro if the new replacement list is the same as the old one. */
+ if (n)
+ {
+ struct macro_key *found_key = (struct macro_key *) n->key;
+ static struct complaint macro_redefined = {
+ "macro `%s' redefined at %s:%d;"
+ "original definition at %s:%d", 0, 0
+ };
+ complain (¯o_redefined, name,
+ source->filename, line,
+ found_key->start_file->filename,
+ found_key->start_line);
+ return found_key;
+ }
+ else
+ return 0;
+ }
+
+
+ void
+ macro_define_object (struct macro_source_file *source, int line,
+ const char *name, const char *replacement)
+ {
+ struct macro_table *t = source->table;
+ struct macro_key *k;
+ struct macro_definition *d;
+
+ k = check_for_redefinition (source, line, name);
+
+ /* If we're redefining a symbol, and the existing key would be
+ identical to our new key, then the splay_tree_insert function
+ will try to delete the old definition. When the definition is
+ living on an obstack, this isn't a happy thing.
+
+ Since this only happens in the presence of questionable debug
+ info, we just ignore all definitions after the first. The only
+ case I know of where this arises is in GCC's output for
+ predefined macros, and all the definitions are the same in that
+ case. */
+ if (k && ! key_compare (k, name, source, line))
+ return;
+
+ k = new_macro_key (t, name, source, line);
+ d = new_macro_definition (t, macro_object_like, 0, 0, replacement);
+ splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
+ }
+
+
+ void
+ macro_define_function (struct macro_source_file *source, int line,
+ const char *name, int argc, const char **argv,
+ const char *replacement)
+ {
+ struct macro_table *t = source->table;
+ struct macro_key *k;
+ struct macro_definition *d;
+
+ k = check_for_redefinition (source, line, name);
+
+ /* See comments about duplicate keys in macro_define_object. */
+ if (k && ! key_compare (k, name, source, line))
+ return;
+
+ /* We should also check here that all the argument names in ARGV are
+ distinct. */
+
+ k = new_macro_key (t, name, source, line);
+ d = new_macro_definition (t, macro_function_like, argc, argv, replacement);
+ splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
+ }
+
+
+ void
+ macro_undef (struct macro_source_file *source, int line,
+ const char *name)
+ {
+ splay_tree_node n = find_definition (name, source, line);
+
+ if (n)
+ {
+ /* This function is the only place a macro's end-of-scope
+ location gets set to anything other than "end of the
+ compilation unit" (i.e., end_file is zero). So if this macro
+ already has its end-of-scope set, then we're probably seeing
+ a second #undefinition for the same #definition. */
+ struct macro_key *key = (struct macro_key *) n->key;
+
+ if (key->end_file)
+ {
+ static struct complaint double_undef = {
+ "macro '%s' is #undefined twice, at %s:%d and %s:%d",
+ 0, 0
+ };
+ complain (&double_undef, name, source->filename, line,
+ key->end_file->filename, key->end_line);
+ }
+
+ /* Whatever the case, wipe out the old ending point, and
+ make this the ending point. */
+ key->end_file = source;
+ key->end_line = line;
+ }
+ else
+ {
+ /* According to the ISO C standard, an #undef for a symbol that
+ has no macro definition in scope is ignored. So we should
+ ignore it too. */
+ #if 0
+ static struct complaint no_macro_to_undefine = {
+ "no definition for macro `%s' in scope to #undef at %s:%d",
+ 0, 0
+ };
+ complain (&no_macro_to_undefine, name, source->filename, line);
+ #endif
+ }
+ }
+
+
+ struct macro_definition *
+ macro_lookup_definition (struct macro_source_file *source,
+ int line, const char *name)
+ {
+ splay_tree_node n = find_definition (name, source, line);
+
+ if (n)
+ return (struct macro_definition *) n->value;
+ else
+ return 0;
+ }
+
+
+ struct macro_source_file *
+ macro_definition_location (struct macro_source_file *source,
+ int line,
+ const char *name,
+ int *definition_line)
+ {
+ splay_tree_node n = find_definition (name, source, line);
+
+ if (n)
+ {
+ struct macro_key *key = (struct macro_key *) n->key;
+ *definition_line = key->start_line;
+ return key->start_file;
+ }
+ else
+ return 0;
+ }
+
+
+
+ /* Creating and freeing macro tables. */
+
+
+ struct macro_table *
+ new_macro_table (struct obstack *obstack,
+ struct bcache *b)
+ {
+ struct macro_table *t;
+
+ /* First, get storage for the `struct macro_table' itself. */
+ if (obstack)
+ t = obstack_alloc (obstack, sizeof (*t));
+ else
+ t = xmalloc (sizeof (*t));
+
+ memset (t, 0, sizeof (*t));
+ t->obstack = obstack;
+ t->bcache = b;
+ t->main_source = 0;
+ t->definitions = (splay_tree_new_with_allocator
+ (macro_tree_compare,
+ ((splay_tree_delete_key_fn) macro_tree_delete_key),
+ ((splay_tree_delete_value_fn) macro_tree_delete_value),
+ ((splay_tree_allocate_fn) macro_alloc),
+ ((splay_tree_deallocate_fn) macro_free),
+ t));
+
+ return t;
+ }
+
+
+ void
+ free_macro_table (struct macro_table *table)
+ {
+ /* Free the source file tree. */
+ free_macro_source_file (table->main_source);
+
+ /* Free the table of macro definitions. */
+ splay_tree_delete (table->definitions);
+ }
Index: gdb/macrotab.h
===================================================================
RCS file: gdb/macrotab.h
diff -N gdb/macrotab.h
*** gdb/macrotab.h 1 Jan 1970 00:00:00 -0000
--- gdb/macrotab.h 6 May 2002 22:18:41 -0000
***************
*** 0 ****
--- 1,295 ----
+ /* Interface to C preprocessor macro tables for GDB.
+ Copyright 2002 Free Software Foundation, Inc.
+ Contributed by Red Hat, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+ #ifndef MACROTAB_H
+ #define MACROTAB_H
+
+ #include "obstack.h"
+ #include "bcache.h"
+
+ /* How do we represent a source location? I mean, how should we
+ represent them within GDB; the user wants to use all sorts of
+ ambiguous abbreviations, like "break 32" and "break foo.c:32"
+ ("foo.c" may have been #included into several compilation units),
+ but what do we disambiguate those things to?
+
+ - Answer 1: "Filename and line number." (Or column number, if
+ you're picky.) That's not quite good enough. For example, the
+ same source file can be #included into several different
+ compilation units --- which #inclusion do you mean?
+
+ - Answer 2: "Compilation unit, filename, and line number." This is
+ a pretty good answer; GDB's `struct symtab_and_line' basically
+ embodies this representation. But it's still ambiguous; what if a
+ given compilation unit #includes the same file twice --- how can I
+ set a breakpoint on line 12 of the fifth #inclusion of "foo.c"?
+
+ - Answer 3: "Compilation unit, chain of #inclusions, and line
+ number." This is analogous to the way GCC reports errors in
+ #include files:
+
+ $ gcc -c base.c
+ In file included from header2.h:8,
+ from header1.h:3,
+ from base.c:5:
+ header3.h:1: parse error before ')' token
+ $
+
+ GCC tells you exactly what path of #inclusions led you to the
+ problem. It gives you complete information, in a way that the
+ following would not:
+
+ $ gcc -c base.c
+ header3.h:1: parse error before ')' token
+ $
+
+ Converting all of GDB to use this is a big task, and I'm not really
+ suggesting it should be a priority. But this module's whole
+ purpose is to maintain structures describing the macro expansion
+ process, so I think it's appropriate for us to take a little care
+ to do that in a complete fashion.
+
+ In this interface, the first line of a file is numbered 1, not 0.
+ This is the same convention the rest of GDB uses. */
+
+
+ /* A table of all the macro definitions for a given compilation unit. */
+ struct macro_table;
+
+
+ /* A source file that participated in a compilation unit --- either a
+ main file, or an #included file. If a file is #included more than
+ once, the presence of the `included_from' and `included_at_line'
+ members means that we need to make one instance of this structure
+ for each #inclusion. Taken as a group, these structures form a
+ tree mapping the #inclusions that contributed to the compilation
+ unit, with the main source file as its root.
+
+ It's worth noting that libcpp has a simpler way of representing all
+ this, which we should consider switching to. It might even be
+ suitable for ordinary non-macro line number info.
+
+ Suppose you take your main source file, and after each line
+ containing an #include directive you insert the text of the
+ #included file. The result is a big file that pretty much
+ corresponds to the full text the compiler's going to see. There's
+ a one-to-one correspondence between lines in the big file and
+ per-inclusion lines in the source files. (Obviously, #include
+ directives that are #if'd out don't count. And you'll need to
+ append a newline to any file that doesn't end in one, to avoid
+ splicing the last #included line with the next line of the
+ #including file.)
+
+ Libcpp calls line numbers in this big imaginary file "logical line
+ numbers", and has a data structure called a "line map" that can map
+ logical line numbers onto actual source filenames and line numbers,
+ and also tell you the chain of #inclusions responsible for any
+ particular logical line number. Basically, this means you can pass
+ around a single line number and some kind of "compilation unit"
+ object and you get nice, unambiguous source code locations that
+ distinguish between multiple #inclusions of the same file, etc.
+
+ Pretty neat, huh? */
+
+ struct macro_source_file
+ {
+
+ /* The macro table for the compilation unit this source location is
+ a part of. */
+ struct macro_table *table;
+
+ /* A source file --- possibly a header file. */
+ const char *filename;
+
+ /* The location we were #included from, or zero if we are the
+ compilation unit's main source file. */
+ struct macro_source_file *included_by;
+
+ /* If `included_from' is non-zero, the line number in that source
+ file at which we were included. */
+ int included_at_line;
+
+ /* Head of a linked list of the source files #included by this file;
+ our children in the #inclusion tree. This list is sorted by its
+ elements' `included_at_line' values, which are unique. (The
+ macro splay tree's ordering function needs this property.) */
+ struct macro_source_file *includes;
+
+ /* The next file #included by our `included_from' file; our sibling
+ in the #inclusion tree. */
+ struct macro_source_file *next_included;
+ };
+
+
+ /* Create a new, empty macro table. Allocate it in OBSTACK, or use
+ xmalloc if OBSTACK is zero. Use BCACHE to store all macro names,
+ arguments, definitions, and anything else that might be the same
+ amongst compilation units in an executable file; if BCACHE is zero,
+ don't cache these things.
+
+ Note that, if either OBSTACK or BCACHE are non-zero, then you
+ should only ever add information the macro table --- you should
+ never remove things from it. You'll get an error if you try. At
+ the moment, since we only provide obstacks and bcaches for macro
+ tables for symtabs, this restriction makes a nice sanity check.
+ Obstacks and bcaches are pretty much grow-only structures anyway.
+ However, if we find that it's occasionally useful to delete things
+ even from the symtab's tables, and the storage leak isn't a
+ problem, this restriction could be lifted. */
+ struct macro_table *new_macro_table (struct obstack *obstack,
+ struct bcache *bcache);
+
+
+ /* Free TABLE, and any macro definitions, source file structures,
+ etc. it owns. This will raise an internal error if TABLE was
+ allocated on an obstack, or if it uses a bcache. */
+ void free_macro_table (struct macro_table *table);
+
+
+ /* Set FILENAME as the main source file of TABLE. Return a source
+ file structure describing that file; if we record the #definition
+ of macros, or the #inclusion of other files into FILENAME, we'll
+ use that source file structure to indicate the context.
+
+ The "main source file" is the one that was given to the compiler;
+ all other source files that contributed to the compilation unit are
+ #included, directly or indirectly, from this one.
+
+ The macro table makes its own copy of FILENAME; the caller is
+ responsible for freeing FILENAME when it is no longer needed. */
+ struct macro_source_file *macro_set_main (struct macro_table *table,
+ const char *filename);
+
+
+ /* Return the main source file of the macro table TABLE. */
+ struct macro_source_file *macro_main (struct macro_table *table);
+
+
+ /* Record a #inclusion.
+ Record in SOURCE's macro table that, at line number LINE in SOURCE,
+ we #included the file INCLUDED. Return a source file structure we
+ can use for symbols #defined or files #included into that. If we've
+ already created a source file structure for this #inclusion, return
+ the same structure we created last time.
+
+ The first line of the source file has a line number of 1, not 0.
+
+ The macro table makes its own copy of INCLUDED; the caller is
+ responsible for freeing INCLUDED when it is no longer needed. */
+ struct macro_source_file *macro_include (struct macro_source_file *source,
+ int line,
+ const char *included);
+
+
+ /* Find any source file structure for a file named NAME, either
+ included into SOURCE, or SOURCE itself. Return zero if we have
+ none. NAME is only the final portion of the filename, not the full
+ path. e.g., `stdio.h', not `/usr/include/stdio.h'. If NAME
+ appears more than once in the inclusion tree, return the
+ least-nested inclusion --- the one closest to the main source file. */
+ struct macro_source_file *(macro_lookup_inclusion
+ (struct macro_source_file *source,
+ const char *name));
+
+
+ /* Record an object-like #definition (i.e., one with no parameter list).
+ Record in SOURCE's macro table that, at line number LINE in SOURCE,
+ we #defined a preprocessor symbol named NAME, whose replacement
+ string is REPLACEMENT. This function makes copies of NAME and
+ REPLACEMENT; the caller is responsible for freeing them. */
+ void macro_define_object (struct macro_source_file *source, int line,
+ const char *name, const char *replacement);
+
+
+ /* Record an function-like #definition (i.e., one with a parameter list).
+
+ Record in SOURCE's macro table that, at line number LINE in SOURCE,
+ we #defined a preprocessor symbol named NAME, with ARGC arguments
+ whose names are given in ARGV, whose replacement string is REPLACEMENT. If
+ the macro takes a variable number of arguments, then ARGC should be
+ one greater than the number of named arguments, and ARGV[ARGC-1]
+ should be the string "...". This function makes its own copies of
+ NAME, ARGV, and REPLACEMENT; the caller is responsible for freeing
+ them. */
+ void macro_define_function (struct macro_source_file *source, int line,
+ const char *name, int argc, const char **argv,
+ const char *replacement);
+
+
+ /* Record an #undefinition.
+ Record in SOURCE's macro table that, at line number LINE in SOURCE,
+ we removed the definition for the preprocessor symbol named NAME. */
+ void macro_undef (struct macro_source_file *source, int line,
+ const char *name);
+
+
+ /* Different kinds of macro definitions. */
+ enum macro_kind
+ {
+ macro_object_like,
+ macro_function_like
+ };
+
+
+ /* A preprocessor symbol definition. */
+ struct macro_definition
+ {
+ /* The table this definition lives in. */
+ struct macro_table *table;
+
+ /* What kind of macro it is. */
+ enum macro_kind kind;
+
+ /* If `kind' is `macro_function_like', the number of arguments it
+ takes, and their names. The names, and the array of pointers to
+ them, are in the table's bcache, if it has one. */
+ int argc;
+ const char * const *argv;
+
+ /* The replacement string (body) of the macro. This is in the
+ table's bcache, if it has one. */
+ const char *replacement;
+ };
+
+
+ /* Return a pointer to the macro definition for NAME in scope at line
+ number LINE of SOURCE. If LINE is -1, return the definition in
+ effect at the end of the file. The macro table owns the structure;
+ the caller need not free it. Return zero if NAME is not #defined
+ at that point. */
+ struct macro_definition *(macro_lookup_definition
+ (struct macro_source_file *source,
+ int line, const char *name));
+
+
+ /* Return the source location of the definition for NAME in scope at
+ line number LINE of SOURCE. Set *DEFINITION_LINE to the line
+ number of the definition, and return a source file structure for
+ the file. Return zero if NAME has no definition in scope at that
+ point, and leave *DEFINITION_LINE unchanged. */
+ struct macro_source_file *(macro_definition_location
+ (struct macro_source_file *source,
+ int line,
+ const char *name,
+ int *definition_line));
+
+
+ #endif /* MACROTAB_H */
Index: gdb/Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.180
diff -c -r1.180 Makefile.in
*** gdb/Makefile.in 4 May 2002 15:52:37 -0000 1.180
--- gdb/Makefile.in 6 May 2002 22:18:39 -0000
***************
*** 539,544 ****
--- 539,545 ----
m2-exp.y m2-lang.c m2-typeprint.c m2-valprint.c main.c maint.c \
memattr.c mem-break.c minsyms.c mipsread.c nlmread.c objfiles.c \
p-exp.y p-lang.c p-typeprint.c p-valprint.c parse.c \
+ macrotab.c macroexp.c \
printcmd.c remote.c remote-nrom.c scm-exp.c scm-lang.c \
scm-valprint.c source.c stabsread.c stack.c symfile.c \
symmisc.c symtab.c linespec.c target.c thread.c top.c tracepoint.c \
***************
*** 571,576 ****
--- 572,578 ----
remote-sim_h = $(INCLUDE_DIR)/remote-sim.h
demangle_h = $(INCLUDE_DIR)/demangle.h
obstack_h = $(INCLUDE_DIR)/obstack.h
+ splay_tree_h = $(INCLUDE_DIR)/splay-tree.h
readline_headers = \
$(READLINE_SRC)/chardefs.h \
***************
*** 631,636 ****
--- 633,640 ----
inferior_h = inferior.h $(breakpoint_h)
language_h = language.h
linespec_h = linespec.h
+ macroexp_h = macroexp.h
+ macrotab_h = macrotab.h $(obstack_h) $(bcache_h)
memattr_h = memattr.h
monitor_h = monitor.h
objfiles_h = objfiles.h
***************
*** 669,674 ****
--- 673,679 ----
gdb-stabs.h $(inferior_h) language.h minimon.h monitor.h \
objfiles.h parser-defs.h serial.h solib.h \
symfile.h stabsread.h target.h terminal.h typeprint.h xcoffsolib.h \
+ macrotab.h macroexp.h \
c-lang.h ch-lang.h f-lang.h \
jv-lang.h \
m2-lang.h p-lang.h \
***************
*** 711,716 ****
--- 716,722 ----
source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \
symtab.o symfile.o symmisc.o linespec.o infcmd.o infrun.o \
expprint.o environ.o stack.o thread.o \
+ macrotab.o macroexp.o \
event-loop.o event-top.o inf-loop.o completer.o \
gdbarch.o arch-utils.o gdbtypes.o copying.o $(DEPFILES) \
memattr.o mem-break.o target.o parse.o language.o $(YYOBJ) buildsym.o \
***************
*** 2111,2116 ****
--- 2117,2127 ----
linespec.o: linespec.c $(linespec_h) $(defs_h) $(frame_h) $(value_h) \
$(objfiles_h) $(symfile_h) $(completer_h) $(symtab_h) \
$(demangle_h) $(command_h) $(cp_abi_h)
+
+ macroexp.o: macroexp.c $(defs_h) $(macrotab_h)
+
+ macrotab.o: macrotab.c $(defs_h) $(obstack_h) $(objfiles_h) $(symtab_h) \
+ $(macrotab_h) $(splay_tree_h) gdb_assert.h $(bcache_h)
target.o: target.c $(bfd_h) $(defs_h) $(gdbcmd_h) $(inferior_h) \
$(objfiles_h) $(symfile_h) $(target_h) $(gdb_string_h) $(regcache_h)