1 /* C preprocessor macro expansion commands for GDB.
2 Copyright (C) 2002, 2007, 2008 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"
27 #include "gdb_string.h"
30 /* The `macro' prefix command. */
32 static struct cmd_list_element *macrolist;
35 macro_command (char *arg, int from_tty)
38 ("\"macro\" must be followed by the name of a macro command.\n");
39 help_list (macrolist, "macro ", -1, gdb_stdout);
44 /* Macro expansion commands. */
48 macro_expand_command (char *exp, int from_tty)
50 struct macro_scope *ms = NULL;
51 char *expanded = NULL;
52 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
53 make_cleanup (free_current_contents, &expanded);
55 /* You know, when the user doesn't specify any expression, it would be
56 really cool if this defaulted to the last expression evaluated.
57 Then it would be easy to ask, "Hey, what did I just evaluate?" But
58 at the moment, the `print' commands don't save the last expression
59 evaluated, just its value. */
61 error (_("You must follow the `macro expand' command with the"
65 ms = default_macro_scope ();
68 expanded = macro_expand (exp, standard_macro_lookup, ms);
69 fputs_filtered ("expands to: ", gdb_stdout);
70 fputs_filtered (expanded, gdb_stdout);
71 fputs_filtered ("\n", gdb_stdout);
74 fputs_filtered ("GDB has no preprocessor macro information for "
78 do_cleanups (cleanup_chain);
84 macro_expand_once_command (char *exp, int from_tty)
86 struct macro_scope *ms = NULL;
87 char *expanded = NULL;
88 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
89 make_cleanup (free_current_contents, &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);
105 fputs_filtered ("expands to: ", gdb_stdout);
106 fputs_filtered (expanded, gdb_stdout);
107 fputs_filtered ("\n", gdb_stdout);
110 fputs_filtered ("GDB has no preprocessor macro information for "
114 do_cleanups (cleanup_chain);
120 show_pp_source_pos (struct ui_file *stream,
121 struct macro_source_file *file,
124 fprintf_filtered (stream, "%s:%d\n", file->filename, line);
126 while (file->included_by)
128 fprintf_filtered (gdb_stdout, " included at %s:%d\n",
129 file->included_by->filename,
130 file->included_at_line);
131 file = file->included_by;
137 info_macro_command (char *name, int from_tty)
139 struct macro_scope *ms = NULL;
140 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
141 struct macro_definition *d;
143 if (! name || ! *name)
144 error (_("You must follow the `info macro' command with the name"
146 "whose definition you want to see."));
148 ms = default_macro_scope ();
150 error (_("GDB has no preprocessor macro information for that code."));
152 d = macro_lookup_definition (ms->file, ms->line, name);
156 struct macro_source_file *file
157 = macro_definition_location (ms->file, ms->line, name, &line);
159 fprintf_filtered (gdb_stdout, "Defined at ");
160 show_pp_source_pos (gdb_stdout, file, line);
161 fprintf_filtered (gdb_stdout, "#define %s", name);
162 if (d->kind == macro_function_like)
166 fputs_filtered ("(", gdb_stdout);
167 for (i = 0; i < d->argc; i++)
169 fputs_filtered (d->argv[i], gdb_stdout);
171 fputs_filtered (", ", gdb_stdout);
173 fputs_filtered (")", gdb_stdout);
175 fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
179 fprintf_filtered (gdb_stdout,
180 "The symbol `%s' has no definition as a C/C++"
181 " preprocessor macro\n"
183 show_pp_source_pos (gdb_stdout, ms->file, ms->line);
186 do_cleanups (cleanup_chain);
191 /* User-defined macros. */
194 skip_ws (char **expp)
196 while (macro_is_whitespace (**expp))
201 extract_identifier (char **expp)
206 if (! *p || ! macro_is_identifier_nondigit (*p))
209 *p && (macro_is_identifier_nondigit (*p) || macro_is_digit (*p));
213 result = (char *) xmalloc (len + 1);
214 memcpy (result, *expp, len);
220 /* Helper function to clean up a temporarily-constructed macro object.
221 This assumes that the contents were all allocated with xmalloc. */
223 free_macro_definition_ptr (void *ptr)
226 struct macro_definition *loc = (struct macro_definition *) ptr;
227 for (i = 0; i < loc->argc; ++i)
228 xfree ((char *) loc->argv[i]);
229 xfree ((char *) loc->argv);
230 /* Note that the 'replacement' field is not allocated. */
234 macro_define_command (char *exp, int from_tty)
236 struct macro_definition new_macro;
238 struct cleanup *cleanup_chain;
241 error (_("usage: macro define NAME[(ARGUMENT-LIST)] [REPLACEMENT-LIST]"));
243 cleanup_chain = make_cleanup (free_macro_definition_ptr, &new_macro);
244 make_cleanup (free_current_contents, &name);
246 memset (&new_macro, 0, sizeof (struct macro_definition));
249 name = extract_identifier (&exp);
251 error (_("Invalid macro name."));
254 /* Function-like macro. */
256 char **argv = (char **) xmalloc (alloced * sizeof (char *));
258 new_macro.kind = macro_function_like;
260 new_macro.argv = (const char * const *) argv;
262 /* Skip the '(' and whitespace. */
270 if (new_macro.argc == alloced)
273 argv = (char **) xrealloc (argv, alloced * sizeof (char *));
274 /* Must update new_macro as well... */
275 new_macro.argv = (const char * const *) argv;
277 argv[new_macro.argc] = extract_identifier (&exp);
278 if (! argv[new_macro.argc])
279 error (_("Macro is missing an argument."));
282 for (i = new_macro.argc - 2; i >= 0; --i)
284 if (! strcmp (argv[i], argv[new_macro.argc - 1]))
285 error (_("Two macro arguments with identical names."));
294 else if (*exp != ')')
295 error (_("',' or ')' expected at end of macro arguments."));
297 /* Skip the closing paren. */
300 macro_define_function (macro_main (macro_user_macros), -1, name,
301 new_macro.argc, (const char **) new_macro.argv,
305 macro_define_object (macro_main (macro_user_macros), -1, name, exp);
307 do_cleanups (cleanup_chain);
312 macro_undef_command (char *exp, int from_tty)
317 error (_("usage: macro undef NAME"));
320 name = extract_identifier (&exp);
322 error (_("Invalid macro name."));
323 macro_undef (macro_main (macro_user_macros), -1, name);
329 print_one_macro (const char *name, const struct macro_definition *macro)
331 fprintf_filtered (gdb_stdout, "macro define %s", name);
332 if (macro->kind == macro_function_like)
335 fprintf_filtered (gdb_stdout, "(");
336 for (i = 0; i < macro->argc; ++i)
337 fprintf_filtered (gdb_stdout, "%s%s", (i > 0) ? ", " : "",
339 fprintf_filtered (gdb_stdout, ")");
341 /* Note that we don't need a leading space here -- "macro define"
343 fprintf_filtered (gdb_stdout, "%s\n", macro->replacement);
348 macro_list_command (char *exp, int from_tty)
350 macro_for_each (macro_user_macros, print_one_macro);
355 /* Initializing the `macrocmd' module. */
357 extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
360 _initialize_macrocmd (void)
362 struct cmd_list_element *c;
364 /* We introduce a new command prefix, `macro', under which we'll put
365 the various commands for working with preprocessor macros. */
366 add_prefix_cmd ("macro", class_info, macro_command,
367 _("Prefix for commands dealing with C preprocessor macros."),
368 ¯olist, "macro ", 0, &cmdlist);
370 add_cmd ("expand", no_class, macro_expand_command, _("\
371 Fully expand any C/C++ preprocessor macro invocations in EXPRESSION.\n\
372 Show the expanded expression."),
374 add_alias_cmd ("exp", "expand", no_class, 1, ¯olist);
375 add_cmd ("expand-once", no_class, macro_expand_once_command, _("\
376 Expand C/C++ preprocessor macro invocations appearing directly in EXPRESSION.\n\
377 Show the expanded expression.\n\
379 This command differs from `macro expand' in that it only expands macro\n\
380 invocations that appear directly in EXPRESSION; if expanding a macro\n\
381 introduces further macro invocations, those are left unexpanded.\n\
383 `macro expand-once' helps you see how a particular macro expands,\n\
384 whereas `macro expand' shows you how all the macros involved in an\n\
385 expression work together to yield a pre-processed expression."),
387 add_alias_cmd ("exp1", "expand-once", no_class, 1, ¯olist);
389 add_cmd ("macro", no_class, info_macro_command,
390 _("Show the definition of MACRO, and its source location."),
393 add_cmd ("define", no_class, macro_define_command, _("\
394 Define a new C/C++ preprocessor macro.\n\
395 The GDB command `macro define DEFINITION' is equivalent to placing a\n\
396 preprocessor directive of the form `#define DEFINITION' such that the\n\
397 definition is visible in all the inferior's source files.\n\
399 (gdb) macro define PI (3.1415926)\n\
400 (gdb) macro define MIN(x,y) ((x) < (y) ? (x) : (y))"),
403 add_cmd ("undef", no_class, macro_undef_command, _("\
404 Remove the definition of the C/C++ preprocessor macro with the given name."),
407 add_cmd ("list", no_class, macro_list_command,
408 _("List all the macros defined using the `macro define' command."),