-2002-05-08 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.
-
2002-05-06 Jim Blandy <jimb@redhat.com>
Separate the job of reading the line number info statement program
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 \
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 \
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
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 \
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 \
$(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)
+++ /dev/null
-/* 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"
-
-
-\f
-/* 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;
-}
-
-
-\f
-/* 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;
-}
-
-
-\f
-/* 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");
-}
-
-
-\f
-/* 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;
- }
-}
+++ /dev/null
-/* 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 */
+++ /dev/null
-/* 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"
-
-\f
-/* 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;
-};
-
-
-\f
-/* 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);
-}
-
-
-\f
-/* 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);
-}
-
-
-\f
-/* 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;
- }
-}
-
-
-\f
-/* 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;
-}
-
-
-\f
-/* 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);
-}
+++ /dev/null
-/* 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 */
projects / thirdparty / binutils-gdb.git / commitdiff
