#include "observable.h"
#include "objfiles.h"
#include "extension.h"
-#include "byte-vector.h"
+#include "gdbtypes.h"
+#include "gdbsupport/byte-vector.h"
-extern unsigned int overload_debug;
/* Local functions. */
static int typecmp (int staticp, int varargs, int nargs,
static struct value *cast_into_complex (struct type *, struct value *);
-int overload_resolution = 0;
+bool overload_resolution = false;
static void
show_overload_resolution (struct ui_file *file, int from_tty,
struct cmd_list_element *c,
"divide object size in cast"));
/* FIXME-type-allocation: need a way to free this type when
we are done with it. */
- range_type = create_static_range_type ((struct type *) NULL,
+ range_type = create_static_range_type (NULL,
TYPE_TARGET_TYPE (range_type),
low_bound,
new_length + low_bound - 1);
deprecated_set_value_type (arg2,
- create_array_type ((struct type *) NULL,
+ create_array_type (NULL,
element_type,
range_type));
return arg2;
return value_at_lazy (to_type, value_address (arg2));
else
{
+ if (current_language->la_language == language_ada)
+ error (_("Invalid type conversion."));
error (_("Invalid cast."));
- return 0;
}
}
/* Return a value with type TYPE located at ADDR.
Call value_at only if the data needs to be fetched immediately;
- if we can be 'lazy' and defer the fetch, perhaps indefinately, call
+ if we can be 'lazy' and defer the fetch, perhaps indefinitely, call
value_at_lazy instead. value_at_lazy simply records the address of
the data and sets the lazy-evaluation-required flag. The lazy flag
is tested in the value_contents macro, which is used if and when
return val;
}
-/* Return one if VAL does not live in target memory, but should in order
- to operate on it. Otherwise return zero. */
+/* See value.h. */
-int
+bool
value_must_coerce_to_target (struct value *val)
{
struct type *valtype;
if (VALUE_LVAL (val) != not_lval
&& VALUE_LVAL (val) != lval_internalvar
&& VALUE_LVAL (val) != lval_xcallable)
- return 0;
+ return false;
valtype = check_typedef (value_type (val));
case TYPE_CODE_ARRAY:
return TYPE_VECTOR (valtype) ? 0 : 1;
case TYPE_CODE_STRING:
- return 1;
+ return true;
default:
- return 0;
+ return false;
}
}
int i;
struct value *v;
int name_matched = 0;
- char dem_opname[64];
type = check_typedef (type);
for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
{
const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
- /* FIXME! May need to check for ARM demangling here. */
- if (startswith (t_field_name, "__") ||
- startswith (t_field_name, "op") ||
- startswith (t_field_name, "type"))
- {
- if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
- t_field_name = dem_opname;
- else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
- t_field_name = dem_opname;
- }
if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
contained in QUALIFIED_NAME until it either finds a good match or
runs out of namespaces. It stores the overloaded functions in
*OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL,
- argument dependent lookup is not performned. */
+ argument dependent lookup is not performed. */
static int
find_oload_champ_namespace (gdb::array_view<value *> args,
for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
{
const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
- char dem_opname[64];
- if (startswith (t_field_name, "__")
- || startswith (t_field_name, "op")
- || startswith (t_field_name, "type"))
- {
- if (cplus_demangle_opname (t_field_name,
- dem_opname, DMGL_ANSI))
- t_field_name = dem_opname;
- else if (cplus_demangle_opname (t_field_name,
- dem_opname, 0))
- t_field_name = dem_opname;
- }
if (t_field_name && strcmp (t_field_name, name) == 0)
{
int j;
else if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
- TRY
+ try
{
target = value_ind (v);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
if (except.error == MEMORY_ERROR)
{
type. */
return NULL;
}
- throw_exception (except);
+ throw;
}
- END_CATCH
}
else
return NULL;
{
struct value *ret = NULL;
- TRY
+ try
{
ret = value_of_this (lang);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
}
- END_CATCH
return ret;
}
&& TYPE_CODE (array_type) != TYPE_CODE_STRING)
error (_("cannot take slice of non-array"));
+ if (type_not_allocated (array_type))
+ error (_("array not allocated"));
+ if (type_not_associated (array_type))
+ error (_("array not associated"));
+
range_type = TYPE_INDEX_TYPE (array_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
error (_("slice from bad array or bitstring"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
- slice_range_type = create_static_range_type ((struct type *) NULL,
+ slice_range_type = create_static_range_type (NULL,
TYPE_TARGET_TYPE (range_type),
lowbound,
lowbound + length - 1);
LONGEST offset
= (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
- slice_type = create_array_type ((struct type *) NULL,
+ slice_type = create_array_type (NULL,
element_type,
slice_range_type);
TYPE_CODE (slice_type) = TYPE_CODE (array_type);
/* Create a value for a FORTRAN complex number. Currently most of the
time values are coerced to COMPLEX*16 (i.e. a complex number
composed of 2 doubles. This really should be a smarter routine
- that figures out precision inteligently as opposed to assuming
+ that figures out precision intelligently as opposed to assuming
doubles. FIXME: fmb */
struct value *