/* Ada language support routines for GDB, the GNU debugger. Copyright
- 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004.
- Free Software Foundation, Inc.
+
+ 1992, 1993, 1994, 1997, 1998, 1999, 2000, 2003, 2004, 2005 Free
+ Software Foundation, Inc.
This file is part of GDB.
#include "block.h"
#include "infcall.h"
#include "dictionary.h"
+#include "exceptions.h"
#ifndef ADA_RETAIN_DOTS
#define ADA_RETAIN_DOTS 0
static int is_dynamic_field (struct type *, int);
-static struct type *to_fixed_variant_branch_type (struct type *, char *,
+static struct type *to_fixed_variant_branch_type (struct type *,
+ const bfd_byte *,
CORE_ADDR, struct value *);
static struct type *to_fixed_array_type (struct type *, struct value *, int);
return fieldno;
if (!maybe_missing)
- error ("Unable to find field %s in struct %s. Aborting",
+ error (_("Unable to find field %s in struct %s. Aborting"),
field_name, TYPE_NAME (type));
return -1;
ADDRESS. */
struct value *
-value_from_contents_and_address (struct type *type, char *valaddr,
+value_from_contents_and_address (struct type *type,
+ const bfd_byte *valaddr,
CORE_ADDR address)
{
struct value *v = allocate_value (type);
if (valaddr == NULL)
- VALUE_LAZY (v) = 1;
+ set_value_lazy (v, 1);
else
- memcpy (VALUE_CONTENTS_RAW (v), valaddr, TYPE_LENGTH (type));
+ memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
VALUE_ADDRESS (v) = address;
if (address != 0)
VALUE_LVAL (v) = lval_memory;
result->bitsize = value_bitsize (val);
result->bitpos = value_bitpos (val);
VALUE_ADDRESS (result) = VALUE_ADDRESS (val) + value_offset (val);
- if (VALUE_LAZY (val)
+ if (value_lazy (val)
|| TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
- VALUE_LAZY (result) = 1;
+ set_value_lazy (result, 1);
else
- memcpy (VALUE_CONTENTS_RAW (result), VALUE_CONTENTS (val),
+ memcpy (value_contents_raw (result), value_contents (val),
TYPE_LENGTH (type));
return result;
}
}
-static char *
-cond_offset_host (char *valaddr, long offset)
+static const bfd_byte *
+cond_offset_host (const bfd_byte *valaddr, long offset)
{
if (valaddr == NULL)
return NULL;
check_size (const struct type *type)
{
if (TYPE_LENGTH (type) > varsize_limit)
- error ("object size is larger than varsize-limit");
+ error (_("object size is larger than varsize-limit"));
}
case TYPE_CODE_INT:
return value_from_longest (type, max_of_type (type));
default:
- error ("Unexpected type in discrete_type_high_bound.");
+ error (_("Unexpected type in discrete_type_high_bound."));
}
}
case TYPE_CODE_INT:
return value_from_longest (type, min_of_type (type));
default:
- error ("Unexpected type in discrete_type_low_bound.");
+ error (_("Unexpected type in discrete_type_low_bound."));
}
}
{
main_program_name_addr = SYMBOL_VALUE_ADDRESS (msym);
if (main_program_name_addr == 0)
- error ("Invalid address for Ada main program name.");
+ error (_("Invalid address for Ada main program name."));
extract_string (main_program_name_addr, main_program_name);
return main_program_name;
strlen (mapping->decoded)) != 0; mapping += 1)
;
if (mapping->encoded == NULL)
- error ("invalid Ada operator name: %s", p);
+ error (_("invalid Ada operator name: %s"), p);
strcpy (encoding_buffer + k, mapping->encoded);
k += strlen (mapping->encoded);
break;
LONGEST addr;
if (desc_bounds_type == NULL)
- error ("Bad GNAT array descriptor");
+ error (_("Bad GNAT array descriptor"));
/* NOTE: The following calculation is not really kosher, but
since desc_type is an XVE-encoded type (and shouldn't be),
else if (is_thick_pntr (type))
return value_struct_elt (&arr, NULL, "P_BOUNDS", NULL,
- "Bad GNAT array descriptor");
+ _("Bad GNAT array descriptor"));
else
return NULL;
}
return thin_data_pntr (arr);
else if (is_thick_pntr (type))
return value_struct_elt (&arr, NULL, "P_ARRAY", NULL,
- "Bad GNAT array descriptor");
+ _("Bad GNAT array descriptor"));
else
return NULL;
}
desc_one_bound (struct value *bounds, int i, int which)
{
return value_struct_elt (&bounds, NULL, bound_name[2 * i + which - 2], NULL,
- "Bad GNAT array descriptor bounds");
+ _("Bad GNAT array descriptor bounds"));
}
/* If BOUNDS is an array-bounds structure type, return the bit position
{
struct value *arrVal = ada_coerce_to_simple_array_ptr (arr);
if (arrVal == NULL)
- error ("Bounds unavailable for null array pointer.");
+ error (_("Bounds unavailable for null array pointer."));
return value_ind (arrVal);
}
else if (ada_is_packed_array_type (value_type (arr)))
struct value *mark = value_mark ();
struct value *dummy = value_from_longest (builtin_type_long, 0);
struct type *result;
- dummy->type = type;
+ deprecated_set_value_type (dummy, type);
result = ada_type_of_array (dummy, 0);
value_free_to_mark (mark);
return result;
sym = standard_lookup (name, get_selected_block (0), VAR_DOMAIN);
if (sym == NULL || SYMBOL_TYPE (sym) == NULL)
{
- lim_warning ("could not find bounds information on packed array");
+ lim_warning (_("could not find bounds information on packed array"));
return NULL;
}
shadow_type = SYMBOL_TYPE (sym);
if (TYPE_CODE (shadow_type) != TYPE_CODE_ARRAY)
{
- lim_warning ("could not understand bounds information on packed array");
+ lim_warning (_("could not understand bounds information on packed array"));
return NULL;
}
if (sscanf (tail + sizeof ("___XP") - 1, "%ld", &bits) != 1)
{
lim_warning
- ("could not understand bit size information on packed array");
+ (_("could not understand bit size information on packed array"));
return NULL;
}
type = decode_packed_array_type (value_type (arr));
if (type == NULL)
{
- error ("can't unpack array");
+ error (_("can't unpack array"));
return NULL;
}
if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY
|| TYPE_FIELD_BITSIZE (elt_type, 0) == 0)
error
- ("attempt to do packed indexing of something other than a packed array");
+ (_("attempt to do packed indexing of something other than a packed array"));
else
{
struct type *range_type = TYPE_INDEX_TYPE (elt_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
{
- lim_warning ("don't know bounds of array");
+ lim_warning (_("don't know bounds of array"));
lowerbound = upperbound = 0;
}
idx = value_as_long (value_pos_atr (ind[i]));
if (idx < lowerbound || idx > upperbound)
- lim_warning ("packed array index %ld out of bounds", (long) idx);
+ lim_warning (_("packed array index %ld out of bounds"), (long) idx);
bits = TYPE_FIELD_BITSIZE (elt_type, 0);
elt_total_bit_offset += (idx - lowerbound) * bits;
elt_type = ada_check_typedef (TYPE_TARGET_TYPE (elt_type));
Assumes 0 <= BIT_OFFSET < HOST_CHAR_BIT. */
struct value *
-ada_value_primitive_packed_val (struct value *obj, char *valaddr, long offset,
- int bit_offset, int bit_size,
+ada_value_primitive_packed_val (struct value *obj, const bfd_byte *valaddr,
+ long offset, int bit_offset, int bit_size,
struct type *type)
{
struct value *v;
v = allocate_value (type);
bytes = (unsigned char *) (valaddr + offset);
}
- else if (VALUE_LAZY (obj))
+ else if (value_lazy (obj))
{
v = value_at (type,
VALUE_ADDRESS (obj) + value_offset (obj) + offset);
else
{
v = allocate_value (type);
- bytes = (unsigned char *) VALUE_CONTENTS (obj) + offset;
+ bytes = (unsigned char *) value_contents (obj) + offset;
}
if (obj != NULL)
}
else
v->bitsize = bit_size;
- unpacked = (unsigned char *) VALUE_CONTENTS (v);
+ unpacked = (unsigned char *) value_contents (v);
srcBitsLeft = bit_size;
nsrc = len;
TARGET, starting at bit offset TARG_OFFSET. SOURCE and TARGET must
not overlap. */
static void
-move_bits (char *target, int targ_offset, char *source, int src_offset, int n)
+move_bits (bfd_byte *target, int targ_offset, const bfd_byte *source,
+ int src_offset, int n)
{
unsigned int accum, mask;
int accum_bits, chunk_size;
struct type *type = value_type (toval);
int bits = value_bitsize (toval);
- 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);
read_memory (VALUE_ADDRESS (toval) + value_offset (toval), buffer, len);
if (BITS_BIG_ENDIAN)
move_bits (buffer, value_bitpos (toval),
- VALUE_CONTENTS (fromval),
+ value_contents (fromval),
TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT -
bits, bits);
else
- move_bits (buffer, value_bitpos (toval), VALUE_CONTENTS (fromval),
+ move_bits (buffer, value_bitpos (toval), value_contents (fromval),
0, bits);
write_memory (VALUE_ADDRESS (toval) + value_offset (toval), buffer,
len);
val = value_copy (toval);
- memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+ memcpy (value_contents_raw (val), value_contents (fromval),
TYPE_LENGTH (type));
- val->type = type;
+ deprecated_set_value_type (val, type);
return val;
}
for (k = 0; k < arity; k += 1)
{
if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY)
- error ("too many subscripts (%d expected)", k);
+ error (_("too many subscripts (%d expected)"), k);
elt = value_subscript (elt, value_pos_atr (ind[k]));
}
return elt;
struct value *idx;
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
- error ("too many subscripts (%d expected)", k);
+ error (_("too many subscripts (%d expected)"), k);
arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
value_copy (arr));
get_discrete_bounds (TYPE_INDEX_TYPE (type), &lwb, &upb);
if (ada_opname_table[i].op == op)
return ada_opname_table[i].decoded;
}
- error ("Could not find operator name for opcode");
+ error (_("Could not find operator name for opcode"));
}
break;
default:
- error ("Unexpected operator during name resolution");
+ error (_("Unexpected operator during name resolution"));
}
argvec = (struct value * *) alloca (sizeof (struct value *) * (nargs + 1));
}
if (n_candidates == 0)
- error ("No definition found for %s",
+ error (_("No definition found for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
else if (n_candidates == 1)
i = 0;
SYMBOL_LINKAGE_NAME (exp->elts[pc + 2].symbol),
context_type);
if (i < 0)
- error ("Could not find a match for %s",
+ error (_("Could not find a match for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
}
else
{
- printf_filtered ("Multiple matches for %s\n",
+ printf_filtered (_("Multiple matches for %s\n"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
user_select_syms (candidates, n_candidates, 1);
i = 0;
SYMBOL_LINKAGE_NAME (exp->elts[pc + 5].symbol),
context_type);
if (i < 0)
- error ("Could not find a match for %s",
+ error (_("Could not find a match for %s"),
SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
}
return -1;
else if (m > 1)
{
- printf_filtered ("Multiple matches for %s\n", name);
+ printf_filtered (_("Multiple matches for %s\n"), name);
user_select_syms (syms, m, 1);
return 0;
}
int first_choice = (max_results == 1) ? 1 : 2;
if (max_results < 1)
- error ("Request to select 0 symbols!");
+ error (_("Request to select 0 symbols!"));
if (nsyms <= 1)
return nsyms;
- printf_unfiltered ("[0] cancel\n");
+ printf_unfiltered (_("[0] cancel\n"));
if (max_results > 1)
- printf_unfiltered ("[1] all\n");
+ printf_unfiltered (_("[1] all\n"));
sort_choices (syms, nsyms);
{
struct symtab_and_line sal =
find_function_start_sal (syms[i].sym, 1);
- printf_unfiltered ("[%d] %s at %s:%d\n", i + first_choice,
- SYMBOL_PRINT_NAME (syms[i].sym),
- (sal.symtab == NULL
- ? "<no source file available>"
- : sal.symtab->filename), sal.line);
+ if (sal.symtab == NULL)
+ printf_unfiltered (_("[%d] %s at <no source file available>:%d\n"),
+ i + first_choice,
+ SYMBOL_PRINT_NAME (syms[i].sym),
+ sal.line);
+ else
+ printf_unfiltered (_("[%d] %s at %s:%d\n"), i + first_choice,
+ SYMBOL_PRINT_NAME (syms[i].sym),
+ sal.symtab->filename, sal.line);
continue;
}
else
struct symtab *symtab = symtab_for_sym (syms[i].sym);
if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
- printf_unfiltered ("[%d] %s at %s:%d\n",
+ printf_unfiltered (_("[%d] %s at %s:%d\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym),
symtab->filename, SYMBOL_LINE (syms[i].sym));
printf_unfiltered ("[%d] ", i + first_choice);
ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
gdb_stdout, -1, 0);
- printf_unfiltered ("'(%s) (enumeral)\n",
+ printf_unfiltered (_("'(%s) (enumeral)\n"),
SYMBOL_PRINT_NAME (syms[i].sym));
}
else if (symtab != NULL)
printf_unfiltered (is_enumeral
- ? "[%d] %s in %s (enumeral)\n"
- : "[%d] %s at %s:?\n",
+ ? _("[%d] %s in %s (enumeral)\n")
+ : _("[%d] %s at %s:?\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym),
symtab->filename);
else
printf_unfiltered (is_enumeral
- ? "[%d] %s (enumeral)\n"
- : "[%d] %s at ?\n",
+ ? _("[%d] %s (enumeral)\n")
+ : _("[%d] %s at ?\n"),
i + first_choice,
SYMBOL_PRINT_NAME (syms[i].sym));
}
args = command_line_input ((char *) NULL, 0, annotation_suffix);
if (args == NULL)
- error_no_arg ("one or more choice numbers");
+ error_no_arg (_("one or more choice numbers"));
n_chosen = 0;
while (isspace (*args))
args += 1;
if (*args == '\0' && n_chosen == 0)
- error_no_arg ("one or more choice numbers");
+ error_no_arg (_("one or more choice numbers"));
else if (*args == '\0')
break;
choice = strtol (args, &args2, 10);
if (args == args2 || choice < 0
|| choice > n_choices + first_choice - 1)
- error ("Argument must be choice number");
+ error (_("Argument must be choice number"));
args = args2;
if (choice == 0)
- error ("cancelled");
+ error (_("cancelled"));
if (choice < first_choice)
{
}
if (n_chosen > max_results)
- error ("Select no more than %d of the above", max_results);
+ error (_("Select no more than %d of the above"), max_results);
return n_chosen;
}
type = SYMBOL_TYPE (sym);
if (type == NULL || TYPE_NFIELDS (type) < 1)
- error ("Improperly encoded renaming.");
+ error (_("Improperly encoded renaming."));
raw_name = TYPE_FIELD_NAME (type, 0);
len = (raw_name == NULL ? 0 : strlen (raw_name)) - 5;
if (len <= 0)
- error ("Improperly encoded renaming.");
+ error (_("Improperly encoded renaming."));
result = xmalloc (len + 1);
strncpy (result, raw_name, len);
*sp = gdbarch_frame_align (current_gdbarch, *sp);
}
- write_memory (VALUE_ADDRESS (val), VALUE_CONTENTS_RAW (val), len);
+ write_memory (VALUE_ADDRESS (val), value_contents_raw (val), len);
}
return val;
struct value *val;
actual_type = ada_check_typedef (value_type (actual));
val = allocate_value (actual_type);
- memcpy ((char *) VALUE_CONTENTS_RAW (val),
- (char *) VALUE_CONTENTS (actual),
+ memcpy ((char *) value_contents_raw (val),
+ (char *) value_contents (actual),
TYPE_LENGTH (actual_type));
actual = ensure_lval (val, sp);
}
for (i = ada_array_arity (ada_check_typedef (value_type (arr))); i > 0; i -= 1)
{
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 0)),
desc_bound_bitpos (bounds_type, i, 0),
desc_bound_bitsize (bounds_type, i, 0));
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 1)),
desc_bound_bitpos (bounds_type, i, 1),
desc_bound_bitsize (bounds_type, i, 1));
bounds = ensure_lval (bounds, sp);
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (ensure_lval (arr, sp)),
fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type));
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (bounds),
fat_pntr_bounds_bitpos (desc_type),
fat_pntr_bounds_bitsize (desc_type));
ADDRESS. */
static struct value *
-value_tag_from_contents_and_address (struct type *type, char *valaddr,
+value_tag_from_contents_and_address (struct type *type,
+ const bfd_byte *valaddr,
CORE_ADDR address)
{
int tag_byte_offset, dummy1, dummy2;
if (find_struct_field ("_tag", type, 0, &tag_type, &tag_byte_offset,
&dummy1, &dummy2))
{
- char *valaddr1 = (valaddr == NULL) ? NULL : valaddr + tag_byte_offset;
+ const bfd_byte *valaddr1 = ((valaddr == NULL)
+ ? NULL
+ : valaddr + tag_byte_offset);
CORE_ADDR address1 = (address == 0) ? 0 : address + tag_byte_offset;
return value_from_contents_and_address (tag_type, valaddr1, address1);
int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
- return ada_value_primitive_packed_val (arg1, VALUE_CONTENTS (arg1),
+ return ada_value_primitive_packed_val (arg1, value_contents (arg1),
offset + bit_pos / 8,
bit_pos % 8, bit_size, type);
}
if (err == NULL)
return NULL;
else
- error ("Bad value type in a %s.", err);
+ error (_("Bad value type in a %s."), err);
}
t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
if (err == NULL)
return NULL;
else
- error ("Bad value type in a %s.", err);
+ error (_("Bad value type in a %s."), err);
}
t1 = ada_check_typedef (t1);
if (TYPE_CODE (t1) == TYPE_CODE_PTR)
if (err == NULL)
return NULL;
else
- error ("Attempt to extract a component of a value that is not a %s.",
+ error (_("Attempt to extract a component of a value that is not a %s."),
err);
}
if (TYPE_CODE (t) == TYPE_CODE_PTR)
address = value_as_address (arg);
else
- address = unpack_pointer (t, VALUE_CONTENTS (arg));
+ address = unpack_pointer (t, value_contents (arg));
t1 = ada_to_fixed_type (ada_get_base_type (t1), NULL, address, NULL);
if (find_struct_field (name, t1, 0,
}
if (v == NULL && err != NULL)
- error ("There is no member named %s.", name);
+ error (_("There is no member named %s."), name);
return v;
}
{
target_terminal_ours ();
gdb_flush (gdb_stdout);
- fprintf_unfiltered (gdb_stderr, "Type ");
- if (type == NULL)
- fprintf_unfiltered (gdb_stderr, "(null)");
- else
- type_print (type, "", gdb_stderr, -1);
- error (" is not a structure or union type");
+ if (type == NULL)
+ error (_("Type (null) is not a structure or union type"));
+ else
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" is not a structure or union type"));
+ }
}
}
{
target_terminal_ours ();
gdb_flush (gdb_stdout);
- fprintf_unfiltered (gdb_stderr, "Type ");
- type_print (type, "", gdb_stderr, -1);
- fprintf_unfiltered (gdb_stderr, " has no component named ");
- error ("%s", name == NULL ? "<null>" : name);
+ if (name == NULL)
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" has no component named <null>"));
+ }
+ else
+ {
+ /* XXX: type_sprint */
+ fprintf_unfiltered (gdb_stderr, _("Type "));
+ type_print (type, "", gdb_stderr, -1);
+ error (_(" has no component named %s"), name);
+ }
}
return NULL;
int
ada_which_variant_applies (struct type *var_type, struct type *outer_type,
- char *outer_valaddr)
+ const bfd_byte *outer_valaddr)
{
int others_clause;
int i;
byte-aligned. */
struct type *
-ada_template_to_fixed_record_type_1 (struct type *type, char *valaddr,
+ada_template_to_fixed_record_type_1 (struct type *type,
+ const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval0,
int keep_dynamic_fields)
{
the current RTYPE length might be good enough for our purposes. */
if (TYPE_LENGTH (type) <= 0)
{
- warning ("Invalid type size for `%s' detected: %d.",
- TYPE_NAME (rtype) ? TYPE_NAME (rtype) : "<unnamed>",
- TYPE_LENGTH (type));
+ if (TYPE_NAME (rtype))
+ warning (_("Invalid type size for `%s' detected: %d."),
+ TYPE_NAME (rtype), TYPE_LENGTH (type));
+ else
+ warning (_("Invalid type size for <unnamed> detected: %d."),
+ TYPE_LENGTH (type));
}
else
{
value_free_to_mark (mark);
if (TYPE_LENGTH (rtype) > varsize_limit)
- error ("record type with dynamic size is larger than varsize-limit");
+ error (_("record type with dynamic size is larger than varsize-limit"));
return rtype;
}
of 1. */
static struct type *
-template_to_fixed_record_type (struct type *type, char *valaddr,
+template_to_fixed_record_type (struct type *type, const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval0)
{
return ada_template_to_fixed_record_type_1 (type, valaddr,
contains the necessary discriminant values. */
static struct type *
-to_record_with_fixed_variant_part (struct type *type, char *valaddr,
+to_record_with_fixed_variant_part (struct type *type, const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval0)
{
struct value *mark = value_mark ();
shortcut and suspect the compiler should be altered. FIXME. */
static struct type *
-to_fixed_record_type (struct type *type0, char *valaddr,
+to_fixed_record_type (struct type *type0, const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
struct type *templ_type;
indicated in the union's type name. */
static struct type *
-to_fixed_variant_branch_type (struct type *var_type0, char *valaddr,
+to_fixed_variant_branch_type (struct type *var_type0, const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
int which;
which =
ada_which_variant_applies (var_type,
- value_type (dval), VALUE_CONTENTS (dval));
+ value_type (dval), value_contents (dval));
if (which < 0)
return empty_record (TYPE_OBJFILE (var_type));
result, range_type);
}
if (!ignore_too_big && TYPE_LENGTH (result) > varsize_limit)
- error ("array type with dynamic size is larger than varsize-limit");
+ error (_("array type with dynamic size is larger than varsize-limit"));
}
TYPE_FLAGS (result) |= TYPE_FLAG_FIXED_INSTANCE;
ADDRESS or in VALADDR contains these discriminants. */
struct type *
-ada_to_fixed_type (struct type *type, char *valaddr,
+ada_to_fixed_type (struct type *type, const bfd_byte *valaddr,
CORE_ADDR address, struct value *dval)
{
type = ada_check_typedef (type);
struct type *type = value_type (arg);
if (!discrete_type_p (type))
- error ("'POS only defined on discrete types");
+ error (_("'POS only defined on discrete types"));
if (TYPE_CODE (type) == TYPE_CODE_ENUM)
{
if (v == TYPE_FIELD_BITPOS (type, i))
return i;
}
- error ("enumeration value is invalid: can't find 'POS");
+ error (_("enumeration value is invalid: can't find 'POS"));
}
else
return value_as_long (arg);
value_val_atr (struct type *type, struct value *arg)
{
if (!discrete_type_p (type))
- error ("'VAL only defined on discrete types");
+ error (_("'VAL only defined on discrete types"));
if (!integer_type_p (value_type (arg)))
- error ("'VAL requires integral argument");
+ error (_("'VAL requires integral argument"));
if (TYPE_CODE (type) == TYPE_CODE_ENUM)
{
long pos = value_as_long (arg);
if (pos < 0 || pos >= TYPE_NFIELDS (type))
- error ("argument to 'VAL out of range");
+ error (_("argument to 'VAL out of range"));
return value_from_longest (type, TYPE_FIELD_BITPOS (type, pos));
}
else
/* The address of the aligned value in an object at address VALADDR
having type TYPE. Assumes ada_is_aligner_type (TYPE). */
-char *
-ada_aligned_value_addr (struct type *type, char *valaddr)
+const bfd_byte *
+ada_aligned_value_addr (struct type *type, const bfd_byte *valaddr)
{
if (ada_is_aligner_type (type))
return ada_aligned_value_addr (TYPE_FIELD_TYPE (type, 0),
if (TYPE_LENGTH (type2) != TYPE_LENGTH (type)
|| TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
!= TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
- error ("Incompatible types in assignment");
- val->type = type;
+ error (_("Incompatible types in assignment"));
+ deprecated_set_value_type (val, type);
}
return val;
}
v2 = value_as_long (arg2);
if (v2 == 0)
- error ("second operand of %s must not be zero.", op_string (op));
+ error (_("second operand of %s must not be zero."), op_string (op));
if (TYPE_UNSIGNED (type1) || op == BINOP_MOD)
return value_binop (arg1, arg2, op);
}
val = allocate_value (type1);
- store_unsigned_integer (VALUE_CONTENTS_RAW (val),
+ store_unsigned_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)), v);
return val;
}
arg2 = ada_coerce_to_simple_array (arg2);
if (TYPE_CODE (value_type (arg1)) != TYPE_CODE_ARRAY
|| TYPE_CODE (value_type (arg2)) != TYPE_CODE_ARRAY)
- error ("Attempt to compare array with non-array");
+ error (_("Attempt to compare array with non-array"));
/* FIXME: The following works only for types whose
representations use all bits (no padding or undefined bits)
and do not have user-defined equality. */
return
TYPE_LENGTH (value_type (arg1)) == TYPE_LENGTH (value_type (arg2))
- && memcmp (VALUE_CONTENTS (arg1), VALUE_CONTENTS (arg2),
+ && memcmp (value_contents (arg1), value_contents (arg2),
TYPE_LENGTH (value_type (arg1))) == 0;
}
return value_equal (arg1, arg2);
arg2 = cast_to_fixed (value_type (arg1), arg2);
else if (ada_is_fixed_point_type (value_type (arg2)))
error
- ("Fixed-point values must be assigned to fixed-point variables");
+ (_("Fixed-point values must be assigned to fixed-point variables"));
else
arg2 = coerce_for_assign (value_type (arg1), arg2);
return ada_value_assign (arg1, arg2);
if ((ada_is_fixed_point_type (value_type (arg1))
|| ada_is_fixed_point_type (value_type (arg2)))
&& value_type (arg1) != value_type (arg2))
- error ("Operands of fixed-point addition must have the same type");
+ error (_("Operands of fixed-point addition must have the same type"));
return value_cast (value_type (arg1), value_add (arg1, arg2));
case BINOP_SUB:
if ((ada_is_fixed_point_type (value_type (arg1))
|| ada_is_fixed_point_type (value_type (arg2)))
&& value_type (arg1) != value_type (arg2))
- error ("Operands of fixed-point subtraction must have the same type");
+ error (_("Operands of fixed-point subtraction must have the same type"));
return value_cast (value_type (arg1), value_sub (arg1, arg2));
case BINOP_MUL:
/* Only encountered when an unresolved symbol occurs in a
context other than a function call, in which case, it is
illegal. */
- error ("Unexpected unresolved symbol, %s, during evaluation",
+ error (_("Unexpected unresolved symbol, %s, during evaluation"),
SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol));
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
if (exp->elts[*pos].opcode == OP_VAR_VALUE
&& SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)
- error ("Unexpected unresolved symbol, %s, during evaluation",
+ error (_("Unexpected unresolved symbol, %s, during evaluation"),
SYMBOL_PRINT_NAME (exp->elts[pc + 5].symbol));
else
{
type = ada_check_typedef (TYPE_TARGET_TYPE (type));
break;
default:
- error ("cannot subscript or call something of type `%s'",
+ error (_("cannot subscript or call something of type `%s'"),
ada_type_name (value_type (argvec[0])));
break;
}
arity = ada_array_arity (type);
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("cannot subscript or call a record");
+ error (_("cannot subscript or call a record"));
if (arity != nargs)
- error ("wrong number of subscripts; expecting %d", arity);
+ error (_("wrong number of subscripts; expecting %d"), arity);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (ada_aligned_type (type));
return
{
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("element type of array unknown");
+ error (_("element type of array unknown"));
else
return allocate_value (ada_aligned_type (type));
}
{
type = ada_array_element_type (type, nargs);
if (type == NULL)
- error ("element type of array unknown");
+ error (_("element type of array unknown"));
else
return allocate_value (ada_aligned_type (type));
}
nargs, argvec + 1));
default:
- error ("Attempt to index or call something other than an "
- "array or function");
+ error (_("Attempt to index or call something other than an \
+array or function"));
}
case TERNOP_SLICE:
ada_aligned_type (TYPE_TARGET_TYPE (value_type (array)));
if (ada_is_packed_array_type (value_type (array)))
- error ("cannot slice a packed array");
+ error (_("cannot slice a packed array"));
/* If this is a reference to an array or an array lvalue,
convert to a pointer. */
type later down the road if the debug info generated by
the compiler is incorrect or incomplete. */
if (!ada_is_simple_array_type (value_type (array)))
- error ("cannot take slice of non-array");
+ error (_("cannot take slice of non-array"));
if (TYPE_CODE (value_type (array)) == TYPE_CODE_PTR)
{
switch (TYPE_CODE (type))
{
default:
- lim_warning ("Membership test incompletely implemented; "
- "always returns true");
+ lim_warning (_("Membership test incompletely implemented; \
+always returns true"));
return value_from_longest (builtin_type_int, (LONGEST) 1);
case TYPE_CODE_RANGE:
tem = longest_to_int (exp->elts[pc + 1].longconst);
if (tem < 1 || tem > ada_array_arity (value_type (arg2)))
- error ("invalid dimension number to '%s", "range");
+ error (_("invalid dimension number to 'range"));
arg3 = ada_array_bound (arg2, tem, 1);
arg2 = ada_array_bound (arg2, tem, 0);
}
if (exp->elts[*pos].opcode != OP_LONG)
- error ("illegal operand to '%s", ada_attribute_name (op));
+ error (_("Invalid operand to '%s"), ada_attribute_name (op));
tem = longest_to_int (exp->elts[*pos + 2].longconst);
*pos += 4;
arg1 = ada_coerce_to_simple_array (arg1);
if (tem < 1 || tem > ada_array_arity (value_type (arg1)))
- error ("invalid dimension number to '%s",
+ error (_("invalid dimension number to '%s"),
ada_attribute_name (op));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
type = ada_index_type (value_type (arg1), tem);
if (type == NULL)
error
- ("attempt to take bound of something that is not an array");
+ (_("attempt to take bound of something that is not an array"));
return allocate_value (type);
}
switch (op)
{
default: /* Should never happen. */
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
return ada_array_bound (arg1, tem, 0);
case OP_ATR_LAST:
switch (op)
{
default:
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
return discrete_type_low_bound (range_type);
case OP_ATR_LAST:
return discrete_type_high_bound (range_type);
case OP_ATR_LENGTH:
- error ("the 'length attribute applies only to array types");
+ error (_("the 'length attribute applies only to array types"));
}
}
else if (TYPE_CODE (type_arg) == TYPE_CODE_FLT)
- error ("unimplemented type attribute");
+ error (_("unimplemented type attribute"));
else
{
LONGEST low, high;
type_arg = decode_packed_array_type (type_arg);
if (tem < 1 || tem > ada_array_arity (type_arg))
- error ("invalid dimension number to '%s",
+ error (_("invalid dimension number to '%s"),
ada_attribute_name (op));
type = ada_index_type (type_arg, tem);
if (type == NULL)
error
- ("attempt to take bound of something that is not an array");
+ (_("attempt to take bound of something that is not an array"));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (type);
switch (op)
{
default:
- error ("unexpected attribute encountered");
+ error (_("unexpected attribute encountered"));
case OP_ATR_FIRST:
low = ada_array_bound_from_type (type_arg, tem, 0, &type);
return value_from_longest (type, low);
goto nosideret;
if (!ada_is_modular_type (type_arg))
- error ("'modulus must be applied to modular type");
+ error (_("'modulus must be applied to modular type"));
return value_from_longest (TYPE_TARGET_TYPE (type_arg),
ada_modulus (type_arg));
{
struct type *arrType = ada_type_of_array (arg1, 0);
if (arrType == NULL)
- error ("Attempt to dereference null array pointer.");
+ error (_("Attempt to dereference null array pointer."));
return value_at_lazy (arrType, 0);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR
/* GDB allows dereferencing an int. */
return value_zero (builtin_type_int, lval_memory);
else
- error ("Attempt to take contents of a non-pointer value.");
+ error (_("Attempt to take contents of a non-pointer value."));
}
arg1 = ada_coerce_ref (arg1); /* FIXME: What is this for?? */
type = ada_check_typedef (value_type (arg1));
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
return allocate_value (builtin_type_void);
else
- error ("Attempt to use a type name as an expression");
+ error (_("Attempt to use a type name as an expression"));
}
nosideret:
case 'G':
return get_var_value ("DEBUG_STRING_G", 0);
default:
- error ("invalid VAX floating-point type");
+ error (_("invalid VAX floating-point type"));
}
}
\f
L = get_int_var_value (name_buf, &ok);
if (!ok)
{
- lim_warning ("Unknown lower bound, using 1.");
+ lim_warning (_("Unknown lower bound, using 1."));
L = 1;
}
}
U = get_int_var_value (name_buf, &ok);
if (!ok)
{
- lim_warning ("Unknown upper bound, using %ld.", (long) L);
+ lim_warning (_("Unknown upper bound, using %ld."), (long) L);
U = L;
}
}
case UNOP_IN_RANGE:
case UNOP_QUAL:
- fprintf_filtered (stream, "Type @");
+ /* XXX: gdb_sprint_host_address, type_sprint */
+ fprintf_filtered (stream, _("Type @"));
gdb_print_host_address (exp->elts[pc + 1].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[pc + 1].type, NULL, stream, 0);
return;
case BINOP_IN_BOUNDS:
+ /* XXX: sprint_subexp */
*pos += oplen;
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
*pos += oplen;
if (prec >= PREC_EQUAL)
fputs_filtered ("(", stream);
+ /* XXX: sprint_subexp */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
print_subexp (exp, pos, stream, PREC_EQUAL);
case UNOP_IN_RANGE:
*pos += oplen;
+ /* XXX: sprint_subexp */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" in ", stream);
LA_PRINT_TYPE (exp->elts[pc + 1].type, "", stream, 1, 0);
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
0, "<?type?>", objfile);
- warning ("internal error: no Ada fundamental type %d", typeid);
+ warning (_("internal error: no Ada fundamental type %d"), typeid);
break;
case FT_VOID:
type = init_type (TYPE_CODE_VOID,