throw_error (NOT_FOUND_ERROR, "%s", message);
}
+/* A callback function and the additional data to call it with. */
+
+struct symbol_and_data_callback
+{
+ /* The callback to use. */
+ symbol_found_callback_ftype *callback;
+
+ /* Data to be passed to the callback. */
+ void *data;
+};
+
+/* A helper for iterate_over_all_matching_symtabs that is used to
+ restrict calls to another callback to symbols representing inline
+ symbols only. */
+
+static int
+iterate_inline_only (struct symbol *sym, void *d)
+{
+ if (SYMBOL_INLINED (sym))
+ {
+ struct symbol_and_data_callback *cad = d;
+
+ return cad->callback (sym, cad->data);
+ }
+ return 1; /* Continue iterating. */
+}
+
/* Some data for the expand_symtabs_matching callback. */
struct symbol_matcher_data
const char *lookup_name;
/* The routine to be used for comparison. */
- symbol_name_match_p_ftype symbol_name_match_p;
+ symbol_name_cmp_ftype symbol_name_cmp;
};
/* A helper for iterate_over_all_matching_symtabs that is passed as a
{
const struct symbol_matcher_data *data = d;
- if (data->symbol_name_match_p (name, data->lookup_name))
- return 1;
- return 0;
+ if (data->symbol_name_cmp (name, data->lookup_name) == 0)
+ return 1; /* Expand this symbol's symbol table. */
+ return 0; /* Skip this symbol. */
}
/* A helper that walks over all matching symtabs in all objfiles and
calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
not NULL, then the search is restricted to just that program
- space. */
+ space. If INCLUDE_INLINE is nonzero then symbols representing
+ inlined instances of functions will be included in the result. */
static void
iterate_over_all_matching_symtabs (const char *name,
const domain_enum domain,
- int (*callback) (struct symbol *, void *),
+ symbol_found_callback_ftype *callback,
void *data,
- struct program_space *search_pspace)
+ struct program_space *search_pspace,
+ int include_inline)
{
struct objfile *objfile;
struct program_space *pspace;
struct symbol_matcher_data matcher_data;
matcher_data.lookup_name = name;
- matcher_data.symbol_name_match_p =
- current_language->la_get_symbol_name_match_p != NULL
- ? current_language->la_get_symbol_name_match_p (name)
+ matcher_data.symbol_name_cmp =
+ current_language->la_get_symbol_name_cmp != NULL
+ ? current_language->la_get_symbol_name_cmp (name)
: strcmp_iw;
ALL_PSPACES (pspace)
block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
+
+ if (include_inline)
+ {
+ struct symbol_and_data_callback cad = { callback, data };
+ int i;
+
+ for (i = FIRST_LOCAL_BLOCK;
+ i < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab)); i++)
+ {
+ block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), i);
+ LA_ITERATE_OVER_SYMBOLS (block, name, domain,
+ iterate_inline_only, &cad);
+ }
+ }
}
}
}
{
int i1 = 0;
int ibase;
- char *class_name = type_name_no_tag (t);
- char *canon;
+ const char *class_name = type_name_no_tag (t);
/* Ignore this class if it doesn't have a name. This is ugly, but
unless we figure out how to get the physname without the name of
method_counter >= 0;
--method_counter)
{
- char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
+ const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
char dem_opname[64];
if (strncmp (method_name, "__", 2) == 0 ||
return;
}
+ /* Sort the list of method names alphabetically. */
+ qsort (VEC_address (const_char_ptr, item_names),
+ VEC_length (const_char_ptr, item_names),
+ sizeof (const_char_ptr), compare_strings);
+
printf_unfiltered (_("[0] cancel\n[1] all\n"));
for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
printf_unfiltered ("[%d] %s\n", i + 2, iter);
/* Locate the end of the first half of the linespec.
After the call, for instance, if the argptr string is "foo.c:123"
- p will point at "123". If there is only one part, like "foo", p
+ p will point at ":123". If there is only one part, like "foo", p
will point to "". If this is a C++ name, like "A::B::foo", p will
point to "::B::foo". Argptr is not changed by this call. */
/* First things first: if ARGPTR starts with a filename, get its
symtab and strip the filename from ARGPTR.
Avoid calling symtab_from_filename if we know can,
- it can be expensive. */
+ it can be expensive. We know we can avoid the call if we see a
+ single word (e.g., "break NAME") or if we see a qualified C++
+ name ("break QUAL::NAME"). */
- if (*p != '\0')
+ if (*p != '\0' && !(p[0] == ':' && p[1] == ':'))
{
TRY_CATCH (file_exception, RETURN_MASK_ERROR)
{
struct type *t;
if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
- return 1;
+ return 1; /* Continue iterating. */
t = SYMBOL_TYPE (sym);
CHECK_TYPEDEF (t);
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION
&& TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
- return 1;
+ return 1; /* Continue iterating. */
slot = htab_find_slot (collector->unique_syms, sym, INSERT);
if (!*slot)
VEC_safe_push (symbolp, collector->symbols, sym);
}
- return 1;
+ return 1; /* Continue iterating. */
}
/* Return the symbol corresponding to the substring of *ARGPTR ending
{
iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
collect_one_symbol, &collector,
- NULL);
+ NULL, 0);
iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
collect_one_symbol, &collector,
- NULL);
+ NULL, 0);
}
else
{
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
VEC_safe_push (symbolp, *syms, sym);
- return 1;
+ return 1; /* Continue iterating. */
}
/* Look up a function symbol in *ARGPTR. If found, advance *ARGPTR
copy[p - *argptr] = 0;
iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
- collect_function_symbols, &result, NULL);
+ collect_function_symbols, &result, NULL,
+ 0);
if (VEC_empty (symbolp, result))
VEC_free (symbolp, result);
add_sal_to_sals (info->state, &info->result, &sal,
SYMBOL_NATURAL_NAME (sym));
- return 1;
+ return 1; /* Continue iterating. */
}
/* We've found a minimal symbol MSYMBOL to associate with our
{
iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
collect_symbols, info,
- pspace);
+ pspace, 1);
search_minsyms_for_name (info, name, pspace);
}
else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))