(lookup_symbol): Likewise.
* symtab.c (lookup_symbol_in_language): Remove SYMTAB parameter.
(lookup_symbol): Likewise.
(search_symbols): Update.
* linespec.c (find_methods, collect_methods): Update.
(add_matching_methods, add_constructors): Update.
(decode_compound, decode_dollar, decode_variable): Update.
(lookup_prefix_sym): Update.
(symbol_found): Remove SYM_SYMTAB parameter.
Use SYMBOL_SYMTAB (sym) instead.
* gdbtypes.c (lookup_typename): Update.
(lookup_struct, lookup_union, lookup_enum): Update.
(lookup_template_type): Update.
(check_typedef): Update.
* language.c (lang_bool_type): Update.
* mdebugread.c (parse_procedure): Update.
* mi/mi-cmd-stack.c (list_args_or_locals): Update.
* parse.c (write_dollar_variable): Update.
* printcmd.c (address_info): Update.
* source.c (select_source_symtab): Update.
* stack.c (print_frame_args, print_frame_arg_vars): Update.
* valops.c (find_function_in_inferior): Update.
(value_struct_elt_for_reference): Update.
* value.c (value_static_field, value_fn_field): Update.
* alpha-mdebug-tdep.c (find_proc_desc): Update.
* arm-tdep.c (arm_skip_prologue): Update.
* mt-tdep.c (mt_skip_prologue): Update.
* xstormy16-tdep.c (xstormy16_skip_prologue): Update.
* ada-lang.h (struct ada_symbol_info): Remove SYMTAB member.
* ada-lang.c (ada_add_block_symbols): Remove SYMTAB parameter.
(add_defn_to_vec): Likewise.
(ada_add_block_symbols): Likewise.
(lookup_cached_symbol, cache_symbol): Likewise.
(standard_lookup): Update.
(ada_lookup_symbol_list): Update.
* c-valprint.c (c_val_print): Update.
* cp-support.c (cp_lookup_rtti_type): Update.
* jv-lang.c (java_lookup_class, get_java_object_type): Update.
* objc-lang.c (lookup_struct_typedef, find_imps): Update.
* p-valprint.c (pascal_val_print): Update.
* scm-lang.c (scm_lookup_name): Update.
* c-exp.y: Update.
* f-exp.y: Update.
* jv-exp.y: Update.
* m2-exp.y: Update.
* objc-exp.y: Update.
* p-exp.y: Update.
+2008-05-19 Ulrich Weigand <uweigand@de.ibm.com>
+
+ * symtab.h (lookup_symbol_in_language): Remove SYMTAB parameter.
+ (lookup_symbol): Likewise.
+ * symtab.c (lookup_symbol_in_language): Remove SYMTAB parameter.
+ (lookup_symbol): Likewise.
+ (search_symbols): Update.
+
+ * linespec.c (find_methods, collect_methods): Update.
+ (add_matching_methods, add_constructors): Update.
+ (decode_compound, decode_dollar, decode_variable): Update.
+ (lookup_prefix_sym): Update.
+
+ (symbol_found): Remove SYM_SYMTAB parameter.
+ Use SYMBOL_SYMTAB (sym) instead.
+
+ * gdbtypes.c (lookup_typename): Update.
+ (lookup_struct, lookup_union, lookup_enum): Update.
+ (lookup_template_type): Update.
+ (check_typedef): Update.
+ * language.c (lang_bool_type): Update.
+ * mdebugread.c (parse_procedure): Update.
+ * mi/mi-cmd-stack.c (list_args_or_locals): Update.
+ * parse.c (write_dollar_variable): Update.
+ * printcmd.c (address_info): Update.
+ * source.c (select_source_symtab): Update.
+ * stack.c (print_frame_args, print_frame_arg_vars): Update.
+ * valops.c (find_function_in_inferior): Update.
+ (value_struct_elt_for_reference): Update.
+ * value.c (value_static_field, value_fn_field): Update.
+
+ * alpha-mdebug-tdep.c (find_proc_desc): Update.
+ * arm-tdep.c (arm_skip_prologue): Update.
+ * mt-tdep.c (mt_skip_prologue): Update.
+ * xstormy16-tdep.c (xstormy16_skip_prologue): Update.
+
+ * ada-lang.h (struct ada_symbol_info): Remove SYMTAB member.
+ * ada-lang.c (ada_add_block_symbols): Remove SYMTAB parameter.
+ (add_defn_to_vec): Likewise.
+ (ada_add_block_symbols): Likewise.
+ (lookup_cached_symbol, cache_symbol): Likewise.
+ (standard_lookup): Update.
+ (ada_lookup_symbol_list): Update.
+
+ * c-valprint.c (c_val_print): Update.
+ * cp-support.c (cp_lookup_rtti_type): Update.
+ * jv-lang.c (java_lookup_class, get_java_object_type): Update.
+ * objc-lang.c (lookup_struct_typedef, find_imps): Update.
+ * p-valprint.c (pascal_val_print): Update.
+ * scm-lang.c (scm_lookup_name): Update.
+
+ * c-exp.y: Update.
+ * f-exp.y: Update.
+ * jv-exp.y: Update.
+ * m2-exp.y: Update.
+ * objc-exp.y: Update.
+ * p-exp.y: Update.
+
2008-05-19 Ulrich Weigand <uweigand@de.ibm.com>
* language.h (struct language_defn): Remove SYMTAB parameter from
static void ada_add_block_symbols (struct obstack *,
struct block *, const char *,
- domain_enum, struct objfile *,
- struct symtab *, int);
+ domain_enum, struct objfile *, int);
static int is_nonfunction (struct ada_symbol_info *, int);
static void add_defn_to_vec (struct obstack *, struct symbol *,
- struct block *, struct symtab *);
+ struct block *);
static int num_defns_collected (struct obstack *);
static int
lookup_cached_symbol (const char *name, domain_enum namespace,
- struct symbol **sym, struct block **block,
- struct symtab **symtab)
+ struct symbol **sym, struct block **block)
{
return 0;
}
static void
cache_symbol (const char *name, domain_enum namespace, struct symbol *sym,
- struct block *block, struct symtab *symtab)
+ struct block *block)
{
}
\f
domain_enum domain)
{
struct symbol *sym;
- struct symtab *symtab;
- if (lookup_cached_symbol (name, domain, &sym, NULL, NULL))
+ if (lookup_cached_symbol (name, domain, &sym, NULL))
return sym;
- sym =
- lookup_symbol_in_language (name, block, domain, language_c, 0, &symtab);
- cache_symbol (name, domain, sym, block_found, symtab);
+ sym = lookup_symbol_in_language (name, block, domain, language_c, 0);
+ cache_symbol (name, domain, sym, block_found);
return sym;
}
static void
add_defn_to_vec (struct obstack *obstackp,
struct symbol *sym,
- struct block *block, struct symtab *symtab)
+ struct block *block)
{
int i;
size_t tmp;
{
prevDefns[i].sym = sym;
prevDefns[i].block = block;
- prevDefns[i].symtab = symtab;
return;
}
}
info.sym = sym;
info.block = block;
- info.symtab = symtab;
obstack_grow (obstackp, &info, sizeof (struct ada_symbol_info));
}
}
{
block_depth += 1;
ada_add_block_symbols (&symbol_list_obstack, block, name,
- namespace, NULL, NULL, wild_match);
+ namespace, NULL, wild_match);
/* If we found a non-function match, assume that's the one. */
if (is_nonfunction (defns_collected (&symbol_list_obstack, 0),
goto done;
cacheIfUnique = 1;
- if (lookup_cached_symbol (name0, namespace, &sym, &block, &s))
+ if (lookup_cached_symbol (name0, namespace, &sym, &block))
{
if (sym != NULL)
- add_defn_to_vec (&symbol_list_obstack, sym, block, s);
+ add_defn_to_vec (&symbol_list_obstack, sym, block);
goto done;
}
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block, name, namespace,
- objfile, s, wild_match);
+ objfile, wild_match);
}
if (namespace == VAR_DOMAIN)
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block,
SYMBOL_LINKAGE_NAME (msymbol),
- namespace, objfile, s, wild_match);
+ namespace, objfile, wild_match);
if (num_defns_collected (&symbol_list_obstack) == ndefns0)
{
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block,
SYMBOL_LINKAGE_NAME (msymbol),
- namespace, objfile, s,
+ namespace, objfile,
wild_match);
}
}
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block, name,
- namespace, objfile, s, wild_match);
+ namespace, objfile, wild_match);
}
}
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block, name, namespace,
- objfile, s, wild_match);
+ objfile, wild_match);
}
ALL_PSYMTABS (objfile, ps)
continue;
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
ada_add_block_symbols (&symbol_list_obstack, block, name,
- namespace, objfile, s, wild_match);
+ namespace, objfile, wild_match);
}
}
}
ndefns = remove_extra_symbols (*results, ndefns);
if (ndefns == 0)
- cache_symbol (name0, namespace, NULL, NULL, NULL);
+ cache_symbol (name0, namespace, NULL, NULL);
if (ndefns == 1 && cacheIfUnique)
- cache_symbol (name0, namespace, (*results)[0].sym, (*results)[0].block,
- (*results)[0].symtab);
+ cache_symbol (name0, namespace, (*results)[0].sym, (*results)[0].block);
ndefns = remove_irrelevant_renamings (*results, ndefns, block0);
ada_add_block_symbols (struct obstack *obstackp,
struct block *block, const char *name,
domain_enum domain, struct objfile *objfile,
- struct symtab *symtab, int wild)
+ int wild)
{
struct dict_iterator iter;
int name_len = strlen (name);
found_sym = 1;
add_defn_to_vec (obstackp,
fixup_symbol_section (sym, objfile),
- block, symtab);
+ block);
break;
}
}
found_sym = 1;
add_defn_to_vec (obstackp,
fixup_symbol_section (sym, objfile),
- block, symtab);
+ block);
break;
}
}
{
add_defn_to_vec (obstackp,
fixup_symbol_section (arg_sym, objfile),
- block, symtab);
+ block);
}
if (!wild)
found_sym = 1;
add_defn_to_vec (obstackp,
fixup_symbol_section (sym, objfile),
- block, symtab);
+ block);
break;
}
}
{
add_defn_to_vec (obstackp,
fixup_symbol_section (arg_sym, objfile),
- block, symtab);
+ block);
}
}
}
OP_ADA_LAST
};
-/* A triple, (symbol, block, symtab), representing one instance of a
+/* A tuple, (symbol, block), representing one instance of a
* symbol-lookup operation. */
struct ada_symbol_info {
struct symbol* sym;
struct block* block;
- struct symtab* symtab;
};
/* Denotes a type of renaming symbol (see ada_parse_renaming). */
symbol reading. */
sym = NULL;
else
- sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0, NULL);
+ sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0);
}
if (sym)
struct symbol *sym;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
/* Don't use this trick for assembly source files. */
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name ($3));
variable: block COLONCOLON name
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN,
current_language->la_language == language_cplus
- ? &is_a_field_of_this : (int *) NULL,
- (struct symtab **) NULL);
+ ? &is_a_field_of_this : (int *) NULL);
/* Call lookup_symtab, not lookup_partial_symtab, in case there are
no psymtabs (coff, xcoff, or some future change to blow away the
psymtabs once once symbols are read). */
if (msymbol != NULL)
wsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), block,
- VAR_DOMAIN, &is_this_fld, NULL);
+ VAR_DOMAIN, &is_this_fld);
if (wsym)
{
struct symbol * rtti_sym;
struct type * rtti_type;
- rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL, NULL);
+ rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
if (rtti_sym == NULL)
{
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN,
current_language->la_language == language_cplus
- ? &is_a_field_of_this : NULL,
- NULL);
+ ? &is_a_field_of_this : NULL);
if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
{
yylval.tsym.type = SYMBOL_TYPE (sym);
struct symbol *sym;
struct type *tmp;
- sym = lookup_symbol (name, block, VAR_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
{
tmp = language_lookup_primitive_type_by_name (current_language,
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
if (sym == NULL)
{
struct symbol *sym;
struct type *t;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
if (sym == NULL)
error (_("No union type named %s."), name);
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
if (sym == NULL)
{
error (_("No enum type named %s."), name);
strcat (nam, TYPE_NAME (type));
strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
- sym = lookup_symbol (nam, block, VAR_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
if (sym == NULL)
{
stub_noname_complaint ();
return type;
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
if (sym)
TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
else /* TYPE_CODE_UNDEF */
stub_noname_complaint ();
return type;
}
- sym = lookup_symbol (name, 0, STRUCT_DOMAIN,
- 0, (struct symtab **) NULL);
+ sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
if (sym)
{
/* Same as above for opaque types, we can replace the stub
int is_a_field_of_this = 0;
struct symbol *sym;
sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
- &is_a_field_of_this, (struct symtab **) NULL);
+ &is_a_field_of_this);
if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
{
if (symbol_read_needs_frame (sym))
java_lookup_class (char *name)
{
struct symbol *sym;
- sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN,
- (int *) 0, (struct symtab **) NULL);
+ sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
if (sym != NULL)
return SYMBOL_TYPE (sym);
#if 0
if (java_object_type == NULL)
{
struct symbol *sym;
- sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN,
- (int *) 0, (struct symtab **) NULL);
+ sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
if (sym == NULL)
error (_("cannot find java.lang.Object"));
java_object_type = SYMBOL_TYPE (sym);
switch (current_language->la_language)
{
case language_fortran:
- sym = lookup_symbol ("logical", NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol ("logical", NULL, VAR_DOMAIN, NULL);
if (sym)
{
type = SYMBOL_TYPE (sym);
case language_pascal:
case language_ada:
if (current_language->la_language==language_cplus)
- {sym = lookup_symbol ("bool", NULL, VAR_DOMAIN, NULL, NULL);}
+ {sym = lookup_symbol ("bool", NULL, VAR_DOMAIN, NULL);}
else
- {sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);}
+ {sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL);}
if (sym)
{
type = SYMBOL_TYPE (sym);
}
return builtin_type_bool;
case language_java:
- sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL);
if (sym)
{
type = SYMBOL_TYPE (sym);
char ***canonical,
char *copy,
struct symbol *sym,
- struct symtab *file_symtab,
- struct symtab *sym_symtab);
+ struct symtab *file_symtab);
static struct
symtabs_and_lines minsym_found (int funfirstline,
the class, then the loop can't do any good. */
if (class_name
&& (lookup_symbol_in_language (class_name, (struct block *) NULL,
- STRUCT_DOMAIN, language, (int *) NULL,
- (struct symtab **) NULL)))
+ STRUCT_DOMAIN, language, (int *) NULL)))
{
int method_counter;
int name_len = strlen (name);
sym_arr[i1] = lookup_symbol_in_language (phys_name,
NULL, VAR_DOMAIN,
language,
- (int *) NULL,
- (struct symtab **) NULL);
+ (int *) NULL);
if (sym_arr[i1])
i1++;
else
sym_arr[i1] = lookup_symbol_in_language (phys_name,
NULL, VAR_DOMAIN,
language,
- (int *) NULL,
- (struct symtab **) NULL);
+ (int *) NULL);
if (sym_arr[i1])
i1++;
}
copy = (char *) alloca (p - *argptr + 1);
memcpy (copy, *argptr, p - *argptr);
copy[p - *argptr] = '\000';
- sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0, &sym_symtab);
+ sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
if (sym)
{
*argptr = (*p == '\'') ? p + 1 : p;
- return symbol_found (funfirstline, canonical, copy, sym,
- NULL, sym_symtab);
+ return symbol_found (funfirstline, canonical, copy, sym, NULL);
}
/* Otherwise fall out from here and go to file/line spec
processing, etc. */
char *saved_arg2 = *argptr;
char *temp_end;
struct symbol *sym;
- /* The symtab that SYM was found in. */
- struct symtab *sym_symtab;
char *copy;
struct symbol *sym_class;
struct symbol **sym_arr;
*argptr = (*p == '\'') ? p + 1 : p;
/* Look up entire name */
- sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0, &sym_symtab);
+ sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
if (sym)
- return symbol_found (funfirstline, canonical, copy, sym,
- NULL, sym_symtab);
+ return symbol_found (funfirstline, canonical, copy, sym, NULL);
/* Couldn't find any interpretation as classes/namespaces, so give
up. The quotes are important if copy is empty. */
/* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
argptr->"inA::fun" */
- return lookup_symbol (copy, 0, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ return lookup_symbol (copy, 0, STRUCT_DOMAIN, 0);
}
/* This finds the method COPY in the class whose type is T and whose
sym_arr[i1] =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, f_index),
- NULL, VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ NULL, VAR_DOMAIN, (int *) NULL);
if (sym_arr[i1])
i1++;
}
struct symtab_and_line val;
char *p;
struct symbol *sym;
- /* The symtab that SYM was found in. */
- struct symtab *sym_symtab;
struct minimal_symbol *msymbol;
p = (copy[1] == '$') ? copy + 2 : copy + 1;
convenience variable. */
/* Look up entire name as a symbol first. */
- sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0, &sym_symtab);
+ sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
file_symtab = (struct symtab *) NULL;
need_canonical = 1;
/* Symbol was found --> jump to normal symbol processing. */
if (sym)
- return symbol_found (funfirstline, canonical, copy, sym,
- NULL, sym_symtab);
+ return symbol_found (funfirstline, canonical, copy, sym, NULL);
/* If symbol was not found, look in minimal symbol tables. */
msymbol = lookup_minimal_symbol (copy, NULL, NULL);
struct symtab *file_symtab, int *not_found_ptr)
{
struct symbol *sym;
- /* The symtab that SYM was found in. */
- struct symtab *sym_symtab;
struct minimal_symbol *msymbol;
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab),
STATIC_BLOCK)
: get_selected_block (0)),
- VAR_DOMAIN, 0, &sym_symtab);
+ VAR_DOMAIN, 0);
if (sym != NULL)
- return symbol_found (funfirstline, canonical, copy, sym,
- file_symtab, sym_symtab);
+ return symbol_found (funfirstline, canonical, copy, sym, file_symtab);
msymbol = lookup_minimal_symbol (copy, NULL, NULL);
static struct symtabs_and_lines
symbol_found (int funfirstline, char ***canonical, char *copy,
- struct symbol *sym, struct symtab *file_symtab,
- struct symtab *sym_symtab)
+ struct symbol *sym, struct symtab *file_symtab)
{
struct symtabs_and_lines values;
function. */
if (file_symtab == 0)
{
- struct blockvector *bv = BLOCKVECTOR (sym_symtab);
+ struct blockvector *bv = BLOCKVECTOR (SYMBOL_SYMTAB (sym));
struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
if (lookup_block_symbol (b, copy, NULL, VAR_DOMAIN) != NULL)
build_canonical_line_spec (values.sals, copy, canonical);
xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
memset (&values.sals[0], 0, sizeof (values.sals[0]));
- values.sals[0].symtab = sym_symtab;
+ values.sals[0].symtab = SYMBOL_SYMTAB (sym);
values.sals[0].line = SYMBOL_LINE (sym);
return values;
}
fblock : BLOCKNAME
{ struct symbol *sym
= lookup_symbol (copy_name ($1), expression_context_block,
- VAR_DOMAIN, 0, NULL);
+ VAR_DOMAIN, 0);
$$ = sym;}
;
fblock : block COLONCOLON BLOCKNAME
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, 0, NULL);
+ VAR_DOMAIN, 0);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name ($3));
variable: block COLONCOLON NAME
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, 0, NULL);
+ VAR_DOMAIN, 0);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
sym = lookup_symbol (copy_name ($1),
expression_context_block,
VAR_DOMAIN,
- &is_a_field_of_this,
- NULL);
+ &is_a_field_of_this);
if (sym)
{
if (symbol_read_needs_frame (sym))
if (lookup_partial_symtab (tmp))
return BLOCKNAME;
- sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN, 0, NULL);
+ sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0);
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
return BLOCKNAME;
if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
the same name exists, lookup_symbol will eventually read in the symtab
for the global function and clobber cur_fdr. */
FDR *save_cur_fdr = cur_fdr;
- s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL);
+ s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
cur_fdr = save_cur_fdr;
#else
s = mylookup_symbol
if (!locals)
sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym),
block, VAR_DOMAIN,
- (int *) NULL,
- (struct symtab **) NULL);
+ (int *) NULL);
else
sym2 = sym;
switch (values)
struct symbol *sym;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
/* Don't use this trick for assembly source files. */
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name ($3));
variable: block COLONCOLON name
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
sym = lookup_symbol (tmp, expression_context_block,
VAR_DOMAIN,
- need_this,
- (struct symtab **) NULL);
+ need_this);
/* Call lookup_symtab, not lookup_partial_symtab, in case there
are no psymtabs (coff, xcoff, or some future change to blow
away the psymtabs once symbols are read). */
tmp1[p - namestart] = '\0';
cur_sym = lookup_symbol (ncopy,
expression_context_block,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (cur_sym)
{
if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
{
struct symbol *sym;
- sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0,
- (struct symtab **) NULL);
+ sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
if (sym == NULL)
{
if (tmp == NULL)
return NULL;
- sym = lookup_symbol (selector, block, VAR_DOMAIN, 0, NULL);
+ sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
if (sym != NULL)
{
if (syms)
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name ($3));
variable: block COLONCOLON name
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
static const char this_name[] = "this";
if (lookup_symbol (this_name, expression_context_block,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL))
+ VAR_DOMAIN, (int *) NULL))
{
free (uptokstart);
return THIS;
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN,
- &is_a_field_of_this,
- (struct symtab **) NULL);
+ VAR_DOMAIN, &is_a_field_of_this);
/* second chance uppercased (as Free Pascal does). */
if (!sym && !is_a_field_of_this && !is_a_field)
{
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN,
- &is_a_field_of_this,
- (struct symtab **) NULL);
+ VAR_DOMAIN, &is_a_field_of_this);
if (sym || is_a_field_of_this || is_a_field)
for (i = 0; i <= namelen; i++)
{
sym = NULL;
else
sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN,
- &is_a_field_of_this,
- (struct symtab **) NULL);
+ VAR_DOMAIN, &is_a_field_of_this);
if (sym || is_a_field_of_this || is_a_field)
for (i = 0; i <= namelen; i++)
{
memcpy (tmp1, namestart, p - namestart);
tmp1[p - namestart] = '\0';
cur_sym = lookup_symbol (ncopy, expression_context_block,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (cur_sym)
{
if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
if (msymbol != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block,
- VAR_DOMAIN, &is_this_fld, NULL);
+ VAR_DOMAIN, &is_this_fld);
if (wsym)
{
have names beginning with $ or $$. Check for those, first. */
sym = lookup_symbol (copy_name (str), (struct block *) NULL,
- VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
error (_("Argument required."));
sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
- &is_a_field_of_this, (struct symtab **) NULL);
+ &is_a_field_of_this);
if (sym == NULL)
{
if (is_a_field_of_this)
if (in_eval_c ()
&& (sym = lookup_symbol ("env",
expression_context_block,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL)) != NULL)
+ VAR_DOMAIN, (int *) NULL)) != NULL)
args[2] = value_of_variable (sym, expression_context_block);
else
/* FIXME in this case, we should try lookup_symbol first */
sym = lookup_symbol (str,
expression_context_block,
- VAR_DOMAIN, (int *) NULL,
- (struct symtab **) NULL);
+ VAR_DOMAIN, (int *) NULL);
if (sym)
return value_of_variable (sym, NULL);
error (_("No symbol \"%s\" in current context."), str);
/* Make the default place to list be the function `main'
if one exists. */
- if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0, NULL))
+ if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0))
{
sals = decode_line_spec (main_name (), 1);
sal = sals.sals[0];
{
struct symbol *nsym;
nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
- b, VAR_DOMAIN, NULL, NULL);
+ b, VAR_DOMAIN, NULL);
gdb_assert (nsym != NULL);
if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
{
are not combined in symbol-reading. */
sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
- b, VAR_DOMAIN, NULL, NULL);
+ b, VAR_DOMAIN, NULL);
print_variable_value (sym2, frame, stream);
fprintf_filtered (stream, "\n");
break;
struct symbol *
lookup_symbol_in_language (const char *name, const struct block *block,
const domain_enum domain, enum language lang,
- int *is_a_field_of_this,
- struct symtab **symtab)
+ int *is_a_field_of_this)
{
char *demangled_name = NULL;
const char *modified_name = NULL;
if (needtofreename)
xfree (demangled_name);
- /* Override the returned symtab with the symbol's specific one. */
- if (returnval != NULL && symtab != NULL)
- *symtab = SYMBOL_SYMTAB (returnval);
-
return returnval;
}
struct symbol *
lookup_symbol (const char *name, const struct block *block,
- domain_enum domain, int *is_a_field_of_this,
- struct symtab **symtab)
+ domain_enum domain, int *is_a_field_of_this)
{
return lookup_symbol_in_language (name, block, domain,
current_language->la_language,
- is_a_field_of_this, symtab);
+ is_a_field_of_this);
}
/* Behave like lookup_symbol except that NAME is the natural name
if (kind == FUNCTIONS_DOMAIN
|| lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
(struct block *) NULL,
- VAR_DOMAIN,
- 0, (struct symtab **) NULL)
+ VAR_DOMAIN, 0)
== NULL)
found_misc = 1;
}
{
/* Variables/Absolutes: Look up by name */
if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
- (struct block *) NULL, VAR_DOMAIN,
- 0, (struct symtab **) NULL) == NULL)
+ (struct block *) NULL, VAR_DOMAIN, 0)
+ == NULL)
{
/* match */
psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
const struct block *,
const domain_enum,
enum language,
- int *,
- struct symtab **);
+ int *);
/* lookup a symbol by name (optional block, optional symtab)
in the current language */
extern struct symbol *lookup_symbol (const char *, const struct block *,
- const domain_enum, int *,
- struct symtab **);
+ const domain_enum, int *);
/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do. */
find_function_in_inferior (const char *name)
{
struct symbol *sym;
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL);
+ sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
if (sym != NULL)
{
if (SYMBOL_CLASS (sym) != LOC_BLOCK)
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0, NULL);
+ 0, VAR_DOMAIN, 0);
if (s == NULL)
return NULL;
{
struct symbol *s =
lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_DOMAIN, 0, NULL);
+ 0, VAR_DOMAIN, 0);
if (s == NULL)
return NULL;
else
{
char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL);
+ struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
if (sym == NULL)
{
/* With some compilers, e.g. HP aCC, static data members are reported
struct symbol *sym;
struct minimal_symbol *msym;
- sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL);
+ sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0);
if (sym != NULL)
{
msym = NULL;
return plg_end;
/* Found a function. */
- sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
+ sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
/* Don't use line number debug info for assembly source files. */
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
{
projects / deliverable / binutils-gdb.git / commitdiff
