1 /* C preprocessor macro expansion commands for GDB.
2 Copyright (C) 2002-2020 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 expansion commands. */
40 /* Prints an informational message regarding the lack of macro information. */
42 macro_inform_no_debuginfo (void)
44 puts_filtered ("GDB has no preprocessor macro information for that code.\n");
48 macro_expand_command (const char *exp
, int from_tty
)
50 gdb::unique_xmalloc_ptr
<struct macro_scope
> ms
;
51 gdb::unique_xmalloc_ptr
<char> expanded
;
53 /* You know, when the user doesn't specify any expression, it would be
54 really cool if this defaulted to the last expression evaluated.
55 Then it would be easy to ask, "Hey, what did I just evaluate?" But
56 at the moment, the `print' commands don't save the last expression
57 evaluated, just its value. */
59 error (_("You must follow the `macro expand' command with the"
63 ms
= default_macro_scope ();
66 expanded
= macro_expand (exp
, standard_macro_lookup
, ms
.get ());
67 fputs_filtered ("expands to: ", gdb_stdout
);
68 fputs_filtered (expanded
.get (), gdb_stdout
);
69 fputs_filtered ("\n", gdb_stdout
);
72 macro_inform_no_debuginfo ();
77 macro_expand_once_command (const char *exp
, int from_tty
)
79 gdb::unique_xmalloc_ptr
<struct macro_scope
> ms
;
80 gdb::unique_xmalloc_ptr
<char> expanded
;
82 /* You know, when the user doesn't specify any expression, it would be
83 really cool if this defaulted to the last expression evaluated.
84 And it should set the once-expanded text as the new `last
85 expression'. That way, you could just hit return over and over and
86 see the expression expanded one level at a time. */
88 error (_("You must follow the `macro expand-once' command with"
90 "you want to expand."));
92 ms
= default_macro_scope ();
95 expanded
= macro_expand_once (exp
, standard_macro_lookup
, ms
.get ());
96 fputs_filtered ("expands to: ", gdb_stdout
);
97 fputs_filtered (expanded
.get (), gdb_stdout
);
98 fputs_filtered ("\n", gdb_stdout
);
101 macro_inform_no_debuginfo ();
104 /* Outputs the include path of a macro starting at FILE and LINE to STREAM.
106 Care should be taken that this function does not cause any lookups into
107 the splay tree so that it can be safely used while iterating. */
109 show_pp_source_pos (struct ui_file
*stream
,
110 struct macro_source_file
*file
,
113 std::string fullname
= macro_source_fullname (file
);
114 fprintf_filtered (stream
, "%ps:%d\n",
115 styled_string (file_name_style
.style (),
119 while (file
->included_by
)
121 fullname
= macro_source_fullname (file
->included_by
);
122 fputs_filtered (_(" included at "), stream
);
123 fputs_styled (fullname
.c_str (), file_name_style
.style (), stream
);
124 fprintf_filtered (stream
, ":%d\n", file
->included_at_line
);
125 file
= file
->included_by
;
129 /* Outputs a macro for human consumption, detailing the include path
130 and macro definition. NAME is the name of the macro.
131 D the definition. FILE the start of the include path, and LINE the
134 Care should be taken that this function does not cause any lookups into
135 the splay tree so that it can be safely used while iterating. */
137 print_macro_definition (const char *name
,
138 const struct macro_definition
*d
,
139 struct macro_source_file
*file
,
142 fprintf_filtered (gdb_stdout
, "Defined at ");
143 show_pp_source_pos (gdb_stdout
, file
, line
);
146 fprintf_filtered (gdb_stdout
, "#define %s", name
);
148 fprintf_filtered (gdb_stdout
, "-D%s", name
);
150 if (d
->kind
== macro_function_like
)
154 fputs_filtered ("(", gdb_stdout
);
155 for (i
= 0; i
< d
->argc
; i
++)
157 fputs_filtered (d
->argv
[i
], gdb_stdout
);
159 fputs_filtered (", ", gdb_stdout
);
161 fputs_filtered (")", gdb_stdout
);
165 fprintf_filtered (gdb_stdout
, " %s\n", d
->replacement
);
167 fprintf_filtered (gdb_stdout
, "=%s\n", d
->replacement
);
170 /* The implementation of the `info macro' command. */
172 info_macro_command (const char *args
, int from_tty
)
174 gdb::unique_xmalloc_ptr
<struct macro_scope
> ms
;
176 int show_all_macros_named
= 0;
177 const char *arg_start
= args
;
178 int processing_args
= 1;
180 while (processing_args
181 && arg_start
&& *arg_start
== '-' && *arg_start
!= '\0')
183 const char *p
= skip_to_space (arg_start
);
185 if (strncmp (arg_start
, "-a", p
- arg_start
) == 0
186 || strncmp (arg_start
, "-all", p
- arg_start
) == 0)
187 show_all_macros_named
= 1;
188 else if (strncmp (arg_start
, "--", p
- arg_start
) == 0)
189 /* Our macro support seems rather C specific but this would
190 seem necessary for languages allowing - in macro names.
191 e.g. Scheme's (defmacro ->foo () "bar\n") */
194 report_unrecognized_option_error ("info macro", arg_start
);
196 arg_start
= skip_spaces (p
);
201 if (! name
|| ! *name
)
202 error (_("You must follow the `info macro' command with the name"
204 "whose definition you want to see."));
206 ms
= default_macro_scope ();
209 macro_inform_no_debuginfo ();
210 else if (show_all_macros_named
)
211 macro_for_each (ms
->file
->table
, [&] (const char *macro_name
,
212 const macro_definition
*macro
,
213 macro_source_file
*source
,
216 if (strcmp (name
, macro_name
) == 0)
217 print_macro_definition (name
, macro
, source
, line
);
221 struct macro_definition
*d
;
223 d
= macro_lookup_definition (ms
->file
, ms
->line
, name
);
227 struct macro_source_file
*file
228 = macro_definition_location (ms
->file
, ms
->line
, name
, &line
);
230 print_macro_definition (name
, d
, file
, line
);
234 fprintf_filtered (gdb_stdout
,
235 "The symbol `%s' has no definition as a C/C++"
236 " preprocessor macro\n"
238 show_pp_source_pos (gdb_stdout
, ms
->file
, ms
->line
);
243 /* Implementation of the "info macros" command. */
245 info_macros_command (const char *args
, int from_tty
)
247 gdb::unique_xmalloc_ptr
<struct macro_scope
> ms
;
250 ms
= default_macro_scope ();
253 std::vector
<symtab_and_line
> sals
254 = decode_line_with_current_source (args
, 0);
257 ms
= sal_macro_scope (sals
[0]);
260 if (! ms
|| ! ms
->file
|| ! ms
->file
->table
)
261 macro_inform_no_debuginfo ();
263 macro_for_each_in_scope (ms
->file
, ms
->line
, print_macro_definition
);
267 /* User-defined macros. */
270 skip_ws (const char **expp
)
272 while (macro_is_whitespace (**expp
))
276 /* Try to find the bounds of an identifier. If an identifier is
277 found, returns a newly allocated string; otherwise returns NULL.
278 EXPP is a pointer to an input string; it is updated to point to the
279 text following the identifier. If IS_PARAMETER is true, this
280 function will also allow "..." forms as used in varargs macro
283 static gdb::unique_xmalloc_ptr
<char>
284 extract_identifier (const char **expp
, int is_parameter
)
287 const char *p
= *expp
;
290 if (is_parameter
&& startswith (p
, "..."))
296 if (! *p
|| ! macro_is_identifier_nondigit (*p
))
299 *p
&& (macro_is_identifier_nondigit (*p
) || macro_is_digit (*p
));
304 if (is_parameter
&& startswith (p
, "..."))
308 result
= (char *) xmalloc (len
+ 1);
309 memcpy (result
, *expp
, len
);
312 return gdb::unique_xmalloc_ptr
<char> (result
);
315 struct temporary_macro_definition
: public macro_definition
317 temporary_macro_definition ()
320 kind
= macro_object_like
;
323 replacement
= nullptr;
326 ~temporary_macro_definition ()
330 for (i
= 0; i
< argc
; ++i
)
331 xfree ((char *) argv
[i
]);
332 xfree ((char *) argv
);
333 /* Note that the 'replacement' field is not allocated. */
338 macro_define_command (const char *exp
, int from_tty
)
340 temporary_macro_definition new_macro
;
343 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
346 gdb::unique_xmalloc_ptr
<char> name
= extract_identifier (&exp
, 0);
348 error (_("Invalid macro name."));
351 /* Function-like macro. */
353 char **argv
= XNEWVEC (char *, alloced
);
355 new_macro
.kind
= macro_function_like
;
357 new_macro
.argv
= (const char * const *) argv
;
359 /* Skip the '(' and whitespace. */
367 if (new_macro
.argc
== alloced
)
370 argv
= (char **) xrealloc (argv
, alloced
* sizeof (char *));
371 /* Must update new_macro as well... */
372 new_macro
.argv
= (const char * const *) argv
;
374 argv
[new_macro
.argc
] = extract_identifier (&exp
, 1).release ();
375 if (! argv
[new_macro
.argc
])
376 error (_("Macro is missing an argument."));
379 for (i
= new_macro
.argc
- 2; i
>= 0; --i
)
381 if (! strcmp (argv
[i
], argv
[new_macro
.argc
- 1]))
382 error (_("Two macro arguments with identical names."));
391 else if (*exp
!= ')')
392 error (_("',' or ')' expected at end of macro arguments."));
394 /* Skip the closing paren. */
398 macro_define_function (macro_main (macro_user_macros
), -1, name
.get (),
399 new_macro
.argc
, (const char **) new_macro
.argv
,
405 macro_define_object (macro_main (macro_user_macros
), -1, name
.get (),
412 macro_undef_command (const char *exp
, int from_tty
)
415 error (_("usage: macro undef NAME"));
418 gdb::unique_xmalloc_ptr
<char> name
= extract_identifier (&exp
, 0);
420 error (_("Invalid macro name."));
421 macro_undef (macro_main (macro_user_macros
), -1, name
.get ());
426 print_one_macro (const char *name
, const struct macro_definition
*macro
,
427 struct macro_source_file
*source
, int line
)
429 fprintf_filtered (gdb_stdout
, "macro define %s", name
);
430 if (macro
->kind
== macro_function_like
)
434 fprintf_filtered (gdb_stdout
, "(");
435 for (i
= 0; i
< macro
->argc
; ++i
)
436 fprintf_filtered (gdb_stdout
, "%s%s", (i
> 0) ? ", " : "",
438 fprintf_filtered (gdb_stdout
, ")");
440 fprintf_filtered (gdb_stdout
, " %s\n", macro
->replacement
);
445 macro_list_command (const char *exp
, int from_tty
)
447 macro_for_each (macro_user_macros
, print_one_macro
);
450 /* Initializing the `macrocmd' module. */
452 void _initialize_macrocmd ();
454 _initialize_macrocmd ()
456 /* We introduce a new command prefix, `macro', under which we'll put
457 the various commands for working with preprocessor macros. */
458 add_basic_prefix_cmd ("macro", class_info
,
459 _("Prefix for commands dealing with C preprocessor macros."),
460 ¯olist
, "macro ", 0, &cmdlist
);
462 add_cmd ("expand", no_class
, macro_expand_command
, _("\
463 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
464 Show the expanded expression."),
466 add_alias_cmd ("exp", "expand", no_class
, 1, ¯olist
);
467 add_cmd ("expand-once", no_class
, macro_expand_once_command
, _("\
468 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
469 Show the expanded expression.\n\
471 This command differs from `macro expand' in that it only expands macro\n\
472 invocations that appear directly in EXPRESSION; if expanding a macro\n\
473 introduces further macro invocations, those are left unexpanded.\n\
475 `macro expand-once' helps you see how a particular macro expands,\n\
476 whereas `macro expand' shows you how all the macros involved in an\n\
477 expression work together to yield a pre-processed expression."),
479 add_alias_cmd ("exp1", "expand-once", no_class
, 1, ¯olist
);
481 add_info ("macro", info_macro_command
,
482 _("Show the definition of MACRO, and it's source location.\n\
483 Usage: info macro [-a|-all] [--] MACRO\n\
485 -a, --all Output all definitions of MACRO in the current compilation\
487 -- Specify the end of arguments and the beginning of the MACRO."));
489 add_info ("macros", info_macros_command
,
490 _("Show the definitions of all macros at LINESPEC, or the current \
492 Usage: info macros [LINESPEC]"));
494 add_cmd ("define", no_class
, macro_define_command
, _("\
495 Define a new C/C++ preprocessor macro.\n\
496 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
497 preprocessor directive of the form `#define DEFINITION' such that the\n\
498 definition is visible in all the inferior's source files.\n\
500 (gdb) macro define PI (3.1415926)\n\
501 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
504 add_cmd ("undef", no_class
, macro_undef_command
, _("\
505 Remove the definition of the C/C++ preprocessor macro with the given name."),
508 add_cmd ("list", no_class
, macro_list_command
,
509 _("List all the macros defined using the `macro define' command."),