struct block_symbol *syms;
int nsyms;
struct symtab *symtab;
+ struct cleanup *old_chain;
+ const struct block *result = NULL;
if (raw_name[0] == '\'')
{
name = ada_encode (raw_name);
nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms);
+ old_chain = make_cleanup (xfree, syms);
+
if (context == NULL
&& (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK))
symtab = lookup_symtab (name);
symtab = NULL;
if (symtab != NULL)
- return BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
+ result = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
else if (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)
{
if (context == NULL)
{
if (nsyms > 1)
warning (_("Function name \"%s\" ambiguous here"), raw_name);
- return SYMBOL_BLOCK_VALUE (syms[0].symbol);
+ result = SYMBOL_BLOCK_VALUE (syms[0].symbol);
}
+
+ do_cleanups (old_chain);
+ return result;
}
static struct symbol*
int depth;
char *encoded_name;
int name_len;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
if (block == NULL)
block = expression_context_block;
encoded_name[tail_index] = '\0';
nsyms = ada_lookup_symbol_list (encoded_name, block,
VAR_DOMAIN, &syms);
+ make_cleanup (xfree, syms);
encoded_name[tail_index] = terminator;
/* A single symbol may rename a package or object. */
write_object_renaming (par_state, block, renaming, renaming_len,
renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
default:
internal_error (__FILE__, __LINE__,
struct type *field_type;
if (tail_index == name_len)
- return SYMBOL_TYPE (type_sym);
+ {
+ do_cleanups (old_chain);
+ return SYMBOL_TYPE (type_sym);
+ }
/* We have some extraneous characters after the type name.
If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
field_type
= get_symbol_field_type (type_sym, encoded_name + tail_index);
if (field_type != NULL)
- return field_type;
+ {
+ do_cleanups (old_chain);
+ return field_type;
+ }
else
error (_("Invalid attempt to select from type: \"%s\"."),
name0.ptr);
encoded_name);
if (type != NULL)
- return type;
+ {
+ do_cleanups (old_chain);
+ return type;
+ }
}
if (nsyms == 1)
{
write_var_from_sym (par_state, syms[0].block, syms[0].symbol);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
else if (nsyms == 0)
write_exp_msymbol (par_state, msym);
/* Maybe cause error here rather than later? FIXME? */
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
write_ambiguous_var (par_state, block, encoded_name,
tail_index);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
}
struct block_symbol *syms;
int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block,
VAR_DOMAIN, &syms);
+ struct cleanup *old_chain = make_cleanup (xfree, syms);
if (nsyms != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF)
write_exp_op_with_string (par_state, OP_NAME, name);
else
write_var_from_sym (par_state, syms[0].block, syms[0].symbol);
+
+ do_cleanups (old_chain);
}
else
if (write_var_or_type (par_state, NULL, name) != NULL)
ADA_KNOWN_AUXILIARY_FUNCTION_NAME_PATTERNS NULL
};
-/* Space for allocating results of ada_lookup_symbol_list. */
-static struct obstack symbol_list_obstack;
-
/* Maintenance-related settings for this module. */
static struct cmd_list_element *maint_set_ada_cmdlist;
struct value **argvec; /* Vector of operand types (alloca'ed). */
int nargs; /* Number of operands. */
int oplen;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
argvec = NULL;
nargs = 0;
(exp->elts[pc + 2].symbol),
exp->elts[pc + 1].block, VAR_DOMAIN,
&candidates);
+ make_cleanup (xfree, candidates);
if (n_candidates > 1)
{
(exp->elts[pc + 5].symbol),
exp->elts[pc + 4].block, VAR_DOMAIN,
&candidates);
+ make_cleanup (xfree, candidates);
+
if (n_candidates == 1)
i = 0;
else
ada_lookup_symbol_list (ada_decoded_op_name (op),
(struct block *) NULL, VAR_DOMAIN,
&candidates);
+ make_cleanup (xfree, candidates);
+
i = ada_resolve_function (candidates, n_candidates, argvec, nargs,
ada_decoded_op_name (op), NULL);
if (i < 0)
case OP_TYPE:
case OP_REGISTER:
+ do_cleanups (old_chain);
return NULL;
}
*pos = pc;
+ do_cleanups (old_chain);
if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
return evaluate_var_msym_value (EVAL_AVOID_SIDE_EFFECTS,
exp->elts[pc + 1].objfile,
/* Find symbols in DOMAIN matching LOOKUP_NAME, in BLOCK and, if FULL_SEARCH
is non-zero, enclosing scope and in global scopes, returning the number of
matches.
- Sets *RESULTS to point to a vector of (SYM,BLOCK) tuples,
+ Sets *RESULTS to point to a newly allocated vector of (SYM,BLOCK) tuples,
indicating the symbols found and the blocks and symbol tables (if
- any) in which they were found. This vector is transient---good only to
- the next call of ada_lookup_symbol_list.
+ any) in which they were found. This vector should be freed when
+ no longer useful.
When full_search is non-zero, any non-function/non-enumeral
symbol match within the nest of blocks whose innermost member is BLOCK,
{
int syms_from_global_search;
int ndefns;
+ int results_size;
+ auto_obstack obstack;
- obstack_free (&symbol_list_obstack, NULL);
- obstack_init (&symbol_list_obstack);
- ada_add_all_symbols (&symbol_list_obstack, block, lookup_name,
+ ada_add_all_symbols (&obstack, block, lookup_name,
domain, full_search, &syms_from_global_search);
- ndefns = num_defns_collected (&symbol_list_obstack);
- *results = defns_collected (&symbol_list_obstack, 1);
+ ndefns = num_defns_collected (&obstack);
+
+ results_size = obstack_object_size (&obstack);
+ *results = (struct block_symbol *) malloc (results_size);
+ memcpy (*results, defns_collected (&obstack, 1), results_size);
ndefns = remove_extra_symbols (*results, ndefns);
(*results)[0].symbol, (*results)[0].block);
ndefns = remove_irrelevant_renamings (*results, ndefns, block);
+
return ndefns;
}
/* Find symbols in DOMAIN matching NAME, in BLOCK and enclosing scope and
in global scopes, returning the number of matches, and setting *RESULTS
- to a vector of (SYM,BLOCK) tuples.
+ to a newly-allocated vector of (SYM,BLOCK) tuples. This newly-allocated
+ vector should be freed when no longer useful.
+
See ada_lookup_symbol_list_worker for further details. */
int
{
int ndefs, i;
struct block_symbol *results;
+ struct cleanup *old_chain;
ndefs = ada_lookup_symbol_list_worker (name, block, domain, &results, 0);
+ old_chain = make_cleanup (xfree, results);
+
for (i = 0; i < ndefs; ++i)
{
if (!callback (results[i].symbol))
break;
}
+
+ do_cleanups (old_chain);
}
/* The result is as for ada_lookup_symbol_list with FULL_SEARCH set
{
struct block_symbol *candidates;
int n_candidates;
+ struct cleanup *old_chain;
/* Since we already have an encoded name, wrap it in '<>' to force a
verbatim match. Otherwise, if the name happens to not look like
n_candidates = ada_lookup_symbol_list (verbatim.c_str (), block,
domain, &candidates);
+ old_chain = make_cleanup (xfree, candidates);
+
if (n_candidates == 0)
- return;
+ {
+ do_cleanups (old_chain);
+ return;
+ }
*info = candidates[0];
info->symbol = fixup_symbol_section (info->symbol, NULL);
+
+ do_cleanups (old_chain);
}
/* Return a symbol in DOMAIN matching NAME, in BLOCK0 and enclosing
int nsyms = ada_lookup_symbol_list_worker (lookup_name,
get_selected_block (0),
VAR_DOMAIN, &syms, 1);
+ struct cleanup *old_chain = make_cleanup (xfree, syms);
if (nsyms != 1)
{
+ do_cleanups (old_chain);
if (err_msg == NULL)
return 0;
else
error (("%s"), err_msg);
}
- return value_of_variable (syms[0].symbol, syms[0].block);
+ struct value *result = value_of_variable (syms[0].symbol, syms[0].block);
+ do_cleanups (old_chain);
+ return result;
}
/* Value of integer variable named NAME in the current environment.
DWARF attribute."),
NULL, NULL, &maint_set_ada_cmdlist, &maint_show_ada_cmdlist);
- obstack_init (&symbol_list_obstack);
-
decoded_names_store = htab_create_alloc
(256, htab_hash_string, (int (*)(const void *, const void *)) streq,
NULL, xcalloc, xfree);
projects / binutils-gdb.git / commitdiff