X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmacrocmd.c;h=7661336230b76b797de73d1aa7390e563be480ec;hb=5fe966540d6b748f825774868463003700f0c878;hp=c9ab440f794b4514abfd222cc6049c9101ae0455;hpb=2fae03e85bab97b883120cf0f5dbaacad2dd141f;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/macrocmd.c b/gdb/macrocmd.c
index c9ab440f79..7661336230 100644
--- a/gdb/macrocmd.c
+++ b/gdb/macrocmd.c
@@ -1,5 +1,5 @@
 /* C preprocessor macro expansion commands for GDB.
-   Copyright (C) 2002, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2002-2016 Free Software Foundation, Inc.
    Contributed by Red Hat, Inc.
 
    This file is part of GDB.
@@ -22,9 +22,10 @@
 #include "macrotab.h"
 #include "macroexp.h"
 #include "macroscope.h"
+#include "cli/cli-utils.h"
 #include "command.h"
 #include "gdbcmd.h"
-#include "gdb_string.h"
+#include "linespec.h"
 
 
 /* The `macro' prefix command.  */
@@ -36,7 +37,7 @@ macro_command (char *arg, int from_tty)
 {
   printf_unfiltered
     ("\"macro\" must be followed by the name of a macro command.\n");
-  help_list (macrolist, "macro ", -1, gdb_stdout);
+  help_list (macrolist, "macro ", all_commands, gdb_stdout);
 }
 
 
@@ -44,12 +45,20 @@ macro_command (char *arg, int from_tty)
 /* Macro expansion commands.  */
 
 
+/* Prints an informational message regarding the lack of macro information.  */
+static void
+macro_inform_no_debuginfo (void)
+{
+  puts_filtered ("GDB has no preprocessor macro information for that code.\n");
+}
+
 static void
 macro_expand_command (char *exp, int from_tty)
 {
   struct macro_scope *ms = NULL;
   char *expanded = NULL;
   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
+
   make_cleanup (free_current_contents, &expanded);
 
   /* You know, when the user doesn't specify any expression, it would be
@@ -71,9 +80,7 @@ macro_expand_command (char *exp, int from_tty)
       fputs_filtered ("\n", gdb_stdout);
     }
   else
-    fputs_filtered ("GDB has no preprocessor macro information for "
-                    "that code.\n",
-                    gdb_stdout);
+    macro_inform_no_debuginfo ();
 
   do_cleanups (cleanup_chain);
   return;
@@ -107,86 +114,193 @@ macro_expand_once_command (char *exp, int from_tty)
       fputs_filtered ("\n", gdb_stdout);
     }
   else
-    fputs_filtered ("GDB has no preprocessor macro information for "
-                    "that code.\n",
-                    gdb_stdout);
+    macro_inform_no_debuginfo ();
 
   do_cleanups (cleanup_chain);
   return;
 }
 
+/*  Outputs the include path of a macro starting at FILE and LINE to STREAM.
 
+    Care should be taken that this function does not cause any lookups into
+    the splay tree so that it can be safely used while iterating.  */
 static void
 show_pp_source_pos (struct ui_file *stream,
                     struct macro_source_file *file,
                     int line)
 {
-  fprintf_filtered (stream, "%s:%d\n", file->filename, line);
+  char *fullname;
+
+  fullname = macro_source_fullname (file);
+  fprintf_filtered (stream, "%s:%d\n", fullname, line);
+  xfree (fullname);
 
   while (file->included_by)
     {
-      fprintf_filtered (gdb_stdout, "  included at %s:%d\n",
-                        file->included_by->filename,
+      fullname = macro_source_fullname (file->included_by);
+      fprintf_filtered (gdb_stdout, "  included at %s:%d\n", fullname,
                         file->included_at_line);
+      xfree (fullname);
       file = file->included_by;
     }
 }
 
+/* Outputs a macro for human consumption, detailing the include path
+   and macro definition.  NAME is the name of the macro.
+   D the definition.  FILE the start of the include path, and LINE the
+   line number in FILE.
 
+   Care should be taken that this function does not cause any lookups into
+   the splay tree so that it can be safely used while iterating.  */
 static void
-info_macro_command (char *name, int from_tty)
+print_macro_definition (const char *name,
+			const struct macro_definition *d,
+			struct macro_source_file *file,
+			int line)
+{
+  fprintf_filtered (gdb_stdout, "Defined at ");
+  show_pp_source_pos (gdb_stdout, file, line);
+
+  if (line != 0)
+    fprintf_filtered (gdb_stdout, "#define %s", name);
+  else
+    fprintf_filtered (gdb_stdout, "-D%s", name);
+
+  if (d->kind == macro_function_like)
+    {
+      int i;
+
+      fputs_filtered ("(", gdb_stdout);
+      for (i = 0; i < d->argc; i++)
+	{
+	  fputs_filtered (d->argv[i], gdb_stdout);
+	  if (i + 1 < d->argc)
+	    fputs_filtered (", ", gdb_stdout);
+	}
+      fputs_filtered (")", gdb_stdout);
+    }
+
+  if (line != 0)
+    fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
+  else
+    fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
+}
+
+/* A callback function for usage with macro_for_each and friends.
+   If USER_DATA is null all macros will be printed.
+   Otherwise USER_DATA is considered to be a string, printing
+   only macros who's NAME matches USER_DATA.  Other arguments are
+   routed to print_macro_definition.  */
+static void
+print_macro_callback (const char *name, const struct macro_definition *macro,
+		   struct macro_source_file *source, int line,
+		   void *user_data)
+{
+  if (! user_data || strcmp ((const char *) user_data, name) == 0)
+    print_macro_definition (name, macro, source, line);
+}
+
+/* The implementation of the `info macro' command.  */
+static void
+info_macro_command (char *args, int from_tty)
 {
   struct macro_scope *ms = NULL;
-  struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
-  struct macro_definition *d;
-  
+  struct cleanup *cleanup_chain;
+  char *name;
+  int show_all_macros_named = 0;
+  char *arg_start = args;
+  int processing_args = 1;
+
+  while (processing_args
+	 && arg_start && *arg_start == '-' && *arg_start != '\0')
+    {
+      char *p = skip_to_space (arg_start);
+
+      if (strncmp (arg_start, "-a", p - arg_start) == 0
+	  || strncmp (arg_start, "-all", p - arg_start) == 0)
+	show_all_macros_named = 1;
+      else if (strncmp (arg_start, "--", p - arg_start) == 0)
+          /* Our macro support seems rather C specific but this would
+             seem necessary for languages allowing - in macro names.
+	     e.g. Scheme's (defmacro ->foo () "bar\n")  */
+	processing_args = 0;
+      else
+	{
+	  /* Relies on modified 'args' not making it in to history */
+	  *p = '\0';
+	  error (_("Unrecognized option '%s' to info macro command.  "
+		   "Try \"help info macro\"."), arg_start);
+	}
+
+        arg_start = skip_spaces (p);
+    }
+
+  name = arg_start;
+
   if (! name || ! *name)
     error (_("You must follow the `info macro' command with the name"
-           " of the macro\n"
-           "whose definition you want to see."));
+	     " of the macro\n"
+	     "whose definition you want to see."));
 
   ms = default_macro_scope ();
-  if (! ms)
-    error (_("GDB has no preprocessor macro information for that code."));
+  cleanup_chain = make_cleanup (free_current_contents, &ms);
 
-  d = macro_lookup_definition (ms->file, ms->line, name);
-  if (d)
+  if (! ms)
+    macro_inform_no_debuginfo ();
+  else if (show_all_macros_named)
+    macro_for_each (ms->file->table, print_macro_callback, name);
+  else
     {
-      int line;
-      struct macro_source_file *file
-        = macro_definition_location (ms->file, ms->line, name, &line);
-
-      fprintf_filtered (gdb_stdout, "Defined at ");
-      show_pp_source_pos (gdb_stdout, file, line);
-      fprintf_filtered (gdb_stdout, "#define %s", name);
-      if (d->kind == macro_function_like)
+      struct macro_definition *d;
+
+      d = macro_lookup_definition (ms->file, ms->line, name);
+      if (d)
+	{
+	  int line;
+	  struct macro_source_file *file
+	    = macro_definition_location (ms->file, ms->line, name, &line);
+
+	  print_macro_definition (name, d, file, line);
+	}
+      else
         {
-          int i;
-
-          fputs_filtered ("(", gdb_stdout);
-          for (i = 0; i < d->argc; i++)
-            {
-              fputs_filtered (d->argv[i], gdb_stdout);
-              if (i + 1 < d->argc)
-                fputs_filtered (", ", gdb_stdout);
-            }
-          fputs_filtered (")", gdb_stdout);
-        }
-      fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
+          fprintf_filtered (gdb_stdout,
+                            "The symbol `%s' has no definition as a C/C++"
+                            " preprocessor macro\n"
+                            "at ", name);
+          show_pp_source_pos (gdb_stdout, ms->file, ms->line);
+	}
     }
+
+  do_cleanups (cleanup_chain);
+}
+
+/* Implementation of the "info macros" command. */
+static void
+info_macros_command (char *args, int from_tty)
+{
+  struct macro_scope *ms = NULL;
+  struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
+
+  if (args == NULL)
+    ms = default_macro_scope ();
   else
     {
-      fprintf_filtered (gdb_stdout,
-                        "The symbol `%s' has no definition as a C/C++"
-                        " preprocessor macro\n"
-                        "at ", name);
-      show_pp_source_pos (gdb_stdout, ms->file, ms->line);
+      struct symtabs_and_lines sals =
+	decode_line_with_current_source (args, 0);
+
+      if (sals.nelts)
+        ms = sal_macro_scope (sals.sals[0]);
     }
 
+  if (! ms || ! ms->file || ! ms->file->table)
+    macro_inform_no_debuginfo ();
+  else
+    macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL);
+
   do_cleanups (cleanup_chain);
 }
 
-
 
 /* User-defined macros.  */
 
@@ -211,7 +325,7 @@ extract_identifier (char **expp, int is_parameter)
   char *p = *expp;
   unsigned int len;
 
-  if (is_parameter && !strncmp (p, "...", 3))
+  if (is_parameter && startswith (p, "..."))
     {
       /* Ok.  */
     }
@@ -225,7 +339,7 @@ extract_identifier (char **expp, int is_parameter)
 	;
     }
 
-  if (is_parameter && !strncmp (p, "...", 3))      
+  if (is_parameter && startswith (p, "..."))      
     p += 3;
 
   len = p - *expp;
@@ -243,6 +357,7 @@ 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);
@@ -272,7 +387,7 @@ macro_define_command (char *exp, int from_tty)
     {
       /* Function-like macro.  */
       int alloced = 5;
-      char **argv = (char **) xmalloc (alloced * sizeof (char *));
+      char **argv = XNEWVEC (char *, alloced);
 
       new_macro.kind = macro_function_like;
       new_macro.argc = 0;
@@ -290,7 +405,7 @@ macro_define_command (char *exp, int from_tty)
 	    {
 	      alloced *= 2;
 	      argv = (char **) xrealloc (argv, alloced * sizeof (char *));
-	      /* Must update new_macro as well... */
+	      /* Must update new_macro as well...  */
 	      new_macro.argv = (const char * const *) argv;
 	    }
 	  argv[new_macro.argc] = extract_identifier (&exp, 1);
@@ -315,13 +430,17 @@ macro_define_command (char *exp, int from_tty)
 	}
       /* Skip the closing paren.  */
       ++exp;
+      skip_ws (&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);
+    {
+      skip_ws (&exp);
+      macro_define_object (macro_main (macro_user_macros), -1, name, exp);
+    }
 
   do_cleanups (cleanup_chain);
 }
@@ -345,31 +464,31 @@ macro_undef_command (char *exp, int from_tty)
 
 
 static void
-print_one_macro (const char *name, const struct macro_definition *macro)
+print_one_macro (const char *name, const struct macro_definition *macro,
+		 struct macro_source_file *source, int line,
+		 void *ignore)
 {
   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);
+  fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
 }
 
 
 static void
 macro_list_command (char *exp, int from_tty)
 {
-  macro_for_each (macro_user_macros, print_one_macro);
+  macro_for_each (macro_user_macros, print_one_macro, NULL);
 }
 
-
 
 /* Initializing the `macrocmd' module.  */
 
@@ -378,8 +497,6 @@ extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
 void
 _initialize_macrocmd (void)
 {
-  struct cmd_list_element *c;
-
   /* We introduce a new command prefix, `macro', under which we'll put
      the various commands for working with preprocessor macros.  */
   add_prefix_cmd ("macro", class_info, macro_command,
@@ -405,9 +522,18 @@ expression work together to yield a pre-processed expression."),
 	   &macrolist);
   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
 
-  add_cmd ("macro", no_class, info_macro_command,
-	   _("Show the definition of MACRO, and its source location."),
-	   &infolist);
+  add_info ("macro", info_macro_command,
+	    _("Show the definition of MACRO, and it's source location.\n\
+Usage: info macro [-a|-all] [--] MACRO\n\
+Options: \n\
+  -a, --all    Output all definitions of MACRO in the current compilation\
+ unit.\n\
+  --           Specify the end of arguments and the beginning of the MACRO."));
+
+  add_info ("macros", info_macros_command,
+	    _("Show the definitions of all macros at LINESPEC, or the current \
+source location.\n\
+Usage: info macros [LINESPEC]"));
 
   add_cmd ("define", no_class, macro_define_command, _("\
 Define a new C/C++ preprocessor macro.\n\