struct fn_field *method = &f[signature_id];
const char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id);
const char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id);
- const char *newname = TYPE_NAME (type);
+ const char *newname = type->name ();
/* Does the form of physname indicate that it is the full mangled name
of a constructor (not just the args)? */
{
const struct language_defn *lang = language_def (gsymbol->language ());
- language_sniff_from_mangled_name (lang, mangled, &demangled);
+ lang->sniff_from_mangled_name (mangled, &demangled);
return demangled;
}
enum language l = (enum language) i;
const struct language_defn *lang = language_def (l);
- if (language_sniff_from_mangled_name (lang, mangled, &demangled))
+ if (lang->sniff_from_mangled_name (mangled, &demangled))
{
gsymbol->m_language = l;
return demangled;
const lookup_name_info &name)
{
symbol_name_matcher_ftype *name_match
- = get_symbol_name_matcher (language_def (gsymbol->language ()), name);
+ = language_def (gsymbol->language ())->get_symbol_name_matcher (name);
return name_match (gsymbol->search_name (), name, NULL);
}
unsigned int
search_name_hash (enum language language, const char *search_name)
{
- return language_def (language)->la_search_name_hash (search_name);
+ return language_def (language)->search_name_hash (search_name);
}
/* See symtab.h.
lookup_language_this (const struct language_defn *lang,
const struct block *block)
{
- if (lang->la_name_of_this == NULL || block == NULL)
+ if (lang->name_of_this () == NULL || block == NULL)
return {};
if (symbol_lookup_debug > 1)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = block_objfile (block);
fprintf_unfiltered (gdb_stdlog,
"lookup_language_this (%s, %s (objfile %s))",
- lang->la_name, host_address_to_string (block),
+ lang->name (), host_address_to_string (block),
objfile_debug_name (objfile));
}
{
struct symbol *sym;
- sym = block_lookup_symbol (block, lang->la_name_of_this,
+ sym = block_lookup_symbol (block, lang->name_of_this (),
symbol_name_match_type::SEARCH_NAME,
VAR_DOMAIN);
if (sym != NULL)
/* The type may be a stub. */
type = check_typedef (type);
- for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+ for (i = type->num_fields () - 1; i >= TYPE_N_BASECLASSES (type); i--)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
is_a_field_of_this->type = type;
- is_a_field_of_this->field = &TYPE_FIELD (type, i);
+ is_a_field_of_this->field = &type->field (i);
return 1;
}
}
if (symbol_lookup_debug)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_aux (%s, %s (objfile %s), %s, %s)\n",
/* I'm not really sure that type of this can ever
be typedefed; just be safe. */
t = check_typedef (t);
- if (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+ if (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
t = TYPE_TARGET_TYPE (t);
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Internal error: `%s' is not an aggregate"),
- langdef->la_name_of_this);
+ langdef->name_of_this ());
if (check_field (t, name, is_a_field_of_this))
{
/* Now do whatever is appropriate for LANGUAGE to look
up static and global variables. */
- result = langdef->la_lookup_symbol_nonlocal (langdef, name, block, domain);
+ result = langdef->lookup_symbol_nonlocal (name, block, domain);
if (result.symbol != NULL)
{
if (symbol_lookup_debug)
/* See symtab.h. */
-struct objfile *
-lookup_objfile_from_block (const struct block *block)
-{
- if (block == NULL)
- return NULL;
-
- block = block_global_block (block);
- /* Look through all blockvectors. */
- for (objfile *obj : current_program_space->objfiles ())
- {
- for (compunit_symtab *cust : obj->compunits ())
- if (block == BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
- GLOBAL_BLOCK))
- {
- if (obj->separate_debug_objfile_backlink)
- obj = obj->separate_debug_objfile_backlink;
-
- return obj;
- }
- }
-
- return NULL;
-}
-
-/* See symtab.h. */
-
struct symbol *
lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
const struct block *block,
if (symbol_lookup_debug > 1)
{
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_block (%s, %s (objfile %s), %s)",
return result;
}
-/* See symtab.h. */
+/* See language.h. */
struct block_symbol
-basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
- const char *name,
- const struct block *block,
- const domain_enum domain)
+language_defn::lookup_symbol_nonlocal (const char *name,
+ const struct block *block,
+ const domain_enum domain) const
{
struct block_symbol result;
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
- result.symbol = language_lookup_primitive_type_as_symbol (langdef,
+ result.symbol = language_lookup_primitive_type_as_symbol (this,
gdbarch, name);
result.block = NULL;
if (result.symbol != NULL)
if (symbol_lookup_debug)
{
- struct objfile *objfile = lookup_objfile_from_block (static_block);
+ struct objfile *objfile = (block == nullptr
+ ? nullptr : block_objfile (block));
fprintf_unfiltered (gdb_stdlog,
"lookup_symbol_in_static_block (%s, %s (objfile %s),"
return { sym, global_block };
}
- struct objfile *objfile = lookup_objfile_from_block (block);
+ struct objfile *objfile = nullptr;
+ if (block != nullptr)
+ {
+ objfile = block_objfile (block);
+ if (objfile->separate_debug_objfile_backlink != nullptr)
+ objfile = objfile->separate_debug_objfile_backlink;
+ }
+
block_symbol bs
= lookup_global_or_static_symbol (name, GLOBAL_BLOCK, objfile, domain);
if (better_symbol (sym, bs.symbol, domain) == sym)
struct type *
lookup_transparent_type (const char *name)
{
- return current_language->la_lookup_transparent_type (name);
+ return current_language->lookup_transparent_type (name);
}
/* A helper for basic_lookup_transparent_type that interfaces with the
struct linetable_entry *last = item + len;
item = std::upper_bound (first, last, pc, pc_compare);
if (item != first)
- {
- /* Found a matching item. Skip backwards over any end of
- sequence markers. */
- for (prev = item - 1; prev->line == 0 && prev != first; prev--)
- /* Nothing. */;
- }
+ prev = item - 1; /* Found a matching item. */
/* At this point, prev points at the line whose start addr is <= pc, and
item points at the next line. If we ran off the end of the linetable
members. We only want to skip enums
here. */
&& !(SYMBOL_CLASS (sym) == LOC_CONST
- && (TYPE_CODE (SYMBOL_TYPE (sym))
+ && (SYMBOL_TYPE (sym)->code ()
== TYPE_CODE_ENUM))
&& (!treg.has_value ()
|| treg_matches_sym_type_name (*treg, sym)))
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 (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_TYPEDEF)
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
else
type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
{
const char *colon = strchr (regexp, ':');
+ /* Ignore the colon if it is part of a Windows drive. */
+ if (HAS_DRIVE_SPEC (regexp)
+ && (regexp[2] == '/' || regexp[2] == '\\'))
+ colon = strchr (STRIP_DRIVE_SPEC (regexp), ':');
+
if (colon && *(colon + 1) != ':')
{
int colon_index;
const language_defn *lang = language_def (symbol_language);
symbol_name_matcher_ftype *name_match
- = get_symbol_name_matcher (lang, lookup_name);
+ = lang->get_symbol_name_matcher (lookup_name);
return name_match (symbol_name, lookup_name, &match_res);
}
/* See symtab.h. */
-void
+bool
completion_list_add_name (completion_tracker &tracker,
language symbol_language,
const char *symname,
/* Clip symbols that cannot match. */
if (!compare_symbol_name (symname, symbol_language, lookup_name, match_res))
- return;
+ return false;
/* Refresh SYMNAME from the match string. It's potentially
different depending on language. (E.g., on Ada, the match may be
tracker.add_completion (std::move (completion),
&match_res.match_for_lcd, text, word);
}
+
+ return true;
}
/* completion_list_add_name wrapper for struct symbol. */
const lookup_name_info &lookup_name,
const char *text, const char *word)
{
- completion_list_add_name (tracker, sym->language (),
- sym->natural_name (),
- lookup_name, text, word);
+ if (!completion_list_add_name (tracker, sym->language (),
+ sym->natural_name (),
+ lookup_name, text, word))
+ return;
/* C++ function symbols include the parameters within both the msymbol
name and the symbol name. The problem is that the msymbol name will
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
{
struct type *t = SYMBOL_TYPE (sym);
- enum type_code c = TYPE_CODE (t);
+ enum type_code c = t->code ();
int j;
if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
- for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+ for (j = TYPE_N_BASECLASSES (t); j < t->num_fields (); j++)
if (TYPE_FIELD_NAME (t, j))
completion_list_add_name (tracker, sym->language (),
TYPE_FIELD_NAME (t, j),
bool
symbol_is_function_or_method (symbol *sym)
{
- switch (TYPE_CODE (SYMBOL_TYPE (sym)))
+ switch (SYMBOL_TYPE (sym)->code ())
{
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
if (code == TYPE_CODE_UNDEF
|| (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && TYPE_CODE (SYMBOL_TYPE (sym)) == code))
+ && SYMBOL_TYPE (sym)->code () == code))
completion_list_add_symbol (tracker, sym,
lookup_name,
text, word);
sym_text, word);
}
else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && TYPE_CODE (SYMBOL_TYPE (sym)) == code)
+ && SYMBOL_TYPE (sym)->code () == code)
completion_list_add_symbol (tracker, sym, lookup_name,
sym_text, word);
}
}
}
-void
-default_collect_symbol_completion_matches (completion_tracker &tracker,
- complete_symbol_mode mode,
- symbol_name_match_type name_match_type,
- const char *text, const char *word,
- enum type_code code)
-{
- return default_collect_symbol_completion_matches_break_on (tracker, mode,
- name_match_type,
- text, word, "",
- code);
-}
-
/* Collect all symbols (regardless of class) which begin by matching
TEXT. */
symbol_name_match_type name_match_type,
const char *text, const char *word)
{
- current_language->la_collect_symbol_completion_matches (tracker, mode,
- name_match_type,
- text, word,
- TYPE_CODE_UNDEF);
+ current_language->collect_symbol_completion_matches (tracker, mode,
+ name_match_type,
+ text, word,
+ TYPE_CODE_UNDEF);
}
/* Like collect_symbol_completion_matches, but only collect
gdb_assert (code == TYPE_CODE_UNION
|| code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_ENUM);
- current_language->la_collect_symbol_completion_matches (tracker, mode,
- name_match_type,
- text, word, code);
+ current_language->collect_symbol_completion_matches (tracker, mode,
+ name_match_type,
+ text, word, code);
}
/* Like collect_symbol_completion_matches, but collects a list of
\f
-/* Initialize the symbol SYM, and mark it as being owned by an objfile. */
-
-void
-initialize_objfile_symbol (struct symbol *sym)
-{
- SYMBOL_OBJFILE_OWNED (sym) = 1;
- SYMBOL_SECTION (sym) = -1;
-}
-
-/* Allocate and initialize a new 'struct symbol' on OBJFILE's
- obstack. */
-
-struct symbol *
-allocate_symbol (struct objfile *objfile)
-{
- struct symbol *result = new (&objfile->objfile_obstack) symbol ();
-
- initialize_objfile_symbol (result);
-
- return result;
-}
-
-/* Allocate and initialize a new 'struct template_symbol' on OBJFILE's
- obstack. */
-
-struct template_symbol *
-allocate_template_symbol (struct objfile *objfile)
-{
- struct template_symbol *result;
-
- result = new (&objfile->objfile_obstack) template_symbol ();
- initialize_objfile_symbol (result);
-
- return result;
-}
-
/* See symtab.h. */
struct objfile *