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       fprintf_filtered (gdb_stdout, "#define %s", name);
 162       if (d->kind == macro_function_like)
 163         {
 164           int i;
 165
 166           fputs_filtered ("(", gdb_stdout);
 167           for (i = 0; i < d->argc; i++)
 168             {
 169               fputs_filtered (d->argv[i], gdb_stdout);
 170               if (i + 1 < d->argc)
 171                 fputs_filtered (", ", gdb_stdout);
 172             }
 173           fputs_filtered (")", gdb_stdout);
 174         }
 175       fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
 176     }
 177   else
 178     {
 179       fprintf_filtered (gdb_stdout,
 180                         "The symbol `%s' has no definition as a C/C++"
 181                         " preprocessor macro\n"
 182                         "at ", name);
 183       show_pp_source_pos (gdb_stdout, ms->file, ms->line);
 184     }
 185
 186   do_cleanups (cleanup_chain);
 187 }
 188
 189
 190 \f
 191 /* User-defined macros.  */
 192
 193 static void
 194 skip_ws (char **expp)
 195 {
 196   while (macro_is_whitespace (**expp))
 197     ++*expp;
 198 }
 199
 200 /* Try to find the bounds of an identifier.  If an identifier is
 201    found, returns a newly allocated string; otherwise returns NULL.
 202    EXPP is a pointer to an input string; it is updated to point to the
 203    text following the identifier.  If IS_PARAMETER is true, this
 204    function will also allow "..." forms as used in varargs macro
 205    parameters.  */
 206
 207 static char *
 208 extract_identifier (char **expp, int is_parameter)
 209 {
 210   char *result;
 211   char *p = *expp;
 212   unsigned int len;
 213
 214   if (is_parameter && !strncmp (p, "...", 3))
 215     {
 216       /* Ok.  */
 217     }
 218   else
 219     {
 220       if (! *p || ! macro_is_identifier_nondigit (*p))
 221         return NULL;
 222       for (++p;
 223            *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
 224            ++p)
 225         ;
 226     }
 227
 228   if (is_parameter && !strncmp (p, "...", 3))
 229     p += 3;
 230
 231   len = p - *expp;
 232   result = (char *) xmalloc (len + 1);
 233   memcpy (result, *expp, len);
 234   result[len] = '\0';
 235   *expp += len;
 236   return result;
 237 }
 238
 239 /* Helper function to clean up a temporarily-constructed macro object.
 240    This assumes that the contents were all allocated with xmalloc.  */
 241 static void
 242 free_macro_definition_ptr (void *ptr)
 243 {
 244   int i;
 245   struct macro_definition *loc = (struct macro_definition *) ptr;
 246   for (i = 0; i < loc->argc; ++i)
 247     xfree ((char *) loc->argv[i]);
 248   xfree ((char *) loc->argv);
 249   /* Note that the 'replacement' field is not allocated.  */
 250 }
 251
 252 static void
 253 macro_define_command (char *exp, int from_tty)
 254 {
 255   struct macro_definition new_macro;
 256   char *name = NULL;
 257   struct cleanup *cleanup_chain;
 258
 259   if (!exp)
 260     error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
 261
 262   cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
 263   make_cleanup (free_current_contents, &name);
 264
 265   memset (&new_macro, 0, sizeof (struct macro_definition));
 266
 267   skip_ws (&exp);
 268   name = extract_identifier (&exp, 0);
 269   if (! name)
 270     error (_("Invalid macro name."));
 271   if (*exp == '(')
 272     {
 273       /* Function-like macro.  */
 274       int alloced = 5;
 275       char **argv = (char **) xmalloc (alloced * sizeof (char *));
 276
 277       new_macro.kind = macro_function_like;
 278       new_macro.argc = 0;
 279       new_macro.argv = (const char * const *) argv;
 280
 281       /* Skip the '(' and whitespace.  */
 282       ++exp;
 283       skip_ws (&exp);
 284
 285       while (*exp != ')')
 286         {
 287           int i;
 288
 289           if (new_macro.argc == alloced)
 290             {
 291               alloced *= 2;
 292               argv = (char **) xrealloc (argv, alloced * sizeof (char *));
 293               /* Must update new_macro as well... */
 294               new_macro.argv = (const char * const *) argv;
 295             }
 296           argv[new_macro.argc] = extract_identifier (&exp, 1);
 297           if (! argv[new_macro.argc])
 298             error (_("Macro is missing an argument."));
 299           ++new_macro.argc;
 300
 301           for (i = new_macro.argc - 2; i >= 0; --i)
 302             {
 303               if (! strcmp (argv[i], argv[new_macro.argc - 1]))
 304                 error (_("Two macro arguments with identical names."));
 305             }
 306
 307           skip_ws (&exp);
 308           if (*exp == ',')
 309             {
 310               ++exp;
 311               skip_ws (&exp);
 312             }
 313           else if (*exp != ')')
 314             error (_("',' or ')' expected at end of macro arguments."));
 315         }
 316       /* Skip the closing paren.  */
 317       ++exp;
 318       skip_ws (&exp);
 319
 320       macro_define_function (macro_main (macro_user_macros), -1, name,
 321                              new_macro.argc, (const char **) new_macro.argv,
 322                              exp);
 323     }
 324   else
 325     {
 326       skip_ws (&exp);
 327       macro_define_object (macro_main (macro_user_macros), -1, name, exp);
 328     }
 329
 330   do_cleanups (cleanup_chain);
 331 }
 332
 333
 334 static void
 335 macro_undef_command (char *exp, int from_tty)
 336 {
 337   char *name;
 338
 339   if (!exp)
 340     error (_("usage: macro undef NAME"));
 341
 342   skip_ws (&exp);
 343   name = extract_identifier (&exp, 0);
 344   if (! name)
 345     error (_("Invalid macro name."));
 346   macro_undef (macro_main (macro_user_macros), -1, name);
 347   xfree (name);
 348 }
 349
 350
 351 static void
 352 print_one_macro (const char *name, const struct macro_definition *macro,
 353                  void *ignore)
 354 {
 355   fprintf_filtered (gdb_stdout, "macro define %s", name);
 356   if (macro->kind == macro_function_like)
 357     {
 358       int i;
 359       fprintf_filtered (gdb_stdout, "(");
 360       for (i = 0; i < macro->argc; ++i)
 361         fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
 362                           macro->argv[i]);
 363       fprintf_filtered (gdb_stdout, ")");
 364     }
 365   fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
 366 }
 367
 368
 369 static void
 370 macro_list_command (char *exp, int from_tty)
 371 {
 372   macro_for_each (macro_user_macros, print_one_macro, NULL);
 373 }
 374
 375
 376 \f
 377 /* Initializing the `macrocmd' module.  */
 378
 379 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
 380
 381 void
 382 _initialize_macrocmd (void)
 383 {
 384   struct cmd_list_element *c;
 385
 386   /* We introduce a new command prefix, `macro', under which we'll put
 387      the various commands for working with preprocessor macros.  */
 388   add_prefix_cmd ("macro", class_info, macro_command,
 389                   _("Prefix for commands dealing with C preprocessor macros."),
 390                   &macrolist, "macro ", 0, &cmdlist);
 391
 392   add_cmd ("expand", no_class, macro_expand_command, _("\
 393 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
 394 Show the expanded expression."),
 395            &macrolist);
 396   add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
 397   add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
 398 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
 399 Show the expanded expression.\n\
 400 \n\
 401 This command differs from `macro expand' in that it only expands macro\n\
 402 invocations that appear directly in EXPRESSION; if expanding a macro\n\
 403 introduces further macro invocations, those are left unexpanded.\n\
 404 \n\
 405 `macro expand-once' helps you see how a particular macro expands,\n\
 406 whereas `macro expand' shows you how all the macros involved in an\n\
 407 expression work together to yield a pre-processed expression."),
 408            &macrolist);
 409   add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
 410
 411   add_cmd ("macro", no_class, info_macro_command,
 412            _("Show the definition of MACRO, and its source location."),
 413            &infolist);
 414
 415   add_cmd ("define", no_class, macro_define_command, _("\
 416 Define a new C/C++ preprocessor macro.\n\
 417 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
 418 preprocessor directive of the form `#define DEFINITION' such that the\n\
 419 definition is visible in all the inferior's source files.\n\
 420 For example:\n\
 421   (gdb) macro define PI (3.1415926)\n\
 422   (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
 423            &macrolist);
 424
 425   add_cmd ("undef", no_class, macro_undef_command, _("\
 426 Remove the definition of the C/C++ preprocessor macro with the given name."),
 427            &macrolist);
 428
 429   add_cmd ("list", no_class, macro_list_command,
 430            _("List all the macros defined using the `macro define' command."),
 431            &macrolist);
 432 }