1 /* C preprocessor macro expansion commands for GDB.
2 Copyright (C) 2002-2019 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 (const 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 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
59 gdb::unique_xmalloc_ptr<char> expanded;
61 /* You know, when the user doesn't specify any expression, it would be
62 really cool if this defaulted to the last expression evaluated.
63 Then it would be easy to ask, "Hey, what did I just evaluate?" But
64 at the moment, the `print' commands don't save the last expression
65 evaluated, just its value. */
67 error (_("You must follow the `macro expand' command with the"
71 ms = default_macro_scope ();
74 expanded = macro_expand (exp, standard_macro_lookup, ms.get ());
75 fputs_filtered ("expands to: ", gdb_stdout);
76 fputs_filtered (expanded.get (), gdb_stdout);
77 fputs_filtered ("\n", gdb_stdout);
80 macro_inform_no_debuginfo ();
85 macro_expand_once_command (const char *exp, int from_tty)
87 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
88 gdb::unique_xmalloc_ptr<char> expanded;
90 /* You know, when the user doesn't specify any expression, it would be
91 really cool if this defaulted to the last expression evaluated.
92 And it should set the once-expanded text as the new `last
93 expression'. That way, you could just hit return over and over and
94 see the expression expanded one level at a time. */
96 error (_("You must follow the `macro expand-once' command with"
98 "you want to expand."));
100 ms = default_macro_scope ();
103 expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ());
104 fputs_filtered ("expands to: ", gdb_stdout);
105 fputs_filtered (expanded.get (), gdb_stdout);
106 fputs_filtered ("\n", gdb_stdout);
109 macro_inform_no_debuginfo ();
112 /* Outputs the include path of a macro starting at FILE and LINE to STREAM.
114 Care should be taken that this function does not cause any lookups into
115 the splay tree so that it can be safely used while iterating. */
117 show_pp_source_pos (struct ui_file *stream,
118 struct macro_source_file *file,
123 fullname = macro_source_fullname (file);
124 fprintf_filtered (stream, "%s:%d\n", fullname, line);
127 while (file->included_by)
129 fullname = macro_source_fullname (file->included_by);
130 fprintf_filtered (gdb_stdout, " included at %s:%d\n", fullname,
131 file->included_at_line);
133 file = file->included_by;
137 /* Outputs a macro for human consumption, detailing the include path
138 and macro definition. NAME is the name of the macro.
139 D the definition. FILE the start of the include path, and LINE the
142 Care should be taken that this function does not cause any lookups into
143 the splay tree so that it can be safely used while iterating. */
145 print_macro_definition (const char *name,
146 const struct macro_definition *d,
147 struct macro_source_file *file,
150 fprintf_filtered (gdb_stdout, "Defined at ");
151 show_pp_source_pos (gdb_stdout, file, line);
154 fprintf_filtered (gdb_stdout, "#define %s", name);
156 fprintf_filtered (gdb_stdout, "-D%s", name);
158 if (d->kind == macro_function_like)
162 fputs_filtered ("(", gdb_stdout);
163 for (i = 0; i < d->argc; i++)
165 fputs_filtered (d->argv[i], gdb_stdout);
167 fputs_filtered (", ", gdb_stdout);
169 fputs_filtered (")", gdb_stdout);
173 fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
175 fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
178 /* The implementation of the `info macro' command. */
180 info_macro_command (const char *args, int from_tty)
182 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
184 int show_all_macros_named = 0;
185 const char *arg_start = args;
186 int processing_args = 1;
188 while (processing_args
189 && arg_start && *arg_start == '-' && *arg_start != '\0')
191 const char *p = skip_to_space (arg_start);
193 if (strncmp (arg_start, "-a", p - arg_start) == 0
194 || strncmp (arg_start, "-all", p - arg_start) == 0)
195 show_all_macros_named = 1;
196 else if (strncmp (arg_start, "--", p - arg_start) == 0)
197 /* Our macro support seems rather C specific but this would
198 seem necessary for languages allowing - in macro names.
199 e.g. Scheme's (defmacro ->foo () "bar\n") */
202 report_unrecognized_option_error ("info macro", arg_start);
204 arg_start = skip_spaces (p);
209 if (! name || ! *name)
210 error (_("You must follow the `info macro' command with the name"
212 "whose definition you want to see."));
214 ms = default_macro_scope ();
217 macro_inform_no_debuginfo ();
218 else if (show_all_macros_named)
219 macro_for_each (ms->file->table, [&] (const char *macro_name,
220 const macro_definition *macro,
221 macro_source_file *source,
224 if (strcmp (name, macro_name) == 0)
225 print_macro_definition (name, macro, source, line);
229 struct macro_definition *d;
231 d = macro_lookup_definition (ms->file, ms->line, name);
235 struct macro_source_file *file
236 = macro_definition_location (ms->file, ms->line, name, &line);
238 print_macro_definition (name, d, file, line);
242 fprintf_filtered (gdb_stdout,
243 "The symbol `%s' has no definition as a C/C++"
244 " preprocessor macro\n"
246 show_pp_source_pos (gdb_stdout, ms->file, ms->line);
251 /* Implementation of the "info macros" command. */
253 info_macros_command (const char *args, int from_tty)
255 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
258 ms = default_macro_scope ();
261 std::vector<symtab_and_line> sals
262 = decode_line_with_current_source (args, 0);
265 ms = sal_macro_scope (sals[0]);
268 if (! ms || ! ms->file || ! ms->file->table)
269 macro_inform_no_debuginfo ();
271 macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
275 /* User-defined macros. */
278 skip_ws (const char **expp)
280 while (macro_is_whitespace (**expp))
284 /* Try to find the bounds of an identifier. If an identifier is
285 found, returns a newly allocated string; otherwise returns NULL.
286 EXPP is a pointer to an input string; it is updated to point to the
287 text following the identifier. If IS_PARAMETER is true, this
288 function will also allow "..." forms as used in varargs macro
291 static gdb::unique_xmalloc_ptr<char>
292 extract_identifier (const char **expp, int is_parameter)
295 const char *p = *expp;
298 if (is_parameter && startswith (p, "..."))
304 if (! *p || ! macro_is_identifier_nondigit (*p))
307 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
312 if (is_parameter && startswith (p, "..."))
316 result = (char *) xmalloc (len + 1);
317 memcpy (result, *expp, len);
320 return gdb::unique_xmalloc_ptr<char> (result);
323 struct temporary_macro_definition : public macro_definition
325 temporary_macro_definition ()
328 kind = macro_object_like;
331 replacement = nullptr;
334 ~temporary_macro_definition ()
338 for (i = 0; i < argc; ++i)
339 xfree ((char *) argv[i]);
340 xfree ((char *) argv);
341 /* Note that the 'replacement' field is not allocated. */
346 macro_define_command (const char *exp, int from_tty)
348 temporary_macro_definition new_macro;
351 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
354 gdb::unique_xmalloc_ptr<char> name = extract_identifier (&exp, 0);
356 error (_("Invalid macro name."));
359 /* Function-like macro. */
361 char **argv = XNEWVEC (char *, alloced);
363 new_macro.kind = macro_function_like;
365 new_macro.argv = (const char * const *) argv;
367 /* Skip the '(' and whitespace. */
375 if (new_macro.argc == alloced)
378 argv = (char **) xrealloc (argv, alloced * sizeof (char *));
379 /* Must update new_macro as well... */
380 new_macro.argv = (const char * const *) argv;
382 argv[new_macro.argc] = extract_identifier (&exp, 1).release ();
383 if (! argv[new_macro.argc])
384 error (_("Macro is missing an argument."));
387 for (i = new_macro.argc - 2; i >= 0; --i)
389 if (! strcmp (argv[i], argv[new_macro.argc - 1]))
390 error (_("Two macro arguments with identical names."));
399 else if (*exp != ')')
400 error (_("',' or ')' expected at end of macro arguments."));
402 /* Skip the closing paren. */
406 macro_define_function (macro_main (macro_user_macros), -1, name.get (),
407 new_macro.argc, (const char **) new_macro.argv,
413 macro_define_object (macro_main (macro_user_macros), -1, name.get (),
420 macro_undef_command (const char *exp, int from_tty)
423 error (_("usage: macro undef NAME"));
426 gdb::unique_xmalloc_ptr<char> name = extract_identifier (&exp, 0);
428 error (_("Invalid macro name."));
429 macro_undef (macro_main (macro_user_macros), -1, name.get ());
434 print_one_macro (const char *name, const struct macro_definition *macro,
435 struct macro_source_file *source, int line)
437 fprintf_filtered (gdb_stdout, "macro define %s", name);
438 if (macro->kind == macro_function_like)
442 fprintf_filtered (gdb_stdout, "(");
443 for (i = 0; i < macro->argc; ++i)
444 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
446 fprintf_filtered (gdb_stdout, ")");
448 fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
453 macro_list_command (const char *exp, int from_tty)
455 macro_for_each (macro_user_macros, print_one_macro);
458 /* Initializing the `macrocmd' module. */
461 _initialize_macrocmd (void)
463 /* We introduce a new command prefix, `macro', under which we'll put
464 the various commands for working with preprocessor macros. */
465 add_prefix_cmd ("macro", class_info, macro_command,
466 _("Prefix for commands dealing with C preprocessor macros."),
467 ¯olist, "macro ", 0, &cmdlist);
469 add_cmd ("expand", no_class, macro_expand_command, _("\
470 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
471 Show the expanded expression."),
473 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist);
474 add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
475 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
476 Show the expanded expression.\n\
478 This command differs from `macro expand' in that it only expands macro\n\
479 invocations that appear directly in EXPRESSION; if expanding a macro\n\
480 introduces further macro invocations, those are left unexpanded.\n\
482 `macro expand-once' helps you see how a particular macro expands,\n\
483 whereas `macro expand' shows you how all the macros involved in an\n\
484 expression work together to yield a pre-processed expression."),
486 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist);
488 add_info ("macro", info_macro_command,
489 _("Show the definition of MACRO, and it's source location.\n\
490 Usage: info macro [-a|-all] [--] MACRO\n\
492 -a, --all Output all definitions of MACRO in the current compilation\
494 -- Specify the end of arguments and the beginning of the MACRO."));
496 add_info ("macros", info_macros_command,
497 _("Show the definitions of all macros at LINESPEC, or the current \
499 Usage: info macros [LINESPEC]"));
501 add_cmd ("define", no_class, macro_define_command, _("\
502 Define a new C/C++ preprocessor macro.\n\
503 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
504 preprocessor directive of the form `#define DEFINITION' such that the\n\
505 definition is visible in all the inferior's source files.\n\
507 (gdb) macro define PI (3.1415926)\n\
508 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
511 add_cmd ("undef", no_class, macro_undef_command, _("\
512 Remove the definition of the C/C++ preprocessor macro with the given name."),
515 add_cmd ("list", no_class, macro_list_command,
516 _("List all the macros defined using the `macro define' command."),