X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmacrocmd.c;h=8213c0d703b8e536a0e9a53bc30debb92c415bba;hb=886a217cf4ad31024cf799bf2803c39c07ad1d15;hp=b9f6a9a7ea3e3522ee09dc5e111f1885f1d84011;hpb=01f0fe5e0450edf168c1f612feb93cf588e4e7ea;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/macrocmd.c b/gdb/macrocmd.c index b9f6a9a7ea..8213c0d703 100644 --- a/gdb/macrocmd.c +++ b/gdb/macrocmd.c @@ -1,12 +1,12 @@ /* C preprocessor macro expansion commands for GDB. - Copyright (C) 2002 Free Software Foundation, Inc. + Copyright (C) 2002, 2007, 2008 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 + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -15,9 +15,7 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" @@ -26,6 +24,7 @@ #include "macroscope.h" #include "command.h" #include "gdbcmd.h" +#include "gdb_string.h" /* The `macro' prefix command. */ @@ -191,31 +190,164 @@ info_macro_command (char *name, int from_tty) /* User-defined macros. */ -/* A table of user-defined macros. Unlike the macro tables used for - symtabs, this one uses xmalloc for all its allocation, not an - obstack, and it doesn't bcache anything; it just xmallocs things. So - it's perfectly possible to remove things from this, or redefine - things. */ -static struct macro_table *user_macros; +static void +skip_ws (char **expp) +{ + while (macro_is_whitespace (**expp)) + ++*expp; +} + +static char * +extract_identifier (char **expp) +{ + char *result; + char *p = *expp; + unsigned int len; + if (! *p || ! macro_is_identifier_nondigit (*p)) + return NULL; + for (++p; + *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p)); + ++p) + ; + len = p - *expp; + result = (char *) xmalloc (len + 1); + memcpy (result, *expp, len); + result[len] = '\0'; + *expp += len; + return result; +} + +/* Helper function to clean up a temporarily-constructed macro object. + This assumes that the contents were all allocated with xmalloc. */ +static void +free_macro_definition_ptr (void *ptr) +{ + int i; + struct macro_definition *loc = (struct macro_definition *) ptr; + for (i = 0; i < loc->argc; ++i) + xfree ((char *) loc->argv[i]); + xfree ((char *) loc->argv); + /* Note that the 'replacement' field is not allocated. */ +} static void macro_define_command (char *exp, int from_tty) { - error (_("Command not implemented yet.")); + struct macro_definition new_macro; + char *name = NULL; + struct cleanup *cleanup_chain; + + if (!exp) + error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]")); + + cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro); + make_cleanup (free_current_contents, &name); + + memset (&new_macro, 0, sizeof (struct macro_definition)); + + skip_ws (&exp); + name = extract_identifier (&exp); + if (! name) + error (_("Invalid macro name.")); + if (*exp == '(') + { + /* Function-like macro. */ + int alloced = 5; + char **argv = (char **) xmalloc (alloced * sizeof (char *)); + + new_macro.kind = macro_function_like; + new_macro.argc = 0; + new_macro.argv = (const char * const *) argv; + + /* Skip the '(' and whitespace. */ + ++exp; + skip_ws (&exp); + + while (*exp != ')') + { + int i; + + if (new_macro.argc == alloced) + { + alloced *= 2; + argv = (char **) xrealloc (argv, alloced * sizeof (char *)); + /* Must update new_macro as well... */ + new_macro.argv = (const char * const *) argv; + } + argv[new_macro.argc] = extract_identifier (&exp); + if (! argv[new_macro.argc]) + error (_("Macro is missing an argument.")); + ++new_macro.argc; + + for (i = new_macro.argc - 2; i >= 0; --i) + { + if (! strcmp (argv[i], argv[new_macro.argc - 1])) + error (_("Two macro arguments with identical names.")); + } + + skip_ws (&exp); + if (*exp == ',') + { + ++exp; + skip_ws (&exp); + } + else if (*exp != ')') + error (_("',' or ')' expected at end of macro arguments.")); + } + /* Skip the closing paren. */ + ++exp; + + macro_define_function (macro_main (macro_user_macros), -1, name, + new_macro.argc, (const char **) new_macro.argv, + exp); + } + else + macro_define_object (macro_main (macro_user_macros), -1, name, exp); + + do_cleanups (cleanup_chain); } static void macro_undef_command (char *exp, int from_tty) { - error (_("Command not implemented yet.")); + char *name; + + if (!exp) + error (_("usage: macro undef NAME")); + + skip_ws (&exp); + name = extract_identifier (&exp); + if (! name) + error (_("Invalid macro name.")); + macro_undef (macro_main (macro_user_macros), -1, name); + xfree (name); +} + + +static void +print_one_macro (const char *name, const struct macro_definition *macro) +{ + fprintf_filtered (gdb_stdout, "macro define %s", name); + if (macro->kind == macro_function_like) + { + int i; + fprintf_filtered (gdb_stdout, "("); + for (i = 0; i < macro->argc; ++i) + fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "", + macro->argv[i]); + fprintf_filtered (gdb_stdout, ")"); + } + /* Note that we don't need a leading space here -- "macro define" + provided it. */ + fprintf_filtered (gdb_stdout, "%s\n", macro->replacement); } static void macro_list_command (char *exp, int from_tty) { - error (_("Command not implemented yet.")); + macro_for_each (macro_user_macros, print_one_macro); } @@ -275,6 +407,4 @@ Remove the definition of the C/C++ preprocessor macro with the given name."), add_cmd ("list", no_class, macro_list_command, _("List all the macros defined using the `macro define' command."), ¯olist); - - user_macros = new_macro_table (0, 0); }