#endif
int overload_resolution = 0;
+static void
+show_overload_resolution (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Overload resolution in evaluating C++ functions is %s.\n"),
+ value);
+}
/* Find the address of function name NAME in the inferior. */
{
if (SYMBOL_CLASS (sym) != LOC_BLOCK)
{
- error ("\"%s\" exists in this program but is not a function.",
+ error (_("\"%s\" exists in this program but is not a function."),
name);
}
return value_of_variable (sym, NULL);
else
{
if (!target_has_execution)
- error ("evaluation of this expression requires the target program to be active");
+ error (_("evaluation of this expression requires the target program to be active"));
else
- error ("evaluation of this expression requires the program to have a function \"%s\".", name);
+ error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
}
}
}
if (value_logical_not (val))
{
if (!target_has_execution)
- error ("No memory available to program now: you need to start the target first");
+ error (_("No memory available to program now: you need to start the target first"));
else
- error ("No memory available to program: call to malloc failed");
+ error (_("No memory available to program: call to malloc failed"));
}
return val;
}
low_bound = 0, high_bound = 0;
new_length = val_length / element_length;
if (val_length % element_length != 0)
- warning ("array element type size does not divide object size in cast");
+ warning (_("array element type size does not divide object size in cast"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
range_type = create_range_type ((struct type *) NULL,
TYPE_TARGET_TYPE (range_type),
low_bound,
new_length + low_bound - 1);
- arg2->type = create_array_type ((struct type *) NULL,
- element_type, range_type);
+ deprecated_set_value_type (arg2, create_array_type ((struct type *) NULL,
+ element_type, range_type));
return arg2;
}
}
arg2, 0, type2, 1);
if (v)
{
- v->type = type;
+ deprecated_set_value_type (v, type);
return v;
}
}
/* While pointers to methods don't really point to a function */
case TYPE_CODE_METHOD:
- error ("Pointers to methods not supported with HP aCC");
+ error (_("Pointers to methods not supported with HP aCC"));
default:
break; /* fall out and go to normal handling */
{
if (longest >= ((LONGEST) 1 << addr_bit)
|| longest <= -((LONGEST) 1 << addr_bit))
- warning ("value truncated");
+ warning (_("value truncated"));
}
return value_from_longest (type, longest);
}
if (v)
{
v = value_addr (v);
- v->type = type;
+ deprecated_set_value_type (v, type);
return v;
}
}
CORE_ADDR addr2 = value_as_address (arg2);
addr2 -= (VALUE_ADDRESS (v)
+ value_offset (v)
- + VALUE_EMBEDDED_OFFSET (v));
+ + value_embedded_offset (v));
return value_from_pointer (type, addr2);
}
}
}
/* No superclass found, just fall through to change ptr type. */
}
- arg2->type = type;
+ deprecated_set_value_type (arg2, type);
arg2 = value_change_enclosing_type (arg2, type);
- VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */
+ set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
return arg2;
}
else if (VALUE_LVAL (arg2) == lval_memory)
}
else
{
- error ("Invalid cast.");
+ error (_("Invalid cast."));
return 0;
}
}
struct value *val;
if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
- error ("Attempt to dereference a generic pointer.");
+ error (_("Attempt to dereference a generic pointer."));
val = allocate_value (type);
struct value *val;
if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
- error ("Attempt to dereference a generic pointer.");
+ error (_("Attempt to dereference a generic pointer."));
val = allocate_value (type);
struct value *val;
struct frame_id old_frame;
- if (!toval->modifiable)
- error ("Left operand of assignment is not a modifiable lvalue.");
+ if (!deprecated_value_modifiable (toval))
+ error (_("Left operand of assignment is not a modifiable lvalue."));
toval = coerce_ref (toval);
set_internalvar (VALUE_INTERNALVAR (toval), fromval);
val = value_copy (VALUE_INTERNALVAR (toval)->value);
val = value_change_enclosing_type (val, value_enclosing_type (fromval));
- VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
- VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+ set_value_embedded_offset (val, value_embedded_offset (fromval));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
return val;
case lval_internalvar_component:
case lval_memory:
{
- const bfd_byte *dest_buffer;
+ const gdb_byte *dest_buffer;
CORE_ADDR changed_addr;
int changed_len;
- char buffer[sizeof (LONGEST)];
+ gdb_byte buffer[sizeof (LONGEST)];
if (value_bitsize (toval))
{
/ HOST_CHAR_BIT;
if (changed_len > (int) sizeof (LONGEST))
- error ("Can't handle bitfields which don't fit in a %d bit word.",
+ error (_("Can't handle bitfields which don't fit in a %d bit word."),
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
value_reg = VALUE_REGNUM (toval);
if (!frame)
- error ("Value being assigned to is no longer active.");
+ error (_("Value being assigned to is no longer active."));
if (VALUE_LVAL (toval) == lval_register
&& CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
modify it, and copy it back in. */
int amount_copied;
int amount_to_copy;
- char *buffer;
+ gdb_byte *buffer;
int reg_offset;
int byte_offset;
int regno;
amount_to_copy = byte_offset + TYPE_LENGTH (type);
/* And a bounce buffer. Be slightly over generous. */
- buffer = (char *) alloca (amount_to_copy + MAX_REGISTER_SIZE);
+ buffer = alloca (amount_to_copy + MAX_REGISTER_SIZE);
/* Copy it in. */
for (regno = reg_offset, amount_copied = 0;
}
default:
- error ("Left operand of assignment is not an lvalue.");
+ error (_("Left operand of assignment is not an lvalue."));
}
/* Assigning to the stack pointer, frame pointer, and other
val = value_copy (toval);
memcpy (value_contents_raw (val), value_contents (fromval),
TYPE_LENGTH (type));
- val->type = type;
+ deprecated_set_value_type (val, type);
val = value_change_enclosing_type (val, value_enclosing_type (fromval));
- VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
- VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+ set_value_embedded_offset (val, value_embedded_offset (fromval));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
return val;
}
struct value *val;
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Only values in memory can be extended with '@'.");
+ error (_("Only values in memory can be extended with '@'."));
if (count < 1)
- error ("Invalid number %d of repetitions.", count);
+ error (_("Invalid number %d of repetitions."), count);
val = allocate_repeat_value (value_enclosing_type (arg1), count);
{
if (BLOCK_FUNCTION (b)
&& SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
- error ("No frame is currently executing in block %s.",
+ error (_("No frame is currently executing in block %s."),
SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
else
- error ("No frame is currently executing in specified block");
+ error (_("No frame is currently executing in specified block"));
}
}
val = read_var_value (var, frame);
if (!val)
- error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
+ error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
return val;
}
struct type *type = check_typedef (value_type (arg1));
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
(VALUE_ADDRESS (arg1) + value_offset (arg1)));
struct value *retval;
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1) + value_offset (arg1)));
We keep the same location information, which is efficient,
and allows &(&X) to get the location containing the reference. */
arg2 = value_copy (arg1);
- arg2->type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+ deprecated_set_value_type (arg2, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
return arg2;
}
if (TYPE_CODE (type) == TYPE_CODE_FUNC)
return value_coerce_function (arg1);
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
/* Get target memory address */
arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1)
+ value_offset (arg1)
- + VALUE_EMBEDDED_OFFSET (arg1)));
+ + value_embedded_offset (arg1)));
/* This may be a pointer to a base subobject; so remember the
full derived object's type ... */
arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
/* ... and also the relative position of the subobject in the full object */
- VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
+ set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
return arg2;
}
base_type = check_typedef (value_type (arg1));
if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
- error ("not implemented: member types in value_ind");
+ error (_("not implemented: member types in value_ind"));
/* Allow * on an integer so we can cast it to whatever we want.
This returns an int, which seems like the most C-like thing
enc_type = TYPE_TARGET_TYPE (enc_type);
/* Retrieve the enclosing object pointed to */
arg2 = value_at_lazy (enc_type, (value_as_address (arg1)
- - VALUE_POINTED_TO_OFFSET (arg1)));
+ - value_pointed_to_offset (arg1)));
/* Re-adjust type */
- arg2->type = TYPE_TARGET_TYPE (base_type);
+ deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
/* Add embedding info */
arg2 = value_change_enclosing_type (arg2, enc_type);
- VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
+ set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
/* We may be pointing to an object of some derived type */
arg2 = value_full_object (arg2, NULL, 0, 0, 0);
return arg2;
}
- error ("Attempt to take contents of a non-pointer value.");
+ error (_("Attempt to take contents of a non-pointer value."));
return 0; /* For lint -- never reached */
}
\f
-/* Pushing small parts of stack frames. */
-
-/* Push one word (the size of object that a register holds). */
-
-CORE_ADDR
-push_word (CORE_ADDR sp, ULONGEST word)
-{
- int len = DEPRECATED_REGISTER_SIZE;
- char buffer[MAX_REGISTER_SIZE];
-
- store_unsigned_integer (buffer, len, word);
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= len;
- write_memory (sp, buffer, len);
- }
- else
- {
- /* stack grows upward */
- write_memory (sp, buffer, len);
- sp += len;
- }
-
- return sp;
-}
-
-/* Push LEN bytes with data at BUFFER. */
-
-CORE_ADDR
-push_bytes (CORE_ADDR sp, char *buffer, int len)
-{
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= len;
- write_memory (sp, buffer, len);
- }
- else
- {
- /* stack grows upward */
- write_memory (sp, buffer, len);
- sp += len;
- }
-
- return sp;
-}
-
/* Create a value for an array by allocating space in the inferior, copying
the data into that space, and then setting up an array value.
nelem = highbound - lowbound + 1;
if (nelem <= 0)
{
- error ("bad array bounds (%d, %d)", lowbound, highbound);
+ error (_("bad array bounds (%d, %d)"), lowbound, highbound);
}
typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
for (idx = 1; idx < nelem; idx++)
{
if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
{
- error ("array elements must all be the same size");
+ error (_("array elements must all be the same size"));
}
}
copy LEN bytes from PTR in gdb to that address in the inferior. */
addr = allocate_space_in_inferior (len);
- write_memory (addr, ptr, len);
+ write_memory (addr, (gdb_byte *) ptr, len);
val = value_at_lazy (stringtype, addr);
return (val);
int i;
if (t2 == 0)
- internal_error (__FILE__, __LINE__, "typecmp: no argument list");
+ internal_error (__FILE__, __LINE__, _("typecmp: no argument list"));
/* Skip ``this'' argument if applicable. T2 will always include THIS. */
if (staticp)
{
v = value_static_field (type, i);
if (v == 0)
- error ("field %s is nonexistent or has been optimised out",
+ error (_("field %s is nonexistent or has been optimised out"),
name);
}
else
{
v = value_primitive_field (arg1, offset, i, type);
if (v == 0)
- error ("there is no field named %s", name);
+ error (_("there is no field named %s"), name);
}
return v;
}
VALUE_ADDRESS (arg1)
+ value_offset (arg1) + offset);
if (boffset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
/* The virtual base class pointer might have been clobbered by the
user program. Make sure that it still points to a valid memory
base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
if (target_read_memory (base_addr, value_contents_raw (v2),
TYPE_LENGTH (basetype)) != 0)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
VALUE_LVAL (v2) = lval_memory;
VALUE_ADDRESS (v2) = base_addr;
}
VALUE_LVAL (v2) = VALUE_LVAL (arg1);
VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
- v2->offset = value_offset (arg1) + boffset;
+ set_value_offset (v2, value_offset (arg1) + boffset);
if (value_lazy (arg1))
set_value_lazy (v2, 1);
else
void
find_rt_vbase_offset (struct type *type, struct type *basetype,
- const bfd_byte *valaddr, int offset, int *boffset_p,
+ const gdb_byte *valaddr, int offset, int *boffset_p,
int *skip_p)
{
int boffset; /* offset of virtual base */
/* Before the constructor is invoked, things are usually zero'd out. */
if (vtbl == 0)
- error ("Couldn't find virtual table -- object may not be constructed yet.");
+ error (_("Couldn't find virtual table -- object may not be constructed yet."));
/* Find virtual base's offset -- jump over entries for primary base
check_stub_method_group (type, i);
if (j > 0 && args == 0)
- error ("cannot resolve overloaded method `%s': no arguments supplied", name);
+ error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
else if (j == 0 && args == 0)
{
v = value_fn_field (arg1p, f, j, type, offset);
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
value_contents_all (*arg1p),
- offset + VALUE_EMBEDDED_OFFSET (*arg1p),
+ offset + value_embedded_offset (*arg1p),
&base_offset, &skip);
if (skip >= 0)
- error ("Virtual base class offset not found in vtable");
+ error (_("Virtual base class offset not found in vtable"));
}
else
{
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
- const bfd_byte *base_valaddr;
+ const gdb_byte *base_valaddr;
/* The virtual base class pointer might have been clobbered by the
user program. Make sure that it still points to a valid memory
if (offset < 0 || offset >= TYPE_LENGTH (type))
{
- bfd_byte *tmp = alloca (TYPE_LENGTH (baseclass));
+ gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
if (target_read_memory (VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset,
tmp, TYPE_LENGTH (baseclass)) != 0)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
base_valaddr = tmp;
}
else
VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset);
if (base_offset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
}
}
else
}
if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("not implemented: member type in value_struct_elt");
+ error (_("not implemented: member type in value_struct_elt"));
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Attempt to extract a component of a value that is not a %s.", err);
+ error (_("Attempt to extract a component of a value that is not a %s."), err);
/* Assume it's not, unless we see that it is. */
if (static_memfuncp)
return it as a pointer to a method. */
if (destructor_name_p (name, t))
- error ("Cannot get value of destructor");
+ error (_("Cannot get value of destructor"));
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
if (v == (struct value *) - 1)
- error ("Cannot take address of a method");
+ error (_("Cannot take address of a method"));
else if (v == 0)
{
if (TYPE_NFN_FIELDS (t))
- error ("There is no member or method named %s.", name);
+ error (_("There is no member or method named %s."), name);
else
- error ("There is no member named %s.", name);
+ error (_("There is no member named %s."), name);
}
return v;
}
f_index, NULL, 0);
}
if (v == NULL)
- error ("could not find destructor function named %s.", name);
+ error (_("could not find destructor function named %s."), name);
else
return v;
}
else
{
- error ("destructor should not have any argument");
+ error (_("destructor should not have any argument"));
}
}
else
if (v == (struct value *) - 1)
{
- error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
+ error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
}
else if (v == 0)
{
}
if (!v)
- error ("Structure has no component named %s.", name);
+ error (_("Structure has no component named %s."), name);
return v;
}
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
value_contents_all (*argp),
- offset + VALUE_EMBEDDED_OFFSET (*argp),
+ offset + value_embedded_offset (*argp),
&base_offset, &skip);
if (skip >= 0)
- error ("Virtual base class offset not found in vtable");
+ error (_("Virtual base class offset not found in vtable"));
}
else
{
value_contents (*argp) + base_offset,
VALUE_ADDRESS (*argp) + base_offset);
if (base_offset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
}
}
else
}
if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("Not implemented: member type in value_find_oload_lis");
+ error (_("Not implemented: member type in value_find_oload_lis"));
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Attempt to extract a component of a value that is not a struct or union");
+ error (_("Attempt to extract a component of a value that is not a struct or union"));
return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
}
&num_fns,
&basetype, &boffset);
if (!fns_ptr || !num_fns)
- error ("Couldn't find method %s%s%s",
+ error (_("Couldn't find method %s%s%s"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
if (match_quality == INCOMPATIBLE)
{
if (method)
- error ("Cannot resolve method %s%s%s to any overloaded instance",
+ error (_("Cannot resolve method %s%s%s to any overloaded instance"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
- error ("Cannot resolve function %s to any overloaded instance",
+ error (_("Cannot resolve function %s to any overloaded instance"),
func_name);
}
else if (match_quality == NON_STANDARD)
{
if (method)
- warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
+ warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
- warning ("Using non-standard conversion to match function %s to supplied arguments",
+ warning (_("Using non-standard conversion to match function %s to supplied arguments"),
func_name);
}
else
len = cp - dname;
if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
- error ("name of destructor must equal name of class");
+ error (_("name of destructor must equal name of class"));
else
return 1;
}
}
if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("not implemented: member type in check_field");
+ error (_("not implemented: member type in check_field"));
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Internal error: `this' is not an aggregate");
+ error (_("Internal error: `this' is not an aggregate"));
return check_field_in (t, name);
}
return value_namespace_elt (curtype, name, noside);
default:
internal_error (__FILE__, __LINE__,
- "non-aggregate type in value_aggregate_elt");
+ _("non-aggregate type in value_aggregate_elt"));
}
}
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
+ error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
{
{
v = value_static_field (t, i);
if (v == NULL)
- error ("static field %s has been optimized out",
+ error (_("static field %s has been optimized out"),
name);
return v;
}
if (TYPE_FIELD_PACKED (t, i))
- error ("pointers to bitfield members not allowed");
+ error (_("pointers to bitfield members not allowed"));
return value_from_longest
(lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
/* Destructors are a special case. */
if (destructor_name_p (name, t))
{
- error ("member pointers to destructors not implemented yet");
+ error (_("member pointers to destructors not implemented yet"));
}
/* Perform all necessary dereferencing. */
check_stub_method_group (t, i);
if (intype == 0 && j > 1)
- error ("non-unique member `%s' requires type instantiation", name);
+ error (_("non-unique member `%s' requires type instantiation"), name);
if (intype)
{
while (j--)
if (TYPE_FN_FIELD_TYPE (f, j) == intype)
break;
if (j < 0)
- error ("no member function matches that type instantiation");
+ error (_("no member function matches that type instantiation"));
}
else
j = 0;
noside);
if (retval == NULL)
- error ("No symbol \"%s\" in namespace \"%s\".", name,
+ error (_("No symbol \"%s\" in namespace \"%s\"."), name,
TYPE_TAG_NAME (curtype));
return retval;
/* Check if object is in memory */
if (VALUE_LVAL (argp) != lval_memory)
{
- warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
+ warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."), TYPE_NAME (real_type));
return argp;
}
adjusting for the embedded offset of argp if that's what value_rtti_type
used for its computation. */
new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
- (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)));
- new_val->type = value_type (argp);
- VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
+ (using_enc ? 0 : value_embedded_offset (argp)));
+ deprecated_set_value_type (new_val, value_type (argp));
+ set_value_embedded_offset (new_val, (using_enc
+ ? top + value_embedded_offset (argp)
+ : top));
return new_val;
}
if (deprecated_selected_frame == 0)
{
if (complain)
- error ("no frame selected");
+ error (_("no frame selected"));
else
return 0;
}
if (!func)
{
if (complain)
- error ("no `%s' in nameless context", name);
+ error (_("no `%s' in nameless context"), name);
else
return 0;
}
if (dict_empty (BLOCK_DICT (b)))
{
if (complain)
- error ("no args, no `%s'", name);
+ error (_("no args, no `%s'"), name);
else
return 0;
}
if (sym == NULL)
{
if (complain)
- error ("current stack frame does not contain a variable named `%s'", name);
+ error (_("current stack frame does not contain a variable named `%s'"), name);
else
return NULL;
}
ret = read_var_value (sym, deprecated_selected_frame);
if (ret == 0 && complain)
- error ("`%s' argument unreadable", name);
+ error (_("`%s' argument unreadable"), name);
return ret;
}
if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
&& TYPE_CODE (array_type) != TYPE_CODE_STRING
&& TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
- error ("cannot take slice of non-array");
+ error (_("cannot take slice of non-array"));
range_type = TYPE_INDEX_TYPE (array_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
- error ("slice from bad array or bitstring");
+ error (_("slice from bad array or bitstring"));
if (lowbound < lowerbound || length < 0
|| lowbound + length - 1 > upperbound)
- error ("slice out of range");
+ error (_("slice out of range"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
slice_range_type = create_range_type ((struct type *) NULL,
value_contents (array),
lowbound + i);
if (element < 0)
- error ("internal error accessing bitstring");
+ error (_("internal error accessing bitstring"));
else if (element > 0)
{
int j = i % TARGET_CHAR_BIT;
VALUE_LVAL (slice) = VALUE_LVAL (array);
VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
- slice->offset = value_offset (array) + offset;
+ set_value_offset (slice, value_offset (array) + offset);
}
return slice;
}
|| TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
return value_literal_complex (val, value_zero (real_type, not_lval), type);
else
- error ("cannot cast non-number to complex");
+ error (_("cannot cast non-number to complex"));
}
void
_initialize_valops (void)
{
-#if 0
- deprecated_add_show_from_set
- (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
- "Set automatic abandonment of expressions upon failure.",
- &setlist),
- &showlist);
-#endif
-
- deprecated_add_show_from_set
- (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
- "Set overload resolution in evaluating C++ functions.",
- &setlist),
- &showlist);
+ add_setshow_boolean_cmd ("overload-resolution", class_support,
+ &overload_resolution, _("\
+Set overload resolution in evaluating C++ functions."), _("\
+Show overload resolution in evaluating C++ functions."), NULL,
+ NULL,
+ show_overload_resolution,
+ &setlist, &showlist);
overload_resolution = 1;
}
projects / deliverable / binutils-gdb.git / blobdiff