gdb/macrocmd.c

   1 /* C preprocessor macro expansion commands for GDB.
   2    Copyright (C) 2002, 2007, 2008, 2009 Free Software Foundation, Inc.
   3    Contributed by Red Hat, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "defs.h"
  22 #include "macrotab.h"
  23 #include "macroexp.h"
  24 #include "macroscope.h"
  25 #include "command.h"
  26 #include "gdbcmd.h"
  27 #include "gdb_string.h"
  28
  29 \f
  30 /* The `macro' prefix command.  */
  31
  32 static struct cmd_list_element *macrolist;
  33
  34 static void
  35 macro_command (char *arg, int from_tty)
  36 {
  37   printf_unfiltered
  38     ("\"macro\" must be followed by the name of a macro command.\n");
  39   help_list (macrolist, "macro ", -1, gdb_stdout);
  40 }
  41
  42
  43 \f
  44 /* Macro expansion commands.  */
  45
  46
  47 static void
  48 macro_expand_command (char *exp, int from_tty)
  49 {
  50   struct macro_scope *ms = NULL;
  51   char *expanded = NULL;
  52   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
  53   make_cleanup (free_current_contents, &expanded);
  54
  55   /* You know, when the user doesn't specify any expression, it would be
  56      really cool if this defaulted to the last expression evaluated.
  57      Then it would be easy to ask, "Hey, what did I just evaluate?"  But
  58      at the moment, the `print' commands don't save the last expression
  59      evaluated, just its value.  */
  60   if (! exp || ! *exp)
  61     error (_("You must follow the `macro expand' command with the"
  62            " expression you\n"
  63            "want to expand."));
  64
  65   ms = default_macro_scope ();
  66   if (ms)
  67     {
  68       expanded = macro_expand (exp, standard_macro_lookup, ms);
  69       fputs_filtered ("expands to: ", gdb_stdout);
  70       fputs_filtered (expanded, gdb_stdout);
  71       fputs_filtered ("\n", gdb_stdout);
  72     }
  73   else
  74     fputs_filtered ("GDB has no preprocessor macro information for "
  75                     "that code.\n",
  76                     gdb_stdout);
  77
  78   do_cleanups (cleanup_chain);
  79   return;
  80 }
  81
  82
  83 static void
  84 macro_expand_once_command (char *exp, int from_tty)
  85 {
  86   struct macro_scope *ms = NULL;
  87   char *expanded = NULL;
  88   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
  89   make_cleanup (free_current_contents, &expanded);
  90
  91   /* You know, when the user doesn't specify any expression, it would be
  92      really cool if this defaulted to the last expression evaluated.
  93      And it should set the once-expanded text as the new `last
  94      expression'.  That way, you could just hit return over and over and
  95      see the expression expanded one level at a time.  */
  96   if (! exp || ! *exp)
  97     error (_("You must follow the `macro expand-once' command with"
  98            " the expression\n"
  99            "you want to expand."));
 100
 101   ms = default_macro_scope ();
 102   if (ms)
 103     {
 104       expanded = macro_expand_once (exp, standard_macro_lookup, ms);
 105       fputs_filtered ("expands to: ", gdb_stdout);
 106       fputs_filtered (expanded, gdb_stdout);
 107       fputs_filtered ("\n", gdb_stdout);
 108     }
 109   else
 110     fputs_filtered ("GDB has no preprocessor macro information for "
 111                     "that code.\n",
 112                     gdb_stdout);
 113
 114   do_cleanups (cleanup_chain);
 115   return;
 116 }
 117
 118
 119 static void
 120 show_pp_source_pos (struct ui_file *stream,
 121                     struct macro_source_file *file,
 122                     int line)
 123 {
 124   fprintf_filtered (stream, "%s:%d\n", file->filename, line);
 125
 126   while (file->included_by)
 127     {
 128       fprintf_filtered (gdb_stdout, "  included at %s:%d\n",
 129                         file->included_by->filename,
 130                         file->included_at_line);
 131       file = file->included_by;
 132     }
 133 }
 134
 135
 136 static void
 137 info_macro_command (char *name, int from_tty)
 138 {
 139   struct macro_scope *ms = NULL;
 140   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
 141   struct macro_definition *d;
 142
 143   if (! name || ! *name)
 144     error (_("You must follow the `info macro' command with the name"
 145            " of the macro\n"
 146            "whose definition you want to see."));
 147
 148   ms = default_macro_scope ();
 149   if (! ms)
 150     error (_("GDB has no preprocessor macro information for that code."));
 151
 152   d = macro_lookup_definition (ms->file, ms->line, name);
 153   if (d)
 154     {
 155       int line;
 156       struct macro_source_file *file
 157         = macro_definition_location (ms->file, ms->line, name, &line);
 158
 159       fprintf_filtered (gdb_stdout, "Defined at ");
 160       show_pp_source_pos (gdb_stdout, file, line);
 161       if (line != 0)
 162         fprintf_filtered (gdb_stdout, "#define %s", name);
 163       else
 164         fprintf_filtered (gdb_stdout, "-D%s", name);
 165       if (d->kind == macro_function_like)
 166         {
 167           int i;
 168
 169           fputs_filtered ("(", gdb_stdout);
 170           for (i = 0; i < d->argc; i++)
 171             {
 172               fputs_filtered (d->argv[i], gdb_stdout);
 173               if (i + 1 < d->argc)
 174                 fputs_filtered (", ", gdb_stdout);
 175             }
 176           fputs_filtered (")", gdb_stdout);
 177         }
 178       if (line != 0)
 179         fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
 180       else
 181         fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
 182     }
 183   else
 184     {
 185       fprintf_filtered (gdb_stdout,
 186                         "The symbol `%s' has no definition as a C/C++"
 187                         " preprocessor macro\n"
 188                         "at ", name);
 189       show_pp_source_pos (gdb_stdout, ms->file, ms->line);
 190     }
 191
 192   do_cleanups (cleanup_chain);
 193 }
 194
 195
 196 \f
 197 /* User-defined macros.  */
 198
 199 static void
 200 skip_ws (char **expp)
 201 {
 202   while (macro_is_whitespace (**expp))
 203     ++*expp;
 204 }
 205
 206 /* Try to find the bounds of an identifier.  If an identifier is
 207    found, returns a newly allocated string; otherwise returns NULL.
 208    EXPP is a pointer to an input string; it is updated to point to the
 209    text following the identifier.  If IS_PARAMETER is true, this
 210    function will also allow "..." forms as used in varargs macro
 211    parameters.  */
 212
 213 static char *
 214 extract_identifier (char **expp, int is_parameter)
 215 {
 216   char *result;
 217   char *p = *expp;
 218   unsigned int len;
 219
 220   if (is_parameter && !strncmp (p, "...", 3))
 221     {
 222       /* Ok.  */
 223     }
 224   else
 225     {
 226       if (! *p || ! macro_is_identifier_nondigit (*p))
 227         return NULL;
 228       for (++p;
 229            *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
 230            ++p)
 231         ;
 232     }
 233
 234   if (is_parameter && !strncmp (p, "...", 3))
 235     p += 3;
 236
 237   len = p - *expp;
 238   result = (char *) xmalloc (len + 1);
 239   memcpy (result, *expp, len);
 240   result[len] = '\0';
 241   *expp += len;
 242   return result;
 243 }
 244
 245 /* Helper function to clean up a temporarily-constructed macro object.
 246    This assumes that the contents were all allocated with xmalloc.  */
 247 static void
 248 free_macro_definition_ptr (void *ptr)
 249 {
 250   int i;
 251   struct macro_definition *loc = (struct macro_definition *) ptr;
 252   for (i = 0; i < loc->argc; ++i)
 253     xfree ((char *) loc->argv[i]);
 254   xfree ((char *) loc->argv);
 255   /* Note that the 'replacement' field is not allocated.  */
 256 }
 257
 258 static void
 259 macro_define_command (char *exp, int from_tty)
 260 {
 261   struct macro_definition new_macro;
 262   char *name = NULL;
 263   struct cleanup *cleanup_chain;
 264
 265   if (!exp)
 266     error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
 267
 268   cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
 269   make_cleanup (free_current_contents, &name);
 270
 271   memset (&new_macro, 0, sizeof (struct macro_definition));
 272
 273   skip_ws (&exp);
 274   name = extract_identifier (&exp, 0);
 275   if (! name)
 276     error (_("Invalid macro name."));
 277   if (*exp == '(')
 278     {
 279       /* Function-like macro.  */
 280       int alloced = 5;
 281       char **argv = (char **) xmalloc (alloced * sizeof (char *));
 282
 283       new_macro.kind = macro_function_like;
 284       new_macro.argc = 0;
 285       new_macro.argv = (const char * const *) argv;
 286
 287       /* Skip the '(' and whitespace.  */
 288       ++exp;
 289       skip_ws (&exp);
 290
 291       while (*exp != ')')
 292         {
 293           int i;
 294
 295           if (new_macro.argc == alloced)
 296             {
 297               alloced *= 2;
 298               argv = (char **) xrealloc (argv, alloced * sizeof (char *));
 299               /* Must update new_macro as well... */
 300               new_macro.argv = (const char * const *) argv;
 301             }
 302           argv[new_macro.argc] = extract_identifier (&exp, 1);
 303           if (! argv[new_macro.argc])
 304             error (_("Macro is missing an argument."));
 305           ++new_macro.argc;
 306
 307           for (i = new_macro.argc - 2; i >= 0; --i)
 308             {
 309               if (! strcmp (argv[i], argv[new_macro.argc - 1]))
 310                 error (_("Two macro arguments with identical names."));
 311             }
 312
 313           skip_ws (&exp);
 314           if (*exp == ',')
 315             {
 316               ++exp;
 317               skip_ws (&exp);
 318             }
 319           else if (*exp != ')')
 320             error (_("',' or ')' expected at end of macro arguments."));
 321         }
 322       /* Skip the closing paren.  */
 323       ++exp;
 324       skip_ws (&exp);
 325
 326       macro_define_function (macro_main (macro_user_macros), -1, name,
 327                              new_macro.argc, (const char **) new_macro.argv,
 328                              exp);
 329     }
 330   else
 331     {
 332       skip_ws (&exp);
 333       macro_define_object (macro_main (macro_user_macros), -1, name, exp);
 334     }
 335
 336   do_cleanups (cleanup_chain);
 337 }
 338
 339
 340 static void
 341 macro_undef_command (char *exp, int from_tty)
 342 {
 343   char *name;
 344
 345   if (!exp)
 346     error (_("usage: macro undef NAME"));
 347
 348   skip_ws (&exp);
 349   name = extract_identifier (&exp, 0);
 350   if (! name)
 351     error (_("Invalid macro name."));
 352   macro_undef (macro_main (macro_user_macros), -1, name);
 353   xfree (name);
 354 }
 355
 356
 357 static void
 358 print_one_macro (const char *name, const struct macro_definition *macro,
 359                  void *ignore)
 360 {
 361   fprintf_filtered (gdb_stdout, "macro define %s", name);
 362   if (macro->kind == macro_function_like)
 363     {
 364       int i;
 365       fprintf_filtered (gdb_stdout, "(");
 366       for (i = 0; i < macro->argc; ++i)
 367         fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
 368                           macro->argv[i]);
 369       fprintf_filtered (gdb_stdout, ")");
 370     }
 371   fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
 372 }
 373
 374
 375 static void
 376 macro_list_command (char *exp, int from_tty)
 377 {
 378   macro_for_each (macro_user_macros, print_one_macro, NULL);
 379 }
 380
 381
 382 \f
 383 /* Initializing the `macrocmd' module.  */
 384
 385 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
 386
 387 void
 388 _initialize_macrocmd (void)
 389 {
 390   struct cmd_list_element *c;
 391
 392   /* We introduce a new command prefix, `macro', under which we'll put
 393      the various commands for working with preprocessor macros.  */
 394   add_prefix_cmd ("macro", class_info, macro_command,
 395                   _("Prefix for commands dealing with C preprocessor macros."),
 396                   &macrolist, "macro ", 0, &cmdlist);
 397
 398   add_cmd ("expand", no_class, macro_expand_command, _("\
 399 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
 400 Show the expanded expression."),
 401            &macrolist);
 402   add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
 403   add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
 404 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
 405 Show the expanded expression.\n\
 406 \n\
 407 This command differs from `macro expand' in that it only expands macro\n\
 408 invocations that appear directly in EXPRESSION; if expanding a macro\n\
 409 introduces further macro invocations, those are left unexpanded.\n\
 410 \n\
 411 `macro expand-once' helps you see how a particular macro expands,\n\
 412 whereas `macro expand' shows you how all the macros involved in an\n\
 413 expression work together to yield a pre-processed expression."),
 414            &macrolist);
 415   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
 416
 417   add_cmd ("macro", no_class, info_macro_command,
 418            _("Show the definition of MACRO, and its source location."),
 419            &infolist);
 420
 421   add_cmd ("define", no_class, macro_define_command, _("\
 422 Define a new C/C++ preprocessor macro.\n\
 423 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
 424 preprocessor directive of the form `#define DEFINITION' such that the\n\
 425 definition is visible in all the inferior's source files.\n\
 426 For example:\n\
 427   (gdb) macro define PI (3.1415926)\n\
 428   (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
 429            &macrolist);
 430
 431   add_cmd ("undef", no_class, macro_undef_command, _("\
 432 Remove the definition of the C/C++ preprocessor macro with the given name."),
 433            &macrolist);
 434
 435   add_cmd ("list", no_class, macro_list_command,
 436            _("List all the macros defined using the `macro define' command."),
 437            &macrolist);
 438 }