bool load_language_list()
{
config cfg;
try {
if (game_config::use_bin) {
wml_config_from_file(game_config::path + "/xwml/" + "language.bin", cfg);
} else {
scoped_istream stream = preprocess_file(get_wml_location("hardwired/language.cfg"));
read(cfg, *stream);
wml_config_to_file(game_config::path + "/xwml/" + "language.bin", cfg);
}
} catch(config::error &) {
return false;
}
known_languages.clear();
known_languages.push_back(
language_def("", t_string(N_("System default language"), "wesnoth"), "ltr", "", "A"));
foreach (const config &lang, cfg.child_range("locale"))
{
known_languages.push_back(
language_def(lang["locale"], lang["name"], lang["dir"],
lang["alternates"], lang["sort_name"]));
}
return true;
}
bool load_language_list()
{
config cfg;
try {
scoped_istream stream = preprocess_file(get_wml_location("hardwired/language.cfg"));
read(cfg, *stream);
} catch(config::error &) {
return false;
}
known_languages.clear();
known_languages.push_back(
language_def("", t_string(N_("System default language"), "wesnoth"), "ltr", "", "A"));
BOOST_FOREACH(const config &lang, cfg.child_range("locale"))
{
known_languages.push_back(
language_def(lang["locale"], lang["name"], lang["dir"],
lang["alternates"], lang["sort_name"]));
}
return true;
}
bool load_language_list()
{
config cfg;
try {
scoped_istream stream = preprocess_file(get_wml_location("hardwired/language.cfg"));
read(cfg, *stream);
} catch(config::error &) {
return false;
}
known_languages.clear();
known_languages.push_back(
language_def("", "System default language", "ltr", "", "A"));
config::const_child_itors langs = cfg.child_range("locale");
for(;langs.first != langs.second; ++langs.first) {
known_languages.push_back(
language_def((**langs.first)["locale"], (**langs.first)["name"], (**langs.first)["dir"],
(**langs.first)["alternates"], (**langs.first)["sort_name"]));
}
return true;
}
static void
ada_val_print_flt (struct type *type, const gdb_byte *valaddr,
int offset, int offset_aligned, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
if (options->format)
{
val_print (type, offset, address, stream, recurse,
original_value, options, language_def (language_c));
return;
}
ada_print_floating (valaddr + offset, type, stream);
}
void
iterate_over_minimal_symbols
(struct objfile *objf, const lookup_name_info &lookup_name,
gdb::function_view<bool (struct minimal_symbol *)> callback)
{
/* The first pass is over the ordinary hash table. */
{
const char *name = linkage_name_str (lookup_name);
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
auto *mangled_cmp
= (case_sensitivity == case_sensitive_on
? strcmp
: strcasecmp);
for (minimal_symbol *iter = objf->per_bfd->msymbol_hash[hash];
iter != NULL;
iter = iter->hash_next)
{
if (mangled_cmp (MSYMBOL_LINKAGE_NAME (iter), name) == 0)
if (callback (iter))
return;
}
}
/* The second pass is over the demangled table. Once for each
language in the demangled hash names table (usually just zero or
one). */
for (auto lang : objf->per_bfd->demangled_hash_languages)
{
const language_defn *lang_def = language_def (lang);
symbol_name_matcher_ftype *name_match
= get_symbol_name_matcher (lang_def, lookup_name);
unsigned int hash
= lookup_name.search_name_hash (lang) % MINIMAL_SYMBOL_HASH_SIZE;
for (minimal_symbol *iter = objf->per_bfd->msymbol_demangled_hash[hash];
iter != NULL;
iter = iter->demangled_hash_next)
if (name_match (MSYMBOL_SEARCH_NAME (iter), lookup_name, NULL))
if (callback (iter))
return;
}
}
static void
ada_val_print_ptr (struct type *type, const gdb_byte *valaddr,
int offset, int offset_aligned, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
val_print (type, offset, address, stream, recurse,
original_value, options, language_def (language_c));
if (ada_is_tag_type (type))
{
struct value *val =
value_from_contents_and_address (type,
valaddr + offset_aligned,
address + offset_aligned);
const char *name = ada_tag_name (val);
if (name != NULL)
fprintf_filtered (stream, " (%s)", name);
}
}
struct bound_minimal_symbol
lookup_minimal_symbol (const char *name, const char *sfile,
struct objfile *objf)
{
struct objfile *objfile;
found_minimal_symbols found;
unsigned int mangled_hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
auto *mangled_cmp
= (case_sensitivity == case_sensitive_on
? strcmp
: strcasecmp);
if (sfile != NULL)
sfile = lbasename (sfile);
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
for (objfile = object_files;
objfile != NULL && found.external_symbol.minsym == NULL;
objfile = objfile->next)
{
if (objf == NULL || objf == objfile
|| objf == objfile->separate_debug_objfile_backlink)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"lookup_minimal_symbol (%s, %s, %s)\n",
name, sfile != NULL ? sfile : "NULL",
objfile_debug_name (objfile));
}
/* Do two passes: the first over the ordinary hash table,
and the second over the demangled hash table. */
lookup_minimal_symbol_mangled (name, sfile, objfile,
objfile->per_bfd->msymbol_hash,
mangled_hash, mangled_cmp, found);
/* If not found, try the demangled hash table. */
if (found.external_symbol.minsym == NULL)
{
/* Once for each language in the demangled hash names
table (usually just zero or one languages). */
for (auto lang : objfile->per_bfd->demangled_hash_languages)
{
unsigned int hash
= (lookup_name.search_name_hash (lang)
% MINIMAL_SYMBOL_HASH_SIZE);
symbol_name_matcher_ftype *match
= get_symbol_name_matcher (language_def (lang),
lookup_name);
struct minimal_symbol **msymbol_demangled_hash
= objfile->per_bfd->msymbol_demangled_hash;
lookup_minimal_symbol_demangled (lookup_name, sfile, objfile,
msymbol_demangled_hash,
hash, match, found);
if (found.external_symbol.minsym != NULL)
break;
}
}
}
}
/* External symbols are best. */
if (found.external_symbol.minsym != NULL)
{
if (symbol_lookup_debug)
{
minimal_symbol *minsym = found.external_symbol.minsym;
fprintf_unfiltered (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (external)\n",
host_address_to_string (minsym));
}
return found.external_symbol;
}
/* File-local symbols are next best. */
if (found.file_symbol.minsym != NULL)
{
if (symbol_lookup_debug)
{
minimal_symbol *minsym = found.file_symbol.minsym;
fprintf_unfiltered (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (file-local)\n",
host_address_to_string (minsym));
}
return found.file_symbol;
}
/* Symbols for shared library trampolines are next best. */
if (found.trampoline_symbol.minsym != NULL)
{
if (symbol_lookup_debug)
{
minimal_symbol *minsym = found.trampoline_symbol.minsym;
fprintf_unfiltered (gdb_stdlog,
"lookup_minimal_symbol (...) = %s (trampoline)\n",
host_address_to_string (minsym));
}
return found.trampoline_symbol;
}
/* Not found. */
if (symbol_lookup_debug)
fprintf_unfiltered (gdb_stdlog, "lookup_minimal_symbol (...) = NULL\n");
return {};
}
static void
list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
enum print_values values, int skip_unavailable)
{
struct cleanup *old_chain;
struct ui_out *uiout = current_uiout;
struct ui_file *stb;
gdb_assert (!arg->val || !arg->error);
gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
&& arg->error == NULL)
|| values == PRINT_SIMPLE_VALUES
|| (values == PRINT_ALL_VALUES
&& (arg->val != NULL || arg->error != NULL)));
gdb_assert (arg->entry_kind == print_entry_values_no
|| (arg->entry_kind == print_entry_values_only
&& (arg->val || arg->error)));
if (skip_unavailable && arg->val != NULL
&& (value_entirely_unavailable (arg->val)
/* A scalar object that does not have all bits available is
also considered unavailable, because all bits contribute
to its representation. */
|| (val_print_scalar_type_p (value_type (arg->val))
&& !value_bytes_available (arg->val,
value_embedded_offset (arg->val),
TYPE_LENGTH (value_type (arg->val))))))
return;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
if (values != PRINT_NO_VALUES || what == all)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);
if (arg->entry_kind == print_entry_values_only)
fputs_filtered ("@entry", stb);
ui_out_field_stream (uiout, "name", stb);
if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
ui_out_field_int (uiout, "arg", 1);
if (values == PRINT_SIMPLE_VALUES)
{
check_typedef (arg->sym->type);
type_print (arg->sym->type, "", stb, -1);
ui_out_field_stream (uiout, "type", stb);
}
if (arg->val || arg->error)
{
const char *error_message = NULL;
if (arg->error)
error_message = arg->error;
else
{
TRY
{
struct value_print_options opts;
get_no_prettyformat_print_options (&opts);
opts.deref_ref = 1;
common_val_print (arg->val, stb, 0, &opts,
language_def (SYMBOL_LANGUAGE (arg->sym)));
}
CATCH (except, RETURN_MASK_ERROR)
{
error_message = except.message;
}
END_CATCH
}
if (error_message != NULL)
fprintf_filtered (stb, _("<error reading variable: %s>"),
error_message);
ui_out_field_stream (uiout, "value", stb);
}
do_cleanups (old_chain);
}
struct block_symbol
cp_lookup_symbol_imports_or_template (const char *scope,
const char *name,
const struct block *block,
const domain_enum domain)
{
struct symbol *function = BLOCK_FUNCTION (block);
struct block_symbol result;
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_imports_or_template"
" (%s, %s, %s, %s)\n",
scope, name, host_address_to_string (block),
domain_name (domain));
}
if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
{
/* Search the function's template parameters. */
if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
{
struct template_symbol *templ
= (struct template_symbol *) function;
struct symbol *sym = search_symbol_list (name,
templ->n_template_arguments,
templ->template_arguments);
if (sym != NULL)
{
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_symbol_imports_or_template"
" (...) = %s\n",
host_address_to_string (sym));
}
return (struct block_symbol) {sym, block};
}
}
/* Search the template parameters of the function's defining
context. */
if (SYMBOL_NATURAL_NAME (function))
{
struct type *context;
char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
struct cleanup *cleanups = make_cleanup (xfree, name_copy);
const struct language_defn *lang = language_def (language_cplus);
struct gdbarch *arch = symbol_arch (function);
const struct block *parent = BLOCK_SUPERBLOCK (block);
struct symbol *sym;
while (1)
{
unsigned int prefix_len = cp_entire_prefix_len (name_copy);
if (prefix_len == 0)
context = NULL;
else
{
name_copy[prefix_len] = '\0';
context = lookup_typename (lang, arch,
name_copy,
parent, 1);
}
if (context == NULL)
break;
sym
= search_symbol_list (name,
TYPE_N_TEMPLATE_ARGUMENTS (context),
TYPE_TEMPLATE_ARGUMENTS (context));
if (sym != NULL)
{
do_cleanups (cleanups);
if (symbol_lookup_debug)
{
fprintf_unfiltered
(gdb_stdlog,
"cp_lookup_symbol_imports_or_template (...) = %s\n",
host_address_to_string (sym));
}
return (struct block_symbol) {sym, parent};
}
}
do_cleanups (cleanups);
}
}
static struct block_symbol
cp_lookup_bare_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
const domain_enum domain, int search)
{
struct block_symbol sym;
/* Note: We can't do a simple assert for ':' not being in NAME because
':' may be in the args of a template spec. This isn't intended to be
a complete test, just cheap and documentary. */
if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
gdb_assert (strchr (name, ':') == NULL);
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
return sym;
/* If we didn't find a definition for a builtin type in the static block,
search for it now. This is actually the right thing to do and can be
a massive performance win. E.g., when debugging a program with lots of
shared libraries we could search all of them only to find out the
builtin type isn't defined in any of them. This is common for types
like "void". */
if (langdef != NULL && domain == VAR_DOMAIN)
{
struct gdbarch *gdbarch;
if (block == NULL)
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
sym.symbol
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
sym.block = NULL;
if (sym.symbol != NULL)
return sym;
}
sym = lookup_global_symbol (name, block, domain);
if (sym.symbol != NULL)
return sym;
if (search)
{
struct block_symbol lang_this;
struct type *type;
lang_this = lookup_language_this (language_def (language_cplus), block);
if (lang_this.symbol == NULL)
return null_block_symbol;
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
/* If TYPE_NAME is NULL, abandon trying to find this symbol.
This can happen for lambda functions compiled with clang++,
which outputs no name for the container class. */
if (TYPE_NAME (type) == NULL)
return null_block_symbol;
/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
}
return sym;
}
static struct block_symbol
d_lookup_symbol (const struct language_defn *langdef,
const char *name, const struct block *block,
const domain_enum domain, int search)
{
struct block_symbol sym;
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
return sym;
/* If we didn't find a definition for a builtin type in the static block,
such as "ucent" which is a specialist type, search for it now. */
if (langdef != NULL && domain == VAR_DOMAIN)
{
struct gdbarch *gdbarch;
if (block == NULL)
gdbarch = target_gdbarch ();
else
gdbarch = block_gdbarch (block);
sym.symbol
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
sym.block = NULL;
if (sym.symbol != NULL)
return sym;
}
sym = lookup_global_symbol (name, block, domain);
if (sym.symbol != NULL)
return sym;
if (search)
{
char *classname, *nested;
unsigned int prefix_len;
struct cleanup *cleanup;
struct block_symbol class_sym;
/* A simple lookup failed. Check if the symbol was defined in
a base class. */
cleanup = make_cleanup (null_cleanup, NULL);
/* Find the name of the class and the name of the method,
variable, etc. */
prefix_len = d_entire_prefix_len (name);
/* If no prefix was found, search "this". */
if (prefix_len == 0)
{
struct type *type;
struct block_symbol lang_this;
lang_this = lookup_language_this (language_def (language_d), block);
if (lang_this.symbol == NULL)
{
do_cleanups (cleanup);
return null_block_symbol;
}
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
classname = xstrdup (TYPE_NAME (type));
nested = xstrdup (name);
}
else
{
/* The class name is everything up to and including PREFIX_LEN. */
classname = savestring (name, prefix_len);
/* The rest of the name is everything else past the initial scope
operator. */
nested = xstrdup (name + prefix_len + 1);
}
/* Add cleanups to free memory for these strings. */
make_cleanup (xfree, classname);
make_cleanup (xfree, nested);
/* Lookup a class named CLASSNAME. If none is found, there is nothing
more that can be done. */
class_sym = lookup_global_symbol (classname, block, domain);
if (class_sym.symbol == NULL)
{
do_cleanups (cleanup);
return null_block_symbol;
}
/* Look for a symbol named NESTED in this class. */
sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
nested, block);
do_cleanups (cleanup);
}
return sym;
}
static void
ada_val_print_1 (struct type *type,
int offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
struct value *original_value,
const struct value_print_options *options,
const struct language_defn *language)
{
int offset_aligned;
const gdb_byte *valaddr = value_contents_for_printing (original_value);
type = ada_check_typedef (type);
if (ada_is_array_descriptor_type (type)
|| (ada_is_constrained_packed_array_type (type)
&& TYPE_CODE (type) != TYPE_CODE_PTR))
{
ada_val_print_gnat_array (type, valaddr, offset, address,
stream, recurse, original_value,
options, language);
return;
}
offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
type = printable_val_type (type, valaddr + offset_aligned);
type = resolve_dynamic_type (type, valaddr + offset_aligned,
address + offset_aligned);
switch (TYPE_CODE (type))
{
default:
val_print (type, offset, address, stream, recurse,
original_value, options, language_def (language_c));
break;
case TYPE_CODE_PTR:
ada_val_print_ptr (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options, language);
break;
case TYPE_CODE_INT:
case TYPE_CODE_RANGE:
ada_val_print_num (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options, language);
break;
case TYPE_CODE_ENUM:
ada_val_print_enum (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options, language);
break;
case TYPE_CODE_FLT:
ada_val_print_flt (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options, language);
break;
case TYPE_CODE_UNION:
case TYPE_CODE_STRUCT:
ada_val_print_struct_union (type, valaddr, offset, offset_aligned,
address, stream, recurse,
original_value, options, language);
break;
case TYPE_CODE_ARRAY:
ada_val_print_array (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options);
return;
case TYPE_CODE_REF:
ada_val_print_ref (type, valaddr, offset, offset_aligned,
address, stream, recurse, original_value,
options, language);
break;
}
}
static enum ext_lang_bt_status
extract_sym (PyObject *obj, gdb::unique_xmalloc_ptr<char> *name,
struct symbol **sym, struct block **sym_block,
const struct language_defn **language)
{
PyObject *result = PyObject_CallMethod (obj, "symbol", NULL);
if (result == NULL)
return EXT_LANG_BT_ERROR;
/* For 'symbol' callback, the function can return a symbol or a
string. */
if (gdbpy_is_string (result))
{
*name = python_string_to_host_string (result);
Py_DECREF (result);
if (*name == NULL)
return EXT_LANG_BT_ERROR;
/* If the API returns a string (and not a symbol), then there is
no symbol derived language available and the frame filter has
either overridden the symbol with a string, or supplied a
entirely synthetic symbol/value pairing. In that case, use
python_language. */
*language = python_language;
*sym = NULL;
*sym_block = NULL;
}
else
{
/* This type checks 'result' during the conversion so we
just call it unconditionally and check the return. */
*sym = symbol_object_to_symbol (result);
/* TODO: currently, we have no way to recover the block in which SYMBOL
was found, so we have no block to return. Trying to evaluate SYMBOL
will yield an incorrect value when it's located in a FRAME and
evaluated from another frame (as permitted in nested functions). */
*sym_block = NULL;
Py_DECREF (result);
if (*sym == NULL)
{
PyErr_SetString (PyExc_RuntimeError,
_("Unexpected value. Expecting a "
"gdb.Symbol or a Python string."));
return EXT_LANG_BT_ERROR;
}
/* Duplicate the symbol name, so the caller has consistency
in garbage collection. */
name->reset (xstrdup (SYMBOL_PRINT_NAME (*sym)));
/* If a symbol is specified attempt to determine the language
from the symbol. If mode is not "auto", then the language
has been explicitly set, use that. */
if (language_mode == language_mode_auto)
*language = language_def (SYMBOL_LANGUAGE (*sym));
else
*language = current_language;
}
return EXT_LANG_BT_OK;
}
static void
list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
enum print_values values)
{
struct cleanup *old_chain;
struct ui_out *uiout = current_uiout;
struct ui_file *stb;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
gdb_assert (!arg->val || !arg->error);
gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL
&& arg->error == NULL)
|| values == PRINT_SIMPLE_VALUES
|| (values == PRINT_ALL_VALUES
&& (arg->val != NULL || arg->error != NULL)));
gdb_assert (arg->entry_kind == print_entry_values_no
|| (arg->entry_kind == print_entry_values_only
&& (arg->val || arg->error)));
if (values != PRINT_NO_VALUES || what == all)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);
if (arg->entry_kind == print_entry_values_only)
fputs_filtered ("@entry", stb);
ui_out_field_stream (uiout, "name", stb);
if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))
ui_out_field_int (uiout, "arg", 1);
if (values == PRINT_SIMPLE_VALUES)
{
check_typedef (arg->sym->type);
type_print (arg->sym->type, "", stb, -1);
ui_out_field_stream (uiout, "type", stb);
}
if (arg->val || arg->error)
{
volatile struct gdb_exception except;
if (arg->error)
except.message = arg->error;
else
{
/* TRY_CATCH has two statements, wrap it in a block. */
TRY_CATCH (except, RETURN_MASK_ERROR)
{
struct value_print_options opts;
get_raw_print_options (&opts);
opts.deref_ref = 1;
common_val_print (arg->val, stb, 0, &opts,
language_def (SYMBOL_LANGUAGE (arg->sym)));
}
}
if (except.message)
fprintf_filtered (stb, _("<error reading variable: %s>"),
except.message);
ui_out_field_stream (uiout, "value", stb);
}
do_cleanups (old_chain);
}
