/* Multiple source language support for GDB.
- Copyright (C) 1991-2020 Free Software Foundation, Inc.
+ Copyright (C) 1991-2022 Free Software Foundation, Inc.
Contributed by the Department of Computer Science at the State University
of New York at Buffalo.
#include "c-lang.h"
#include <algorithm>
#include "gdbarch.h"
+#include "compile/compile-internal.h"
static void set_range_case (void);
enum language flang; /* The language of the frame. */
if (language_mode == language_mode_auto)
- fprintf_filtered (gdb_stdout,
- _("The current source language is "
- "\"auto; currently %s\".\n"),
- current_language->name ());
+ gdb_printf (file,
+ _("The current source language is "
+ "\"auto; currently %s\".\n"),
+ current_language->name ());
else
- fprintf_filtered (gdb_stdout,
- _("The current source language is \"%s\".\n"),
- current_language->name ());
+ gdb_printf (file,
+ _("The current source language is \"%s\".\n"),
+ current_language->name ());
if (has_stack_frames ())
{
if (flang != language_unknown
&& language_mode == language_mode_manual
&& current_language->la_language != flang)
- printf_filtered ("%s\n", _(lang_frame_mismatch_warn));
+ gdb_printf (file, "%s\n", _(lang_frame_mismatch_warn));
}
}
"Unrecognized range check setting.");
}
- fprintf_filtered (gdb_stdout,
- _("Range checking is \"auto; currently %s\".\n"),
- tmp);
+ gdb_printf (file,
+ _("Range checking is \"auto; currently %s\".\n"),
+ tmp);
}
else
- fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
- value);
+ gdb_printf (file, _("Range checking is \"%s\".\n"),
+ value);
if (range_check == range_check_warn
|| ((range_check == range_check_on)
"Unrecognized case-sensitive setting.");
}
- fprintf_filtered (gdb_stdout,
- _("Case sensitivity in "
- "name search is \"auto; currently %s\".\n"),
- tmp);
+ gdb_printf (file,
+ _("Case sensitivity in "
+ "name search is \"auto; currently %s\".\n"),
+ tmp);
}
else
- fprintf_filtered (gdb_stdout,
- _("Case sensitivity in name search is \"%s\".\n"),
- value);
+ gdb_printf (file,
+ _("Case sensitivity in name search is \"%s\".\n"),
+ value);
if (case_sensitivity != current_language->case_sensitivity ())
warning (_("the current case sensitivity setting does not match "
}
\f
-/* Print out the current language settings: language, range and
- type checking. If QUIETLY, print only what has changed. */
+/* See language.h. */
void
-language_info (int quietly)
+language_info ()
{
- if (quietly && expected_language == current_language)
+ if (expected_language == current_language)
return;
expected_language = current_language;
- printf_unfiltered (_("Current language: %s\n"), language);
- show_language_command (NULL, 1, NULL, NULL);
-
- if (!quietly)
- {
- printf_unfiltered (_("Range checking: %s\n"), range);
- show_range_command (NULL, 1, NULL, NULL);
- printf_unfiltered (_("Case sensitivity: %s\n"), case_sensitive);
- show_case_command (NULL, 1, NULL, NULL);
- }
-}
-\f
-
-/* Returns non-zero if the value is a pointer type. */
-int
-pointer_type (struct type *type)
-{
- return type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type);
-}
-
-\f
-/* This page contains functions that return info about
- (struct value) values used in GDB. */
-
-/* Returns non-zero if the value VAL represents a true value. */
-int
-value_true (struct value *val)
-{
- /* It is possible that we should have some sort of error if a non-boolean
- value is used in this context. Possibly dependent on some kind of
- "boolean-checking" option like range checking. But it should probably
- not depend on the language except insofar as is necessary to identify
- a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
- should be an error, probably). */
- return !value_logical_not (val);
+ gdb_printf (_("Current language: %s\n"), language);
+ show_language_command (gdb_stdout, 1, NULL, NULL);
}
\f
/* This page contains functions for the printing out of
case range_check_off:
/* FIXME: cagney/2002-01-30: Should this function print anything
when range error is off? */
- vfprintf_filtered (gdb_stderr, string, args);
- fprintf_filtered (gdb_stderr, "\n");
+ gdb_vprintf (gdb_stderr, string, args);
+ gdb_printf (gdb_stderr, "\n");
break;
default:
internal_error (__FILE__, __LINE__, _("bad switch"));
/* Display "auto", "local" and "unknown" first, and then the rest,
alpha sorted. */
const char **language_names_p = language_names;
- *language_names_p++ = language_def (language_auto)->name ();
+ language = language_def (language_auto)->name ();
+ *language_names_p++ = language;
*language_names_p++ = "local";
*language_names_p++ = language_def (language_unknown)->name ();
const char **sort_begin = language_names_p;
more flexible demangler for the languages that need it.
FIXME: Sometimes the demangler is invoked when we don't know the
language, so we can't use this everywhere. */
-char *
+gdb::unique_xmalloc_ptr<char>
language_demangle (const struct language_defn *current_language,
const char *mangled, int options)
{
{
struct value *index_value = value_from_longest (index_type, index);
- fprintf_filtered (stream, "[");
+ gdb_printf (stream, "[");
value_print (index_value, stream, options);
- fprintf_filtered (stream, "] = ");
+ gdb_printf (stream, "] = ");
}
/* See language.h. */
/* Generates an expression that assumes a C like syntax is valid. */
type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
std::string name = type_to_string (type);
- return gdb::unique_xmalloc_ptr<char>
- (xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
+ return xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr));
}
/* See language.h. */
/* See language.h. */
-void
-language_defn::printchar (int ch, struct type *chtype,
- struct ui_file * stream) const
-{
- c_printchar (ch, chtype, stream);
-}
-
-/* See language.h. */
-
void
language_defn::printstr (struct ui_file *stream, struct type *elttype,
const gdb_byte *string, unsigned int length,
return c_is_string_type_p (type);
}
+/* See language.h. */
+
+std::unique_ptr<compile_instance>
+language_defn::get_compile_instance () const
+{
+ return {};
+}
+
/* The default implementation of the get_symbol_name_matcher_inner method
from the language_defn class. Matches with strncmp_iw. */
return &c_varobj_ops;
}
-/* See language.h. */
-
-const struct exp_descriptor *
-language_defn::expression_ops () const
-{
- return &exp_descriptor_standard;
-}
-
/* Parent class for both the "auto" and "unknown" languages. These two
pseudo-languages are very similar so merging their implementations like
this makes sense. */
/* See language.h. */
- char *demangle_symbol (const char *mangled, int options) const override
+ gdb::unique_xmalloc_ptr<char> demangle_symbol (const char *mangled,
+ int options) const override
{
/* The auto language just uses the C++ demangler. */
return gdb_demangle (mangled, options);
int parser (struct parser_state *ps) const override
{
- /* No parsing is done, just claim success. */
- return 1;
+ error (_("expression parsing not implemented for language \"%s\""),
+ natural_name ());
}
/* See language.h. */
const char *name_of_this () const override
{ return "this"; }
-
- /* See language.h. */
-
- const struct op_print *opcode_print_table () const override
- {
- static const struct op_print unk_op_print_tab[] =
- {
- {NULL, OP_NULL, PREC_NULL, 0}
- };
-
- return unk_op_print_tab;
- }
};
/* Class representing the fake "auto" language. */
sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
if (sym != nullptr)
{
- struct type *type = SYMBOL_TYPE (sym);
+ struct type *type = sym->type ();
if (type != nullptr && type->code () == TYPE_CODE_BOOL)
return type;
}
{
struct symbol *symbol;
struct gdbarch *gdbarch;
- gdb_assert (!TYPE_OBJFILE_OWNED (type));
- gdbarch = TYPE_OWNER (type).gdbarch;
+ gdb_assert (!type->is_objfile_owned ());
+ gdbarch = type->arch_owner ();
symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
symbol->m_name = type->name ();
symbol->set_language (lang, nullptr);
symbol->owner.arch = gdbarch;
- SYMBOL_OBJFILE_OWNED (symbol) = 0;
- SYMBOL_SECTION (symbol) = 0;
- SYMBOL_TYPE (symbol) = type;
- SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
- SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
+ symbol->set_is_objfile_owned (0);
+ symbol->set_section_index (0);
+ symbol->set_type (type);
+ symbol->set_domain (VAR_DOMAIN);
+ symbol->set_aclass_index (LOC_TYPEDEF);
return symbol;
}
struct type *
language_arch_info::lookup_primitive_type
- (std::function<bool (struct type *)> filter)
+ (gdb::function_view<bool (struct type *)> filter)
{
for (struct type_and_symbol &tas : primitive_types_and_symbols)
{
return nullptr;
}
-/* See language.h. */
+/* Helper for the language_lookup_primitive_type overloads to forward
+ to the corresponding language's lookup_primitive_type overload. */
template<typename T>
-struct type *
-language_lookup_primitive_type (const struct language_defn *la,
- struct gdbarch *gdbarch,
- T arg)
+static struct type *
+language_lookup_primitive_type_1 (const struct language_defn *la,
+ struct gdbarch *gdbarch,
+ T arg)
{
struct language_gdbarch *ld =
(struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
return ld->arch_info[la->la_language].lookup_primitive_type (arg);
}
-/* Template instantiation. */
+/* See language.h. */
-template struct type *
+struct type *
language_lookup_primitive_type (const struct language_defn *la,
struct gdbarch *gdbarch,
- const char *arg);
+ const char *name)
+{
+ return language_lookup_primitive_type_1 (la, gdbarch, name);
+}
-/* Template instantiation. */
+/* See language.h. */
-template struct type *
+struct type *
language_lookup_primitive_type (const struct language_defn *la,
struct gdbarch *gdbarch,
- std::function<bool (struct type *)> arg);
+ gdb::function_view<bool (struct type *)> filter)
+{
+ return language_lookup_primitive_type_1 (la, gdbarch, filter);
+}
/* See language.h. */
struct language_arch_info *lai = &ld->arch_info[la->la_language];
if (symbol_lookup_debug)
- fprintf_unfiltered (gdb_stdlog,
- "language_lookup_primitive_type_as_symbol"
- " (%s, %s, %s)",
- la->name (), host_address_to_string (gdbarch), name);
+ gdb_printf (gdb_stdlog,
+ "language_lookup_primitive_type_as_symbol"
+ " (%s, %s, %s)",
+ la->name (), host_address_to_string (gdbarch), name);
struct symbol *sym
= lai->lookup_primitive_type_as_symbol (name, la->la_language);
if (symbol_lookup_debug)
- fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
+ gdb_printf (gdb_stdlog, " = %s\n", host_address_to_string (sym));
/* Note: The result of symbol lookup is normally a symbol *and* the block
it was found in. Builtin types don't live in blocks. We *could* give
/* GDB commands for language specific stuff. */
- add_basic_prefix_cmd ("check", no_class,
- _("Set the status of the type/range checker."),
- &setchecklist, "set check ", 0, &setlist);
- add_alias_cmd ("c", "check", no_class, 1, &setlist);
- add_alias_cmd ("ch", "check", no_class, 1, &setlist);
-
- add_show_prefix_cmd ("check", no_class,
- _("Show the status of the type/range checker."),
- &showchecklist, "show check ", 0, &showlist);
- add_alias_cmd ("c", "check", no_class, 1, &showlist);
- add_alias_cmd ("ch", "check", no_class, 1, &showlist);
-
+ set_show_commands setshow_check_cmds
+ = add_setshow_prefix_cmd ("check", no_class,
+ _("Set the status of the type/range checker."),
+ _("Show the status of the type/range checker."),
+ &setchecklist, &showchecklist,
+ &setlist, &showlist);
+ add_alias_cmd ("c", setshow_check_cmds.set, no_class, 1, &setlist);
+ add_alias_cmd ("ch", setshow_check_cmds.set, no_class, 1, &setlist);
+ add_alias_cmd ("c", setshow_check_cmds.show, no_class, 1, &showlist);
+ add_alias_cmd ("ch", setshow_check_cmds.show, no_class, 1, &showlist);
+
+ range = type_or_range_names[3];
+ gdb_assert (strcmp (range, "auto") == 0);
add_setshow_enum_cmd ("range", class_support, type_or_range_names,
&range,
_("Set range checking (on/warn/off/auto)."),
show_range_command,
&setchecklist, &showchecklist);
+ case_sensitive = case_sensitive_names[2];
+ gdb_assert (strcmp (case_sensitive, "auto") == 0);
add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
&case_sensitive, _("\
Set case sensitivity in name search (on/off/auto)."), _("\
add_set_language_command ();
- language = "auto";
- range = "auto";
- case_sensitive = "auto";
-
/* Have the above take effect. */
set_language (language_auto);
}