+2018-02-08 Tom Tromey <tom@tromey.com>
+
+ * symtab.c (default_collect_symbol_completion_matches_break_on):
+ Use unique_xmalloc_ptr.
+ * macroscope.h: (sal_macro_scope, user_macro_scope)
+ (default_macro_scope): Return unique_xmalloc_ptr.
+ * macroscope.c (sal_macro_scope, user_macro_scope)
+ (default_macro_scope): Return unique_xmalloc_ptr.
+ * macroexp.h (macro_expand, macro_expand_once): Return
+ unique_xmalloc_ptr.
+ * macroexp.c (macro_expand, macro_expand_once): Return
+ unique_xmalloc_ptr.
+ * macrocmd.c (macro_expand_command, macro_expand_once_command)
+ (info_macro_command, info_macros_command): Use
+ unique_xmalloc_ptr.
+ * compile/compile-c-support.c (write_macro_definitions): Use
+ unique_xmalloc_ptr.
+ * c-exp.y (c_parse): Use unique_xmalloc_ptr.
+
2018-02-07 Simon Marchi <simon.marchi@ericsson.com>
* value.c (value_static_field): Assign field type instead of
gdb_assert (par_state != NULL);
pstate = par_state;
- /* Note that parsing (within yyparse) freely installs cleanups
- assuming they'll be run here (below). */
-
- back_to = make_cleanup (free_current_contents, &expression_macro_scope);
-
- /* Set up the scope for macro expansion. */
- expression_macro_scope = NULL;
+ gdb::unique_xmalloc_ptr<struct macro_scope> macro_scope;
if (expression_context_block)
- expression_macro_scope
- = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+ macro_scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
else
- expression_macro_scope = default_macro_scope ();
- if (! expression_macro_scope)
- expression_macro_scope = user_macro_scope ();
+ macro_scope = default_macro_scope ();
+ if (! macro_scope)
+ macro_scope = user_macro_scope ();
+
+ scoped_restore restore_macro_scope
+ = make_scoped_restore (&expression_macro_scope, macro_scope.get ());
/* Initialize macro expansion code. */
obstack_init (&expansion_obstack);
gdb_assert (! macro_original_text);
- make_cleanup (scan_macro_cleanup, 0);
+ /* Note that parsing (within yyparse) freely installs cleanups
+ assuming they'll be run here (below). */
+ back_to = make_cleanup (scan_macro_cleanup, 0);
scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
parser_debug);
write_macro_definitions (const struct block *block, CORE_ADDR pc,
struct ui_file *file)
{
- struct macro_scope *scope;
+ gdb::unique_xmalloc_ptr<struct macro_scope> scope;
if (block != NULL)
scope = sal_macro_scope (find_pc_line (pc, 0));
static void
macro_expand_command (const 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);
+ 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.
ms = default_macro_scope ();
if (ms)
{
- expanded = macro_expand (exp, standard_macro_lookup, ms);
+ expanded = macro_expand (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
- fputs_filtered (expanded, gdb_stdout);
+ fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
-
- do_cleanups (cleanup_chain);
- return;
}
static void
macro_expand_once_command (const 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);
+ 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.
ms = default_macro_scope ();
if (ms)
{
- expanded = macro_expand_once (exp, standard_macro_lookup, ms);
+ expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
- fputs_filtered (expanded, gdb_stdout);
+ fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
-
- do_cleanups (cleanup_chain);
- return;
}
/* Outputs the include path of a macro starting at FILE and LINE to STREAM.
static void
info_macro_command (const char *args, int from_tty)
{
- struct macro_scope *ms = NULL;
- struct cleanup *cleanup_chain;
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
const char *name;
int show_all_macros_named = 0;
const char *arg_start = args;
"whose definition you want to see."));
ms = default_macro_scope ();
- cleanup_chain = make_cleanup (free_current_contents, &ms);
if (! ms)
macro_inform_no_debuginfo ();
show_pp_source_pos (gdb_stdout, ms->file, ms->line);
}
}
-
- do_cleanups (cleanup_chain);
}
/* Implementation of the "info macros" command. */
static void
info_macros_command (const char *args, int from_tty)
{
- struct macro_scope *ms = NULL;
- struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
if (args == NULL)
ms = default_macro_scope ();
macro_inform_no_debuginfo ();
else
macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
-
- do_cleanups (cleanup_chain);
}
\f
}
-char *
+gdb::unique_xmalloc_ptr<char>
macro_expand (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton)
appendc (&dest, '\0');
discard_cleanups (back_to);
- return dest.text;
+ return gdb::unique_xmalloc_ptr<char> (dest.text);
}
-char *
+gdb::unique_xmalloc_ptr<char>
macro_expand_once (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton)
preprocessor definitions. SOURCE is a null-terminated string. The
result is a null-terminated string, allocated using xmalloc; it is
the caller's responsibility to free it. */
-char *macro_expand (const char *source,
- macro_lookup_ftype *lookup_func,
- void *lookup_func_baton);
+gdb::unique_xmalloc_ptr<char> macro_expand (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);
/* Expand all preprocessor macro references that appear explicitly in
SOURCE is a null-terminated string. The result is a
null-terminated string, allocated using xmalloc; it is the caller's
responsibility to free it. */
-char *macro_expand_once (const char *source,
- macro_lookup_ftype *lookup_func,
- void *lookup_func_baton);
+gdb::unique_xmalloc_ptr<char> macro_expand_once (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);
/* If the null-terminated string pointed to by *LEXPTR begins with a
struct macro_table *macro_user_macros;
-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
sal_macro_scope (struct symtab_and_line sal)
{
struct macro_source_file *main_file, *inclusion;
- struct macro_scope *ms;
struct compunit_symtab *cust;
if (sal.symtab == NULL)
if (COMPUNIT_MACRO_TABLE (cust) == NULL)
return NULL;
- ms = XNEW (struct macro_scope);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms (XNEW (struct macro_scope));
main_file = macro_main (COMPUNIT_MACRO_TABLE (cust));
inclusion = macro_lookup_inclusion (main_file, sal.symtab->filename);
}
-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
user_macro_scope (void)
{
- struct macro_scope *ms;
-
- ms = XNEW (struct macro_scope);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms (XNEW (struct macro_scope));
ms->file = macro_main (macro_user_macros);
ms->line = -1;
return ms;
}
-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
default_macro_scope (void)
{
struct symtab_and_line sal;
- struct macro_scope *ms;
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
struct frame_info *frame;
CORE_ADDR pc;
/* Return a `struct macro_scope' object corresponding to the symtab
and line given in SAL. If we have no macro information for that
location, or if SAL's pc is zero, return zero. */
-struct macro_scope *sal_macro_scope (struct symtab_and_line sal);
+gdb::unique_xmalloc_ptr<struct macro_scope> sal_macro_scope
+ (struct symtab_and_line sal);
/* Return a `struct macro_scope' object representing just the
- user-defined macros. The result is allocated using xmalloc; the
- caller is responsible for freeing it. */
-struct macro_scope *user_macro_scope (void);
+ user-defined macros. */
+gdb::unique_xmalloc_ptr<struct macro_scope> user_macro_scope (void);
/* Return a `struct macro_scope' object describing the scope the `macro
expand' and `macro expand-once' commands should use for looking up
its PC; otherwise, this is the last listing position.
If we have no macro information for the current location, return
- the user macro scope.
-
- The object returned is allocated using xmalloc; the caller is
- responsible for freeing it. */
-struct macro_scope *default_macro_scope (void);
+ the user macro scope. */
+gdb::unique_xmalloc_ptr<struct macro_scope> default_macro_scope (void);
/* Look up the definition of the macro named NAME in scope at the source
if (current_language->la_macro_expansion == macro_expansion_c
&& code == TYPE_CODE_UNDEF)
{
- struct macro_scope *scope;
+ gdb::unique_xmalloc_ptr<struct macro_scope> scope;
/* This adds a macro's name to the current completion list. */
auto add_macro_name = [&] (const char *macro_name,
completion time. */
scope = default_macro_scope ();
if (scope)
- {
- macro_for_each_in_scope (scope->file, scope->line,
- add_macro_name);
- xfree (scope);
- }
+ macro_for_each_in_scope (scope->file, scope->line,
+ add_macro_name);
/* User-defined macros are always visible. */
macro_for_each (macro_user_macros, add_macro_name);
projects / deliverable / binutils-gdb.git / commitdiff
