static void
macro_expand_command (char *exp, int from_tty)
{
struct macro_scope *ms = NULL;
char *expanded = NULL;
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
make_cleanup (free_current_contents, &expanded);
/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
Then it would be easy to ask, "Hey, what did I just evaluate?" But
at the moment, the `print' commands don't save the last expression
evaluated, just its value. */
if (! exp || ! *exp)
error (_("You must follow the `macro expand' command with the"
" expression you\n"
"want to expand."));
ms = default_macro_scope ();
if (ms)
{
expanded = macro_expand (exp, standard_macro_lookup, ms);
fputs_filtered ("expands to: ", gdb_stdout);
fputs_filtered (expanded, gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
do_cleanups (cleanup_chain);
return;
}
static void
macro_expand_once_command (char *exp, int from_tty)
{
struct macro_scope *ms = NULL;
char *expanded = NULL;
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
make_cleanup (free_current_contents, &expanded);
/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
And it should set the once-expanded text as the new `last
expression'. That way, you could just hit return over and over and
see the expression expanded one level at a time. */
if (! exp || ! *exp)
error (_("You must follow the `macro expand-once' command with"
" the expression\n"
"you want to expand."));
ms = default_macro_scope ();
if (ms)
{
expanded = macro_expand_once (exp, standard_macro_lookup, ms);
fputs_filtered ("expands to: ", gdb_stdout);
fputs_filtered (expanded, gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
do_cleanups (cleanup_chain);
return;
}
static void
macro_expand_command (const char *exp, int from_tty)
{
gdb::unique_xmalloc_ptr<struct macro_scope> ms;
gdb::unique_xmalloc_ptr<char> expanded;
/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
Then it would be easy to ask, "Hey, what did I just evaluate?" But
at the moment, the `print' commands don't save the last expression
evaluated, just its value. */
if (! exp || ! *exp)
error (_("You must follow the `macro expand' command with the"
" expression you\n"
"want to expand."));
ms = default_macro_scope ();
if (ms)
{
expanded = macro_expand (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
}
static void
macro_expand_once_command (const char *exp, int from_tty)
{
gdb::unique_xmalloc_ptr<struct macro_scope> ms;
gdb::unique_xmalloc_ptr<char> expanded;
/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
And it should set the once-expanded text as the new `last
expression'. That way, you could just hit return over and over and
see the expression expanded one level at a time. */
if (! exp || ! *exp)
error (_("You must follow the `macro expand-once' command with"
" the expression\n"
"you want to expand."));
ms = default_macro_scope ();
if (ms)
{
expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
}
static int
c_preprocess_and_parse (void)
{
/* Set up a lookup function for the macro expander. */
struct macro_scope *scope = 0;
struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
if (expression_context_block)
scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
else
scope = default_macro_scope ();
if (scope)
{
expression_macro_lookup_func = standard_macro_lookup;
expression_macro_lookup_baton = (void *) scope;
}
else
{
expression_macro_lookup_func = null_macro_lookup;
expression_macro_lookup_baton = 0;
}
gdb_assert (! macro_original_text);
make_cleanup (scan_macro_cleanup, 0);
{
int result = c_parse ();
do_cleanups (back_to);
return result;
}
}
static void
info_macro_command (char *name, int from_tty)
{
struct macro_scope *ms = NULL;
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
struct macro_definition *d;
if (! name || ! *name)
error ("You must follow the `info macro' command with the name"
" of the macro\n"
"whose definition you want to see.");
ms = default_macro_scope ();
if (! ms)
error ("GDB has no preprocessor macro information for that code.");
d = macro_lookup_definition (ms->file, ms->line, name);
if (d)
{
int line;
struct macro_source_file *file
= macro_definition_location (ms->file, ms->line, name, &line);
fprintf_filtered (gdb_stdout, "Defined at ");
show_pp_source_pos (gdb_stdout, file, line);
fprintf_filtered (gdb_stdout, "#define %s", name);
if (d->kind == macro_function_like)
{
int i;
fputs_filtered ("(", gdb_stdout);
for (i = 0; i < d->argc; i++)
{
fputs_filtered (d->argv[i], gdb_stdout);
if (i + 1 < d->argc)
fputs_filtered (", ", gdb_stdout);
}
fputs_filtered (")", gdb_stdout);
}
fprintf_filtered (gdb_stdout, " %s\n", d->replacement);
}
else
{
fprintf_filtered (gdb_stdout,
"The symbol `%s' has no definition as a C/C++"
" preprocessor macro\n"
"at ", name);
show_pp_source_pos (gdb_stdout, ms->file, ms->line);
}
do_cleanups (cleanup_chain);
}
static void
write_macro_definitions (const struct block *block, CORE_ADDR pc,
struct ui_file *file)
{
struct macro_scope *scope;
if (block != NULL)
scope = sal_macro_scope (find_pc_line (pc, 0));
else
scope = default_macro_scope ();
if (scope == NULL)
scope = user_macro_scope ();
if (scope != NULL && scope->file != NULL && scope->file->table != NULL)
macro_for_each_in_scope (scope->file, scope->line, print_one_macro, file);
}
/* Implementation of the "info macros" command. */
static void
info_macros_command (const char *args, int from_tty)
{
gdb::unique_xmalloc_ptr<struct macro_scope> ms;
if (args == NULL)
ms = default_macro_scope ();
else
{
std::vector<symtab_and_line> sals
= decode_line_with_current_source (args, 0);
if (!sals.empty ())
ms = sal_macro_scope (sals[0]);
}
if (! ms || ! ms->file || ! ms->file->table)
macro_inform_no_debuginfo ();
else
macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
}
/* Implementation of the "info macros" command. */
static void
info_macros_command (char *args, int from_tty)
{
struct macro_scope *ms = NULL;
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
if (args == NULL)
ms = default_macro_scope ();
else
{
struct symtabs_and_lines sals =
decode_line_with_current_source (args, 0);
if (sals.nelts)
ms = sal_macro_scope (sals.sals[0]);
}
if (! ms || ! ms->file || ! ms->file->table)
macro_inform_no_debuginfo ();
else
macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL);
do_cleanups (cleanup_chain);
}
/* The implementation of the `info macro' command. */
static void
info_macro_command (char *args, int from_tty)
{
struct macro_scope *ms = NULL;
struct cleanup *cleanup_chain;
char *name;
int show_all_macros_named = 0;
char *arg_start = args;
int processing_args = 1;
while (processing_args
&& arg_start && *arg_start == '-' && *arg_start != '\0')
{
char *p = skip_to_space (arg_start);
if (strncmp (arg_start, "-a", p - arg_start) == 0
|| strncmp (arg_start, "-all", p - arg_start) == 0)
show_all_macros_named = 1;
else if (strncmp (arg_start, "--", p - arg_start) == 0)
/* Our macro support seems rather C specific but this would
seem necessary for languages allowing - in macro names.
e.g. Scheme's (defmacro ->foo () "bar\n") */
processing_args = 0;
else
{
/* Relies on modified 'args' not making it in to history */
*p = '\0';
error (_("Unrecognized option '%s' to info macro command. "
"Try \"help info macro\"."), arg_start);
}
arg_start = skip_spaces (p);
}
name = arg_start;
if (! name || ! *name)
error (_("You must follow the `info macro' command with the name"
" of the macro\n"
"whose definition you want to see."));
ms = default_macro_scope ();
cleanup_chain = make_cleanup (free_current_contents, &ms);
if (! ms)
macro_inform_no_debuginfo ();
else if (show_all_macros_named)
macro_for_each (ms->file->table, print_macro_callback, name);
else
{
struct macro_definition *d;
d = macro_lookup_definition (ms->file, ms->line, name);
if (d)
{
int line;
struct macro_source_file *file
= macro_definition_location (ms->file, ms->line, name, &line);
print_macro_definition (name, d, file, line);
}
else
{
fprintf_filtered (gdb_stdout,
"The symbol `%s' has no definition as a C/C++"
" preprocessor macro\n"
"at ", name);
show_pp_source_pos (gdb_stdout, ms->file, ms->line);
}
}
do_cleanups (cleanup_chain);
}
/* The implementation of the `info macro' command. */
static void
info_macro_command (const char *args, int from_tty)
{
gdb::unique_xmalloc_ptr<struct macro_scope> ms;
const char *name;
int show_all_macros_named = 0;
const char *arg_start = args;
int processing_args = 1;
while (processing_args
&& arg_start && *arg_start == '-' && *arg_start != '\0')
{
const char *p = skip_to_space (arg_start);
if (strncmp (arg_start, "-a", p - arg_start) == 0
|| strncmp (arg_start, "-all", p - arg_start) == 0)
show_all_macros_named = 1;
else if (strncmp (arg_start, "--", p - arg_start) == 0)
/* Our macro support seems rather C specific but this would
seem necessary for languages allowing - in macro names.
e.g. Scheme's (defmacro ->foo () "bar\n") */
processing_args = 0;
else
{
error (_("Unrecognized option '%.*s' to info macro command. "
"Try \"help info macro\"."),
int (p - arg_start), arg_start);
}
arg_start = skip_spaces (p);
}
name = arg_start;
if (! name || ! *name)
error (_("You must follow the `info macro' command with the name"
" of the macro\n"
"whose definition you want to see."));
ms = default_macro_scope ();
if (! ms)
macro_inform_no_debuginfo ();
else if (show_all_macros_named)
macro_for_each (ms->file->table, [&] (const char *macro_name,
const macro_definition *macro,
macro_source_file *source,
int line)
{
if (strcmp (name, macro_name) == 0)
print_macro_definition (name, macro, source, line);
});
else
{
struct macro_definition *d;
d = macro_lookup_definition (ms->file, ms->line, name);
if (d)
{
int line;
struct macro_source_file *file
= macro_definition_location (ms->file, ms->line, name, &line);
print_macro_definition (name, d, file, line);
}
else
{
fprintf_filtered (gdb_stdout,
"The symbol `%s' has no definition as a C/C++"
" preprocessor macro\n"
"at ", name);
show_pp_source_pos (gdb_stdout, ms->file, ms->line);
}
}
}