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-style.h"
26 #include "cli/cli-utils.h"
32 /* The `macro' prefix command. */
34 static struct cmd_list_element *macrolist;
37 macro_command (const char *arg, int from_tty)
40 ("\"macro\" must be followed by the name of a macro command.\n");
41 help_list (macrolist, "macro ", all_commands, gdb_stdout);
46 /* Macro expansion commands. */
49 /* Prints an informational message regarding the lack of macro information. */
51 macro_inform_no_debuginfo (void)
53 puts_filtered ("GDB has no preprocessor macro information for that code.\n");
57 macro_expand_command (const char *exp, int from_tty)
59 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
60 gdb::unique_xmalloc_ptr<char> expanded;
62 /* You know, when the user doesn't specify any expression, it would be
63 really cool if this defaulted to the last expression evaluated.
64 Then it would be easy to ask, "Hey, what did I just evaluate?" But
65 at the moment, the `print' commands don't save the last expression
66 evaluated, just its value. */
68 error (_("You must follow the `macro expand' command with the"
72 ms = default_macro_scope ();
75 expanded = macro_expand (exp, standard_macro_lookup, ms.get ());
76 fputs_filtered ("expands to: ", gdb_stdout);
77 fputs_filtered (expanded.get (), gdb_stdout);
78 fputs_filtered ("\n", gdb_stdout);
81 macro_inform_no_debuginfo ();
86 macro_expand_once_command (const char *exp, int from_tty)
88 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
89 gdb::unique_xmalloc_ptr<char> expanded;
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. */
97 error (_("You must follow the `macro expand-once' command with"
99 "you want to expand."));
101 ms = default_macro_scope ();
104 expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ());
105 fputs_filtered ("expands to: ", gdb_stdout);
106 fputs_filtered (expanded.get (), gdb_stdout);
107 fputs_filtered ("\n", gdb_stdout);
110 macro_inform_no_debuginfo ();
113 /* Outputs the include path of a macro starting at FILE and LINE to STREAM.
115 Care should be taken that this function does not cause any lookups into
116 the splay tree so that it can be safely used while iterating. */
118 show_pp_source_pos (struct ui_file *stream,
119 struct macro_source_file *file,
124 fullname = macro_source_fullname (file);
125 fputs_styled (fullname, file_name_style.style (), stream);
126 fprintf_filtered (stream, ":%d\n", line);
129 while (file->included_by)
131 fullname = macro_source_fullname (file->included_by);
132 fputs_filtered (_(" included at "), stream);
133 fputs_styled (fullname, file_name_style.style (), stream);
134 fprintf_filtered (stream, ":%d\n", file->included_at_line);
136 file = file->included_by;
140 /* Outputs a macro for human consumption, detailing the include path
141 and macro definition. NAME is the name of the macro.
142 D the definition. FILE the start of the include path, and LINE the
145 Care should be taken that this function does not cause any lookups into
146 the splay tree so that it can be safely used while iterating. */
148 print_macro_definition (const char *name,
149 const struct macro_definition *d,
150 struct macro_source_file *file,
153 fprintf_filtered (gdb_stdout, "Defined at ");
154 show_pp_source_pos (gdb_stdout, file, line);
157 fprintf_filtered (gdb_stdout, "#define %s", name);
159 fprintf_filtered (gdb_stdout, "-D%s", name);
161 if (d->kind == macro_function_like)
165 fputs_filtered ("(", gdb_stdout);
166 for (i = 0; i < d->argc; i++)
168 fputs_filtered (d->argv[i], gdb_stdout);
170 fputs_filtered (", ", gdb_stdout);
172 fputs_filtered (")", gdb_stdout);
176 fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
178 fprintf_filtered (gdb_stdout, "=%s\n", d->replacement);
181 /* The implementation of the `info macro' command. */
183 info_macro_command (const char *args, int from_tty)
185 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
187 int show_all_macros_named = 0;
188 const char *arg_start = args;
189 int processing_args = 1;
191 while (processing_args
192 && arg_start && *arg_start == '-' && *arg_start != '\0')
194 const char *p = skip_to_space (arg_start);
196 if (strncmp (arg_start, "-a", p - arg_start) == 0
197 || strncmp (arg_start, "-all", p - arg_start) == 0)
198 show_all_macros_named = 1;
199 else if (strncmp (arg_start, "--", p - arg_start) == 0)
200 /* Our macro support seems rather C specific but this would
201 seem necessary for languages allowing - in macro names.
202 e.g. Scheme's (defmacro ->foo () "bar\n") */
205 report_unrecognized_option_error ("info macro", arg_start);
207 arg_start = skip_spaces (p);
212 if (! name || ! *name)
213 error (_("You must follow the `info macro' command with the name"
215 "whose definition you want to see."));
217 ms = default_macro_scope ();
220 macro_inform_no_debuginfo ();
221 else if (show_all_macros_named)
222 macro_for_each (ms->file->table, [&] (const char *macro_name,
223 const macro_definition *macro,
224 macro_source_file *source,
227 if (strcmp (name, macro_name) == 0)
228 print_macro_definition (name, macro, source, line);
232 struct macro_definition *d;
234 d = macro_lookup_definition (ms->file, ms->line, name);
238 struct macro_source_file *file
239 = macro_definition_location (ms->file, ms->line, name, &line);
241 print_macro_definition (name, d, file, line);
245 fprintf_filtered (gdb_stdout,
246 "The symbol `%s' has no definition as a C/C++"
247 " preprocessor macro\n"
249 show_pp_source_pos (gdb_stdout, ms->file, ms->line);
254 /* Implementation of the "info macros" command. */
256 info_macros_command (const char *args, int from_tty)
258 gdb::unique_xmalloc_ptr<struct macro_scope> ms;
261 ms = default_macro_scope ();
264 std::vector<symtab_and_line> sals
265 = decode_line_with_current_source (args, 0);
268 ms = sal_macro_scope (sals[0]);
271 if (! ms || ! ms->file || ! ms->file->table)
272 macro_inform_no_debuginfo ();
274 macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
278 /* User-defined macros. */
281 skip_ws (const char **expp)
283 while (macro_is_whitespace (**expp))
287 /* Try to find the bounds of an identifier. If an identifier is
288 found, returns a newly allocated string; otherwise returns NULL.
289 EXPP is a pointer to an input string; it is updated to point to the
290 text following the identifier. If IS_PARAMETER is true, this
291 function will also allow "..." forms as used in varargs macro
294 static gdb::unique_xmalloc_ptr<char>
295 extract_identifier (const char **expp, int is_parameter)
298 const char *p = *expp;
301 if (is_parameter && startswith (p, "..."))
307 if (! *p || ! macro_is_identifier_nondigit (*p))
310 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
315 if (is_parameter && startswith (p, "..."))
319 result = (char *) xmalloc (len + 1);
320 memcpy (result, *expp, len);
323 return gdb::unique_xmalloc_ptr<char> (result);
326 struct temporary_macro_definition : public macro_definition
328 temporary_macro_definition ()
331 kind = macro_object_like;
334 replacement = nullptr;
337 ~temporary_macro_definition ()
341 for (i = 0; i < argc; ++i)
342 xfree ((char *) argv[i]);
343 xfree ((char *) argv);
344 /* Note that the 'replacement' field is not allocated. */
349 macro_define_command (const char *exp, int from_tty)
351 temporary_macro_definition new_macro;
354 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
357 gdb::unique_xmalloc_ptr<char> name = extract_identifier (&exp, 0);
359 error (_("Invalid macro name."));
362 /* Function-like macro. */
364 char **argv = XNEWVEC (char *, alloced);
366 new_macro.kind = macro_function_like;
368 new_macro.argv = (const char * const *) argv;
370 /* Skip the '(' and whitespace. */
378 if (new_macro.argc == alloced)
381 argv = (char **) xrealloc (argv, alloced * sizeof (char *));
382 /* Must update new_macro as well... */
383 new_macro.argv = (const char * const *) argv;
385 argv[new_macro.argc] = extract_identifier (&exp, 1).release ();
386 if (! argv[new_macro.argc])
387 error (_("Macro is missing an argument."));
390 for (i = new_macro.argc - 2; i >= 0; --i)
392 if (! strcmp (argv[i], argv[new_macro.argc - 1]))
393 error (_("Two macro arguments with identical names."));
402 else if (*exp != ')')
403 error (_("',' or ')' expected at end of macro arguments."));
405 /* Skip the closing paren. */
409 macro_define_function (macro_main (macro_user_macros), -1, name.get (),
410 new_macro.argc, (const char **) new_macro.argv,
416 macro_define_object (macro_main (macro_user_macros), -1, name.get (),
423 macro_undef_command (const char *exp, int from_tty)
426 error (_("usage: macro undef NAME"));
429 gdb::unique_xmalloc_ptr<char> name = extract_identifier (&exp, 0);
431 error (_("Invalid macro name."));
432 macro_undef (macro_main (macro_user_macros), -1, name.get ());
437 print_one_macro (const char *name, const struct macro_definition *macro,
438 struct macro_source_file *source, int line)
440 fprintf_filtered (gdb_stdout, "macro define %s", name);
441 if (macro->kind == macro_function_like)
445 fprintf_filtered (gdb_stdout, "(");
446 for (i = 0; i < macro->argc; ++i)
447 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
449 fprintf_filtered (gdb_stdout, ")");
451 fprintf_filtered (gdb_stdout, " %s\n", macro->replacement);
456 macro_list_command (const char *exp, int from_tty)
458 macro_for_each (macro_user_macros, print_one_macro);
461 /* Initializing the `macrocmd' module. */
464 _initialize_macrocmd (void)
466 /* We introduce a new command prefix, `macro', under which we'll put
467 the various commands for working with preprocessor macros. */
468 add_prefix_cmd ("macro", class_info, macro_command,
469 _("Prefix for commands dealing with C preprocessor macros."),
470 ¯olist, "macro ", 0, &cmdlist);
472 add_cmd ("expand", no_class, macro_expand_command, _("\
473 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
474 Show the expanded expression."),
476 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist);
477 add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
478 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
479 Show the expanded expression.\n\
481 This command differs from `macro expand' in that it only expands macro\n\
482 invocations that appear directly in EXPRESSION; if expanding a macro\n\
483 introduces further macro invocations, those are left unexpanded.\n\
485 `macro expand-once' helps you see how a particular macro expands,\n\
486 whereas `macro expand' shows you how all the macros involved in an\n\
487 expression work together to yield a pre-processed expression."),
489 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist);
491 add_info ("macro", info_macro_command,
492 _("Show the definition of MACRO, and it's source location.\n\
493 Usage: info macro [-a|-all] [--] MACRO\n\
495 -a, --all Output all definitions of MACRO in the current compilation\
497 -- Specify the end of arguments and the beginning of the MACRO."));
499 add_info ("macros", info_macros_command,
500 _("Show the definitions of all macros at LINESPEC, or the current \
502 Usage: info macros [LINESPEC]"));
504 add_cmd ("define", no_class, macro_define_command, _("\
505 Define a new C/C++ preprocessor macro.\n\
506 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
507 preprocessor directive of the form `#define DEFINITION' such that the\n\
508 definition is visible in all the inferior's source files.\n\
510 (gdb) macro define PI (3.1415926)\n\
511 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
514 add_cmd ("undef", no_class, macro_undef_command, _("\
515 Remove the definition of the C/C++ preprocessor macro with the given name."),
518 add_cmd ("list", no_class, macro_list_command,
519 _("List all the macros defined using the `macro define' command."),