1 /* C preprocessor macro expansion commands for GDB.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3 Contributed by Red Hat, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #include "macroscope.h"
25 #include "cli/cli-utils.h"
31 /* The `macro' prefix command. */
33 static struct cmd_list_element *macrolist;
36 macro_command (char *arg, int from_tty)
39 ("\"macro\" must be followed by the name of a macro command.\n");
40 help_list (macrolist, "macro ", all_commands, gdb_stdout);
45 /* Macro expansion commands. */
48 /* Prints an informational message regarding the lack of macro information. */
50 macro_inform_no_debuginfo (void)
52 puts_filtered ("GDB has no preprocessor macro information for that code.\n");
56 macro_expand_command (const char *exp, int from_tty)
58 struct macro_scope *ms = NULL;
59 char *expanded = NULL;
60 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
62 make_cleanup (free_current_contents, &expanded);
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. */
70 error (_("You must follow the `macro expand' command with the"
74 ms = default_macro_scope ();
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);
83 macro_inform_no_debuginfo ();
85 do_cleanups (cleanup_chain);
91 macro_expand_once_command (const char *exp, int from_tty)
93 struct macro_scope *ms = NULL;
94 char *expanded = NULL;
95 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
96 make_cleanup (free_current_contents, &expanded);
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. */
104 error (_("You must follow the `macro expand-once' command with"
106 "you want to expand."));
108 ms = default_macro_scope ();
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);
117 macro_inform_no_debuginfo ();
119 do_cleanups (cleanup_chain);
123 /* Outputs the include path of a macro starting at FILE and LINE to STREAM.
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. */
128 show_pp_source_pos (struct ui_file *stream,
129 struct macro_source_file *file,
134 fullname = macro_source_fullname (file);
135 fprintf_filtered (stream, "%s:%d\n", fullname, line);
138 while (file->included_by)
140 fullname = macro_source_fullname (file->included_by);
141 fprintf_filtered (gdb_stdout, " included at %s:%d\n", fullname,
142 file->included_at_line);
144 file = file->included_by;
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
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. */
156 print_macro_definition (const char *name,
157 const struct macro_definition *d,
158 struct macro_source_file *file,
161 fprintf_filtered (gdb_stdout, "Defined at ");
162 show_pp_source_pos (gdb_stdout, file, line);
165 fprintf_filtered (gdb_stdout, "#define %s", name);
167 fprintf_filtered (gdb_stdout, "-D%s", name);
169 if (d->kind == macro_function_like)
173 fputs_filtered ("(", gdb_stdout);
174 for (i = 0; i < d->argc; i++)
176 fputs_filtered (d->argv[i], gdb_stdout);
178 fputs_filtered (", ", gdb_stdout);
180 fputs_filtered (")", gdb_stdout);
184 fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
186 fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
189 /* The implementation of the `info macro' command. */
191 info_macro_command (char *args, int from_tty)
193 struct macro_scope *ms = NULL;
194 struct cleanup *cleanup_chain;
196 int show_all_macros_named = 0;
197 char *arg_start = args;
198 int processing_args = 1;
200 while (processing_args
201 && arg_start && *arg_start == '-' && *arg_start != '\0')
203 char *p = skip_to_space (arg_start);
205 if (strncmp (arg_start, "-a", p - arg_start) == 0
206 || strncmp (arg_start, "-all", p - arg_start) == 0)
207 show_all_macros_named = 1;
208 else if (strncmp (arg_start, "--", p - arg_start) == 0)
209 /* Our macro support seems rather C specific but this would
210 seem necessary for languages allowing - in macro names.
211 e.g. Scheme's (defmacro ->foo () "bar\n") */
215 /* Relies on modified 'args' not making it in to history */
217 error (_("Unrecognized option '%s' to info macro command. "
218 "Try \"help info macro\"."), arg_start);
221 arg_start = skip_spaces (p);
226 if (! name || ! *name)
227 error (_("You must follow the `info macro' command with the name"
229 "whose definition you want to see."));
231 ms = default_macro_scope ();
232 cleanup_chain = make_cleanup (free_current_contents, &ms);
235 macro_inform_no_debuginfo ();
236 else if (show_all_macros_named)
237 macro_for_each (ms->file->table, [&] (const char *macro_name,
238 const macro_definition *macro,
239 macro_source_file *source,
242 if (strcmp (name, macro_name) == 0)
243 print_macro_definition (name, macro, source, line);
247 struct macro_definition *d;
249 d = macro_lookup_definition (ms->file, ms->line, name);
253 struct macro_source_file *file
254 = macro_definition_location (ms->file, ms->line, name, &line);
256 print_macro_definition (name, d, file, line);
260 fprintf_filtered (gdb_stdout,
261 "The symbol `%s' has no definition as a C/C++"
262 " preprocessor macro\n"
264 show_pp_source_pos (gdb_stdout, ms->file, ms->line);
268 do_cleanups (cleanup_chain);
271 /* Implementation of the "info macros" command. */
273 info_macros_command (char *args, int from_tty)
275 struct macro_scope *ms = NULL;
276 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
279 ms = default_macro_scope ();
282 std::vector<symtab_and_line> sals
283 = decode_line_with_current_source (args, 0);
286 ms = sal_macro_scope (sals[0]);
289 if (! ms || ! ms->file || ! ms->file->table)
290 macro_inform_no_debuginfo ();
292 macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
294 do_cleanups (cleanup_chain);
298 /* User-defined macros. */
301 skip_ws (const char **expp)
303 while (macro_is_whitespace (**expp))
307 /* Try to find the bounds of an identifier. If an identifier is
308 found, returns a newly allocated string; otherwise returns NULL.
309 EXPP is a pointer to an input string; it is updated to point to the
310 text following the identifier. If IS_PARAMETER is true, this
311 function will also allow "..." forms as used in varargs macro
315 extract_identifier (const char **expp, int is_parameter)
318 const char *p = *expp;
321 if (is_parameter && startswith (p, "..."))
327 if (! *p || ! macro_is_identifier_nondigit (*p))
330 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
335 if (is_parameter && startswith (p, "..."))
339 result = (char *) xmalloc (len + 1);
340 memcpy (result, *expp, len);
346 /* Helper function to clean up a temporarily-constructed macro object.
347 This assumes that the contents were all allocated with xmalloc. */
349 free_macro_definition_ptr (void *ptr)
352 struct macro_definition *loc = (struct macro_definition *) ptr;
354 for (i = 0; i < loc->argc; ++i)
355 xfree ((char *) loc->argv[i]);
356 xfree ((char *) loc->argv);
357 /* Note that the 'replacement' field is not allocated. */
361 macro_define_command (const char *exp, int from_tty)
363 struct macro_definition new_macro;
365 struct cleanup *cleanup_chain;
368 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
370 cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
371 make_cleanup (free_current_contents, &name);
373 memset (&new_macro, 0, sizeof (struct macro_definition));
376 name = extract_identifier (&exp, 0);
378 error (_("Invalid macro name."));
381 /* Function-like macro. */
383 char **argv = XNEWVEC (char *, alloced);
385 new_macro.kind = macro_function_like;
387 new_macro.argv = (const char * const *) argv;
389 /* Skip the '(' and whitespace. */
397 if (new_macro.argc == alloced)
400 argv = (char **) xrealloc (argv, alloced * sizeof (char *));
401 /* Must update new_macro as well... */
402 new_macro.argv = (const char * const *) argv;
404 argv[new_macro.argc] = extract_identifier (&exp, 1);
405 if (! argv[new_macro.argc])
406 error (_("Macro is missing an argument."));
409 for (i = new_macro.argc - 2; i >= 0; --i)
411 if (! strcmp (argv[i], argv[new_macro.argc - 1]))
412 error (_("Two macro arguments with identical names."));
421 else if (*exp != ')')
422 error (_("',' or ')' expected at end of macro arguments."));
424 /* Skip the closing paren. */
428 macro_define_function (macro_main (macro_user_macros), -1, name,
429 new_macro.argc, (const char **) new_macro.argv,
435 macro_define_object (macro_main (macro_user_macros), -1, name, exp);
438 do_cleanups (cleanup_chain);
443 macro_undef_command (const char *exp, int from_tty)
448 error (_("usage: macro undef NAME"));
451 name = extract_identifier (&exp, 0);
453 error (_("Invalid macro name."));
454 macro_undef (macro_main (macro_user_macros), -1, name);
460 print_one_macro (const char *name, const struct macro_definition *macro,
461 struct macro_source_file *source, int line)
463 fprintf_filtered (gdb_stdout, "macro define %s", name);
464 if (macro->kind == macro_function_like)
468 fprintf_filtered (gdb_stdout, "(");
469 for (i = 0; i < macro->argc; ++i)
470 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
472 fprintf_filtered (gdb_stdout, ")");
474 fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
479 macro_list_command (const char *exp, int from_tty)
481 macro_for_each (macro_user_macros, print_one_macro);
484 /* Initializing the `macrocmd' module. */
487 _initialize_macrocmd (void)
489 /* We introduce a new command prefix, `macro', under which we'll put
490 the various commands for working with preprocessor macros. */
491 add_prefix_cmd ("macro", class_info, macro_command,
492 _("Prefix for commands dealing with C preprocessor macros."),
493 ¯olist, "macro ", 0, &cmdlist);
495 add_cmd ("expand", no_class, macro_expand_command, _("\
496 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
497 Show the expanded expression."),
499 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist);
500 add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
501 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
502 Show the expanded expression.\n\
504 This command differs from `macro expand' in that it only expands macro\n\
505 invocations that appear directly in EXPRESSION; if expanding a macro\n\
506 introduces further macro invocations, those are left unexpanded.\n\
508 `macro expand-once' helps you see how a particular macro expands,\n\
509 whereas `macro expand' shows you how all the macros involved in an\n\
510 expression work together to yield a pre-processed expression."),
512 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist);
514 add_info ("macro", info_macro_command,
515 _("Show the definition of MACRO, and it's source location.\n\
516 Usage: info macro [-a|-all] [--] MACRO\n\
518 -a, --all Output all definitions of MACRO in the current compilation\
520 -- Specify the end of arguments and the beginning of the MACRO."));
522 add_info ("macros", info_macros_command,
523 _("Show the definitions of all macros at LINESPEC, or the current \
525 Usage: info macros [LINESPEC]"));
527 add_cmd ("define", no_class, macro_define_command, _("\
528 Define a new C/C++ preprocessor macro.\n\
529 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
530 preprocessor directive of the form `#define DEFINITION' such that the\n\
531 definition is visible in all the inferior's source files.\n\
533 (gdb) macro define PI (3.1415926)\n\
534 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
537 add_cmd ("undef", no_class, macro_undef_command, _("\
538 Remove the definition of the C/C++ preprocessor macro with the given name."),
541 add_cmd ("list", no_class, macro_list_command,
542 _("List all the macros defined using the `macro define' command."),