GDB (xrefs)
/tmp/gdb-7.10/gdb/macrocmd.c
Go to the documentation of this file.
1 /* C preprocessor macro expansion commands for GDB.
2  Copyright (C) 2002-2015 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 "cli/cli-utils.h"
26 #include "command.h"
27 #include "gdbcmd.h"
28 #include "linespec.h"
29 
30 
31 /* The `macro' prefix command. */
32 
33 static struct cmd_list_element *macrolist;
34 
35 static void
36 macro_command (char *arg, int from_tty)
37 {
39  ("\"macro\" must be followed by the name of a macro command.\n");
40  help_list (macrolist, "macro ", all_commands, gdb_stdout);
41 }
42 
43 
44 
45 /* Macro expansion commands. */
46 
47 
48 /* Prints an informational message regarding the lack of macro information. */
49 static void
51 {
52  puts_filtered ("GDB has no preprocessor macro information for that code.\n");
53 }
54 
55 static void
56 macro_expand_command (char *exp, int from_tty)
57 {
58  struct macro_scope *ms = NULL;
59  char *expanded = NULL;
61 
63 
64  /* You know, when the user doesn't specify any expression, it would be
65  really cool if this defaulted to the last expression evaluated.
66  Then it would be easy to ask, "Hey, what did I just evaluate?" But
67  at the moment, the `print' commands don't save the last expression
68  evaluated, just its value. */
69  if (! exp || ! *exp)
70  error (_("You must follow the `macro expand' command with the"
71  " expression you\n"
72  "want to expand."));
73 
74  ms = default_macro_scope ();
75  if (ms)
76  {
77  expanded = macro_expand (exp, standard_macro_lookup, ms);
78  fputs_filtered ("expands to: ", gdb_stdout);
79  fputs_filtered (expanded, gdb_stdout);
80  fputs_filtered ("\n", gdb_stdout);
81  }
82  else
84 
85  do_cleanups (cleanup_chain);
86  return;
87 }
88 
89 
90 static void
91 macro_expand_once_command (char *exp, int from_tty)
92 {
93  struct macro_scope *ms = NULL;
94  char *expanded = NULL;
97 
98  /* You know, when the user doesn't specify any expression, it would be
99  really cool if this defaulted to the last expression evaluated.
100  And it should set the once-expanded text as the new `last
101  expression'. That way, you could just hit return over and over and
102  see the expression expanded one level at a time. */
103  if (! exp || ! *exp)
104  error (_("You must follow the `macro expand-once' command with"
105  " the expression\n"
106  "you want to expand."));
107 
108  ms = default_macro_scope ();
109  if (ms)
110  {
111  expanded = macro_expand_once (exp, standard_macro_lookup, ms);
112  fputs_filtered ("expands to: ", gdb_stdout);
113  fputs_filtered (expanded, gdb_stdout);
114  fputs_filtered ("\n", gdb_stdout);
115  }
116  else
118 
119  do_cleanups (cleanup_chain);
120  return;
121 }
122 
123 /* Outputs the include path of a macro starting at FILE and LINE to STREAM.
124 
125  Care should be taken that this function does not cause any lookups into
126  the splay tree so that it can be safely used while iterating. */
127 static void
128 show_pp_source_pos (struct ui_file *stream,
129  struct macro_source_file *file,
130  int line)
131 {
132  char *fullname;
133 
134  fullname = macro_source_fullname (file);
135  fprintf_filtered (stream, "%s:%d\n", fullname, line);
136  xfree (fullname);
137 
138  while (file->included_by)
139  {
140  fullname = macro_source_fullname (file->included_by);
141  fprintf_filtered (gdb_stdout, " included at %s:%d\n", fullname,
142  file->included_at_line);
143  xfree (fullname);
144  file = file->included_by;
145  }
146 }
147 
148 /* Outputs a macro for human consumption, detailing the include path
149  and macro definition. NAME is the name of the macro.
150  D the definition. FILE the start of the include path, and LINE the
151  line number in FILE.
152 
153  Care should be taken that this function does not cause any lookups into
154  the splay tree so that it can be safely used while iterating. */
155 static void
157  const struct macro_definition *d,
158  struct macro_source_file *file,
159  int line)
160 {
161  fprintf_filtered (gdb_stdout, "Defined at ");
162  show_pp_source_pos (gdb_stdout, file, line);
163 
164  if (line != 0)
165  fprintf_filtered (gdb_stdout, "#define %s", name);
166  else
167  fprintf_filtered (gdb_stdout, "-D%s", name);
168 
169  if (d->kind == macro_function_like)
170  {
171  int i;
172 
173  fputs_filtered ("(", gdb_stdout);
174  for (i = 0; i < d->argc; i++)
175  {
176  fputs_filtered (d->argv[i], gdb_stdout);
177  if (i + 1 < d->argc)
178  fputs_filtered (", ", gdb_stdout);
179  }
180  fputs_filtered (")", gdb_stdout);
181  }
182 
183  if (line != 0)
184  fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
185  else
186  fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
187 }
188 
189 /* A callback function for usage with macro_for_each and friends.
190  If USER_DATA is null all macros will be printed.
191  Otherwise USER_DATA is considered to be a string, printing
192  only macros who's NAME matches USER_DATA. Other arguments are
193  routed to print_macro_definition. */
194 static void
195 print_macro_callback (const char *name, const struct macro_definition *macro,
196  struct macro_source_file *source, int line,
197  void *user_data)
198 {
199  if (! user_data || strcmp (user_data, name) == 0)
200  print_macro_definition (name, macro, source, line);
201 }
202 
203 /* The implementation of the `info macro' command. */
204 static void
205 info_macro_command (char *args, int from_tty)
206 {
207  struct macro_scope *ms = NULL;
208  struct cleanup *cleanup_chain;
209  char *name;
210  int show_all_macros_named = 0;
211  char *arg_start = args;
212  int processing_args = 1;
213 
214  while (processing_args
215  && arg_start && *arg_start == '-' && *arg_start != '\0')
216  {
217  char *p = skip_to_space (arg_start);
218 
219  if (strncmp (arg_start, "-a", p - arg_start) == 0
220  || strncmp (arg_start, "-all", p - arg_start) == 0)
221  show_all_macros_named = 1;
222  else if (strncmp (arg_start, "--", p - arg_start) == 0)
223  /* Our macro support seems rather C specific but this would
224  seem necessary for languages allowing - in macro names.
225  e.g. Scheme's (defmacro ->foo () "bar\n") */
226  processing_args = 0;
227  else
228  {
229  /* Relies on modified 'args' not making it in to history */
230  *p = '\0';
231  error (_("Unrecognized option '%s' to info macro command. "
232  "Try \"help info macro\"."), arg_start);
233  }
234 
235  arg_start = skip_spaces (p);
236  }
237 
238  name = arg_start;
239 
240  if (! name || ! *name)
241  error (_("You must follow the `info macro' command with the name"
242  " of the macro\n"
243  "whose definition you want to see."));
244 
245  ms = default_macro_scope ();
246  cleanup_chain = make_cleanup (free_current_contents, &ms);
247 
248  if (! ms)
250  else if (show_all_macros_named)
252  else
253  {
254  struct macro_definition *d;
255 
256  d = macro_lookup_definition (ms->file, ms->line, name);
257  if (d)
258  {
259  int line;
260  struct macro_source_file *file
261  = macro_definition_location (ms->file, ms->line, name, &line);
262 
263  print_macro_definition (name, d, file, line);
264  }
265  else
266  {
268  "The symbol `%s' has no definition as a C/C++"
269  " preprocessor macro\n"
270  "at ", name);
272  }
273  }
274 
275  do_cleanups (cleanup_chain);
276 }
277 
278 /* Implementation of the "info macros" command. */
279 static void
280 info_macros_command (char *args, int from_tty)
281 {
282  struct macro_scope *ms = NULL;
284 
285  if (args == NULL)
286  ms = default_macro_scope ();
287  else
288  {
289  struct symtabs_and_lines sals =
291 
292  if (sals.nelts)
293  ms = sal_macro_scope (sals.sals[0]);
294  }
295 
296  if (! ms || ! ms->file || ! ms->file->table)
298  else
300 
301  do_cleanups (cleanup_chain);
302 }
303 
304 
305 /* User-defined macros. */
306 
307 static void
308 skip_ws (char **expp)
309 {
310  while (macro_is_whitespace (**expp))
311  ++*expp;
312 }
313 
314 /* Try to find the bounds of an identifier. If an identifier is
315  found, returns a newly allocated string; otherwise returns NULL.
316  EXPP is a pointer to an input string; it is updated to point to the
317  text following the identifier. If IS_PARAMETER is true, this
318  function will also allow "..." forms as used in varargs macro
319  parameters. */
320 
321 static char *
322 extract_identifier (char **expp, int is_parameter)
323 {
324  char *result;
325  char *p = *expp;
326  unsigned int len;
327 
328  if (is_parameter && startswith (p, "..."))
329  {
330  /* Ok. */
331  }
332  else
333  {
334  if (! *p || ! macro_is_identifier_nondigit (*p))
335  return NULL;
336  for (++p;
337  *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
338  ++p)
339  ;
340  }
341 
342  if (is_parameter && startswith (p, "..."))
343  p += 3;
344 
345  len = p - *expp;
346  result = (char *) xmalloc (len + 1);
347  memcpy (result, *expp, len);
348  result[len] = '\0';
349  *expp += len;
350  return result;
351 }
352 
353 /* Helper function to clean up a temporarily-constructed macro object.
354  This assumes that the contents were all allocated with xmalloc. */
355 static void
357 {
358  int i;
359  struct macro_definition *loc = (struct macro_definition *) ptr;
360 
361  for (i = 0; i < loc->argc; ++i)
362  xfree ((char *) loc->argv[i]);
363  xfree ((char *) loc->argv);
364  /* Note that the 'replacement' field is not allocated. */
365 }
366 
367 static void
368 macro_define_command (char *exp, int from_tty)
369 {
370  struct macro_definition new_macro;
371  char *name = NULL;
372  struct cleanup *cleanup_chain;
373 
374  if (!exp)
375  error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
376 
377  cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
379 
380  memset (&new_macro, 0, sizeof (struct macro_definition));
381 
382  skip_ws (&exp);
383  name = extract_identifier (&exp, 0);
384  if (! name)
385  error (_("Invalid macro name."));
386  if (*exp == '(')
387  {
388  /* Function-like macro. */
389  int alloced = 5;
390  char **argv = (char **) xmalloc (alloced * sizeof (char *));
391 
392  new_macro.kind = macro_function_like;
393  new_macro.argc = 0;
394  new_macro.argv = (const char * const *) argv;
395 
396  /* Skip the '(' and whitespace. */
397  ++exp;
398  skip_ws (&exp);
399 
400  while (*exp != ')')
401  {
402  int i;
403 
404  if (new_macro.argc == alloced)
405  {
406  alloced *= 2;
407  argv = (char **) xrealloc (argv, alloced * sizeof (char *));
408  /* Must update new_macro as well... */
409  new_macro.argv = (const char * const *) argv;
410  }
411  argv[new_macro.argc] = extract_identifier (&exp, 1);
412  if (! argv[new_macro.argc])
413  error (_("Macro is missing an argument."));
414  ++new_macro.argc;
415 
416  for (i = new_macro.argc - 2; i >= 0; --i)
417  {
418  if (! strcmp (argv[i], argv[new_macro.argc - 1]))
419  error (_("Two macro arguments with identical names."));
420  }
421 
422  skip_ws (&exp);
423  if (*exp == ',')
424  {
425  ++exp;
426  skip_ws (&exp);
427  }
428  else if (*exp != ')')
429  error (_("',' or ')' expected at end of macro arguments."));
430  }
431  /* Skip the closing paren. */
432  ++exp;
433  skip_ws (&exp);
434 
436  new_macro.argc, (const char **) new_macro.argv,
437  exp);
438  }
439  else
440  {
441  skip_ws (&exp);
443  }
444 
445  do_cleanups (cleanup_chain);
446 }
447 
448 
449 static void
450 macro_undef_command (char *exp, int from_tty)
451 {
452  char *name;
453 
454  if (!exp)
455  error (_("usage: macro undef NAME"));
456 
457  skip_ws (&exp);
458  name = extract_identifier (&exp, 0);
459  if (! name)
460  error (_("Invalid macro name."));
462  xfree (name);
463 }
464 
465 
466 static void
467 print_one_macro (const char *name, const struct macro_definition *macro,
468  struct macro_source_file *source, int line,
469  void *ignore)
470 {
471  fprintf_filtered (gdb_stdout, "macro define %s", name);
472  if (macro->kind == macro_function_like)
473  {
474  int i;
475 
477  for (i = 0; i < macro->argc; ++i)
478  fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
479  macro->argv[i]);
481  }
482  fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
483 }
484 
485 
486 static void
487 macro_list_command (char *exp, int from_tty)
488 {
490 }
491 
492 
493 /* Initializing the `macrocmd' module. */
494 
495 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
496 
497 void
499 {
500  /* We introduce a new command prefix, `macro', under which we'll put
501  the various commands for working with preprocessor macros. */
503  _("Prefix for commands dealing with C preprocessor macros."),
504  &macrolist, "macro ", 0, &cmdlist);
505 
506  add_cmd ("expand", no_class, macro_expand_command, _("\
507 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
508 Show the expanded expression."),
509  &macrolist);
510  add_alias_cmd ("exp", "expand", no_class, 1, &macrolist);
511  add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
512 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
513 Show the expanded expression.\n\
514 \n\
515 This command differs from `macro expand' in that it only expands macro\n\
516 invocations that appear directly in EXPRESSION; if expanding a macro\n\
517 introduces further macro invocations, those are left unexpanded.\n\
518 \n\
519 `macro expand-once' helps you see how a particular macro expands,\n\
520 whereas `macro expand' shows you how all the macros involved in an\n\
521 expression work together to yield a pre-processed expression."),
522  &macrolist);
523  add_alias_cmd ("exp1", "expand-once", no_class, 1, &macrolist);
524 
526  _("Show the definition of MACRO, and it's source location.\n\
527 Usage: info macro [-a|-all] [--] MACRO\n\
528 Options: \n\
529  -a, --all Output all definitions of MACRO in the current compilation\
530  unit.\n\
531  -- Specify the end of arguments and the beginning of the MACRO."),
532 
533  &infolist);
534 
536  _("Show the definitions of all macros at LINESPEC, or the current \
537 source location.\n\
538 Usage: info macros [LINESPEC]"),
539  &infolist);
540 
541  add_cmd ("define", no_class, macro_define_command, _("\
542 Define a new C/C++ preprocessor macro.\n\
543 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
544 preprocessor directive of the form `#define DEFINITION' such that the\n\
545 definition is visible in all the inferior's source files.\n\
546 For example:\n\
547  (gdb) macro define PI (3.1415926)\n\
548  (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
549  &macrolist);
550 
551  add_cmd ("undef", no_class, macro_undef_command, _("\
552 Remove the definition of the C/C++ preprocessor macro with the given name."),
553  &macrolist);
554 
556  _("List all the macros defined using the `macro define' command."),
557  &macrolist);
558 }
void macro_define_function(struct macro_source_file *source, int line, const char *name, int argc, const char **argv, const char *replacement)
Definition: macrotab.c:800
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
int macro_is_digit(int c)
Definition: macroexp.c:197
const char *const * argv
Definition: macrotab.h:300
struct macro_source_file * file
Definition: macroscope.h:34
char * macro_expand(const char *source, macro_lookup_ftype *lookup_func, void *lookup_func_baton)
Definition: macroexp.c:1410
int macro_is_identifier_nondigit(int c)
Definition: macroexp.c:204
__extension__ enum macro_kind kind
Definition: macrotab.h:292
static void skip_ws(char **expp)
Definition: macrocmd.c:308
void xfree(void *)
Definition: common-utils.c:97
initialize_file_ftype _initialize_macrocmd
static struct cleanup * cleanup_chain
Definition: cleanups.c:63
struct macro_table * table
Definition: macrotab.h:127
struct macro_source_file * included_by
Definition: macrotab.h:136
struct ui_file * gdb_stdout
Definition: main.c:71
struct macro_definition * standard_macro_lookup(const char *name, void *baton)
Definition: macroscope.c:147
static void print_macro_definition(const char *name, const struct macro_definition *d, struct macro_source_file *file, int line)
Definition: macrocmd.c:156
static void macro_inform_no_debuginfo(void)
Definition: macrocmd.c:50
void macro_for_each_in_scope(struct macro_source_file *file, int line, macro_callback_fn fn, void *user_data)
Definition: macrotab.c:1031
static void free_macro_definition_ptr(void *ptr)
Definition: macrocmd.c:356
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
char * skip_spaces(char *chp)
Definition: common-utils.c:259
#define _(String)
Definition: gdb_locale.h:40
struct macro_scope * sal_macro_scope(struct symtab_and_line sal)
Definition: macroscope.c:39
static void macro_command(char *arg, int from_tty)
Definition: macrocmd.c:36
struct macro_scope * default_macro_scope(void)
Definition: macroscope.c:102
static void macro_define_command(char *exp, int from_tty)
Definition: macrocmd.c:368
struct macro_table * macro_user_macros
Definition: macroscope.c:35
void macro_define_object(struct macro_source_file *source, int line, const char *name, const char *replacement)
Definition: macrotab.c:781
struct cmd_list_element * infolist
Definition: cli-cmds.c:107
const char *const name
Definition: aarch64-tdep.c:68
void initialize_file_ftype(void)
Definition: defs.h:281
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
struct macro_definition * macro_lookup_definition(struct macro_source_file *source, int line, const char *name)
Definition: macrotab.c:919
static char * extract_identifier(char **expp, int is_parameter)
Definition: macrocmd.c:322
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
void puts_filtered(const char *string)
Definition: utils.c:2428
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static void macro_undef_command(char *exp, int from_tty)
Definition: macrocmd.c:450
void free_current_contents(void *ptr)
Definition: utils.c:476
static void macro_expand_once_command(char *exp, int from_tty)
Definition: macrocmd.c:91
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:286
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
char * macro_source_fullname(struct macro_source_file *file)
Definition: macrotab.c:1092
void * xmalloc(YYSIZE_T)
struct macro_source_file * macro_definition_location(struct macro_source_file *source, int line, const char *name, int *definition_line)
Definition: macrotab.c:941
static void macro_list_command(char *exp, int from_tty)
Definition: macrocmd.c:487
void macro_for_each(struct macro_table *table, macro_callback_fn fn, void *user_data)
Definition: macrotab.c:992
static void info_macro_command(char *args, int from_tty)
Definition: macrocmd.c:205
static void print_one_macro(const char *name, const struct macro_definition *macro, struct macro_source_file *source, int line, void *ignore)
Definition: macrocmd.c:467
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
static void show_pp_source_pos(struct ui_file *stream, struct macro_source_file *file, int line)
Definition: macrocmd.c:128
int line
Definition: symtab.h:1570
struct symtabs_and_lines decode_line_with_current_source(char *string, int flags)
Definition: linespec.c:2543
static void print_macro_callback(const char *name, const struct macro_definition *macro, struct macro_source_file *source, int line, void *user_data)
Definition: macrocmd.c:195
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
struct symtab_and_line * sals
Definition: symtab.h:1392
struct macro_source_file * macro_main(struct macro_table *t)
Definition: macrotab.c:432
const char * replacement
Definition: macrotab.h:307
static struct cmd_list_element * macrolist
Definition: macrocmd.c:33
static void info_macros_command(char *args, int from_tty)
Definition: macrocmd.c:280
void error(const char *fmt,...)
Definition: errors.c:38
void macro_undef(struct macro_source_file *source, int line, const char *name)
Definition: macrotab.c:828
char * macro_expand_once(const char *source, macro_lookup_ftype *lookup_func, void *lookup_func_baton)
Definition: macroexp.c:1433
#define skip_to_space(INP)
Definition: common-utils.h:94
static void macro_expand_command(char *exp, int from_tty)
Definition: macrocmd.c:56
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
const ULONGEST const LONGEST len
Definition: target.h:309
int macro_is_whitespace(int c)
Definition: macroexp.c:186