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 (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 (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 /* 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. */
195 print_macro_callback (const char *name, const struct macro_definition *macro,
196 struct macro_source_file *source, int line,
199 if (! user_data || strcmp ((const char *) user_data, name) == 0)
200 print_macro_definition (name, macro, source, line);
203 /* The implementation of the `info macro' command. */
205 info_macro_command (char *args, int from_tty)
207 struct macro_scope *ms = NULL;
208 struct cleanup *cleanup_chain;
210 int show_all_macros_named = 0;
211 char *arg_start = args;
212 int processing_args = 1;
214 while (processing_args
215 && arg_start && *arg_start == '-' && *arg_start != '\0')
217 char *p = skip_to_space (arg_start);
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") */
229 /* Relies on modified 'args' not making it in to history */
231 error (_("Unrecognized option '%s' to info macro command. "
232 "Try \"help info macro\"."), arg_start);
235 arg_start = skip_spaces (p);
240 if (! name || ! *name)
241 error (_("You must follow the `info macro' command with the name"
243 "whose definition you want to see."));
245 ms = default_macro_scope ();
246 cleanup_chain = make_cleanup (free_current_contents, &ms);
249 macro_inform_no_debuginfo ();
250 else if (show_all_macros_named)
251 macro_for_each (ms->file->table, print_macro_callback, name);
254 struct macro_definition *d;
256 d = macro_lookup_definition (ms->file, ms->line, name);
260 struct macro_source_file *file
261 = macro_definition_location (ms->file, ms->line, name, &line);
263 print_macro_definition (name, d, file, line);
267 fprintf_filtered (gdb_stdout,
268 "The symbol `%s' has no definition as a C/C++"
269 " preprocessor macro\n"
271 show_pp_source_pos (gdb_stdout, ms->file, ms->line);
275 do_cleanups (cleanup_chain);
278 /* Implementation of the "info macros" command. */
280 info_macros_command (char *args, int from_tty)
282 struct macro_scope *ms = NULL;
283 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
286 ms = default_macro_scope ();
289 struct symtabs_and_lines sals =
290 decode_line_with_current_source (args, 0);
293 ms = sal_macro_scope (sals.sals[0]);
296 if (! ms || ! ms->file || ! ms->file->table)
297 macro_inform_no_debuginfo ();
299 macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL);
301 do_cleanups (cleanup_chain);
305 /* User-defined macros. */
308 skip_ws (char **expp)
310 while (macro_is_whitespace (**expp))
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
322 extract_identifier (char **expp, int is_parameter)
328 if (is_parameter && startswith (p, "..."))
334 if (! *p || ! macro_is_identifier_nondigit (*p))
337 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
342 if (is_parameter && startswith (p, "..."))
346 result = (char *) xmalloc (len + 1);
347 memcpy (result, *expp, len);
353 /* Helper function to clean up a temporarily-constructed macro object.
354 This assumes that the contents were all allocated with xmalloc. */
356 free_macro_definition_ptr (void *ptr)
359 struct macro_definition *loc = (struct macro_definition *) ptr;
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. */
368 macro_define_command (char *exp, int from_tty)
370 struct macro_definition new_macro;
372 struct cleanup *cleanup_chain;
375 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
377 cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
378 make_cleanup (free_current_contents, &name);
380 memset (&new_macro, 0, sizeof (struct macro_definition));
383 name = extract_identifier (&exp, 0);
385 error (_("Invalid macro name."));
388 /* Function-like macro. */
390 char **argv = XNEWVEC (char *, alloced);
392 new_macro.kind = macro_function_like;
394 new_macro.argv = (const char * const *) argv;
396 /* Skip the '(' and whitespace. */
404 if (new_macro.argc == alloced)
407 argv = (char **) xrealloc (argv, alloced * sizeof (char *));
408 /* Must update new_macro as well... */
409 new_macro.argv = (const char * const *) argv;
411 argv[new_macro.argc] = extract_identifier (&exp, 1);
412 if (! argv[new_macro.argc])
413 error (_("Macro is missing an argument."));
416 for (i = new_macro.argc - 2; i >= 0; --i)
418 if (! strcmp (argv[i], argv[new_macro.argc - 1]))
419 error (_("Two macro arguments with identical names."));
428 else if (*exp != ')')
429 error (_("',' or ')' expected at end of macro arguments."));
431 /* Skip the closing paren. */
435 macro_define_function (macro_main (macro_user_macros), -1, name,
436 new_macro.argc, (const char **) new_macro.argv,
442 macro_define_object (macro_main (macro_user_macros), -1, name, exp);
445 do_cleanups (cleanup_chain);
450 macro_undef_command (char *exp, int from_tty)
455 error (_("usage: macro undef NAME"));
458 name = extract_identifier (&exp, 0);
460 error (_("Invalid macro name."));
461 macro_undef (macro_main (macro_user_macros), -1, name);
467 print_one_macro (const char *name, const struct macro_definition *macro,
468 struct macro_source_file *source, int line,
471 fprintf_filtered (gdb_stdout, "macro define %s", name);
472 if (macro->kind == macro_function_like)
476 fprintf_filtered (gdb_stdout, "(");
477 for (i = 0; i < macro->argc; ++i)
478 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
480 fprintf_filtered (gdb_stdout, ")");
482 fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
487 macro_list_command (char *exp, int from_tty)
489 macro_for_each (macro_user_macros, print_one_macro, NULL);
493 /* Initializing the `macrocmd' module. */
495 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
498 _initialize_macrocmd (void)
500 /* We introduce a new command prefix, `macro', under which we'll put
501 the various commands for working with preprocessor macros. */
502 add_prefix_cmd ("macro", class_info, macro_command,
503 _("Prefix for commands dealing with C preprocessor macros."),
504 ¯olist, "macro ", 0, &cmdlist);
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."),
510 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist);
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\
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\
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."),
523 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist);
525 add_info ("macro", info_macro_command,
526 _("Show the definition of MACRO, and it's source location.\n\
527 Usage: info macro [-a|-all] [--] MACRO\n\
529 -a, --all Output all definitions of MACRO in the current compilation\
531 -- Specify the end of arguments and the beginning of the MACRO."));
533 add_info ("macros", info_macros_command,
534 _("Show the definitions of all macros at LINESPEC, or the current \
536 Usage: info macros [LINESPEC]"));
538 add_cmd ("define", no_class, macro_define_command, _("\
539 Define a new C/C++ preprocessor macro.\n\
540 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
541 preprocessor directive of the form `#define DEFINITION' such that the\n\
542 definition is visible in all the inferior's source files.\n\
544 (gdb) macro define PI (3.1415926)\n\
545 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
548 add_cmd ("undef", no_class, macro_undef_command, _("\
549 Remove the definition of the C/C++ preprocessor macro with the given name."),
552 add_cmd ("list", no_class, macro_list_command,
553 _("List all the macros defined using the `macro define' command."),