if (result.symbol)
{
- struct type *t = result.symbol->type;
+ struct type *t = result.symbol->type ();
/* I'm not really sure that type of this can ever
be typedefed; just be safe. */
block_find_non_opaque_type, NULL);
if (sym == NULL)
error_in_psymtab_expansion (block_index, name, cust);
- gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
- return SYMBOL_TYPE (sym);
+ gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+ return sym->type ();
}
/* Subroutine of basic_lookup_transparent_type to simplify it.
block_find_non_opaque_type, NULL);
if (sym != NULL)
{
- gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
- return SYMBOL_TYPE (sym);
+ gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+ return sym->type ();
}
}
b = BLOCK_SUPERBLOCK (b);
}
if (function_block != NULL
- && SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
+ && BLOCK_FUNCTION (function_block)->line () != 0)
{
- sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
+ sal->line = BLOCK_FUNCTION (function_block)->line ();
sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
}
}
sym->natural_name ());
}
- sym_type = SYMBOL_TYPE (sym);
+ sym_type = sym->type ();
if (sym_type == NULL)
return false;
members. We only want to skip enums
here. */
&& !(sym->aclass () == LOC_CONST
- && (SYMBOL_TYPE (sym)->code ()
+ && (sym->type ()->code ()
== TYPE_CODE_ENUM))
&& (!treg.has_value ()
|| treg_matches_sym_type_name (*treg, sym)))
&& sym->domain () != MODULE_DOMAIN)
|| (kind == MODULES_DOMAIN
&& sym->domain () == MODULE_DOMAIN
- && SYMBOL_LINE (sym) != 0))))
+ && sym->line () != 0))))
{
if (result_set->size () < m_max_search_results)
{
For the struct printing case below, things are worse, we force
printing of the ";" in this function, which is going to be wrong
for languages that don't require a ";" between statements. */
- if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
- typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
+ if (sym->type ()->code () == TYPE_CODE_TYPEDEF)
+ typedef_print (sym->type (), sym, &tmp_stream);
else
- type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+ type_print (sym->type (), "", &tmp_stream, -1);
str += tmp_stream.string ();
}
/* variable, func, or typedef-that-is-c++-class. */
{
string_file tmp_stream;
- type_print (SYMBOL_TYPE (sym),
+ type_print (sym->type (),
(sym->aclass () == LOC_TYPEDEF
? "" : sym->print_name ()),
&tmp_stream, 0);
s_filename));
}
- if (SYMBOL_LINE (sym) != 0)
- printf_filtered ("%d:\t", SYMBOL_LINE (sym));
+ if (sym->line () != 0)
+ printf_filtered ("%d:\t", sym->line ());
else
puts_filtered ("\t");
}
{
if (sym->aclass () == LOC_TYPEDEF)
{
- struct type *t = SYMBOL_TYPE (sym);
+ struct type *t = sym->type ();
enum type_code c = t->code ();
int j;
bool
symbol_is_function_or_method (symbol *sym)
{
- switch (SYMBOL_TYPE (sym)->code ())
+ switch (sym->type ()->code ())
{
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (code == TYPE_CODE_UNDEF
|| (sym->domain () == STRUCT_DOMAIN
- && SYMBOL_TYPE (sym)->code () == code))
+ && sym->type ()->code () == code))
completion_list_add_symbol (tracker, sym,
lookup_name,
text, word);
sym_text, word);
}
else if (sym->domain () == STRUCT_DOMAIN
- && SYMBOL_TYPE (sym)->code () == code)
+ && sym->type ()->code () == code)
completion_list_add_symbol (tracker, sym, lookup_name,
sym_text, word);
}