X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=e86b532e40be696a6630a2fc8d81c38fa29e8d1a;hb=24b06219744627c597d799c1aafb2b2322ac3c3e;hp=40290d4a721c83e82e3e2ae9677db726402f9e9b;hpb=25ae5d16b1e30cc2bc1f2eb5b51553ea6413433c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 40290d4a72..e86b532e40 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1,6 +1,7 @@ /* Perform non-arithmetic operations on values, for GDB. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 + + Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, + 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GDB. @@ -17,8 +18,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "symtab.h" @@ -125,6 +126,14 @@ static int auto_abandon = 0; #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. */ @@ -137,7 +146,7 @@ find_function_in_inferior (const char *name) { 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); @@ -158,9 +167,9 @@ find_function_in_inferior (const char *name) 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); } } } @@ -179,9 +188,9 @@ value_allocate_space_in_inferior (int len) 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; } @@ -232,15 +241,15 @@ value_cast (struct type *type, struct value *arg2) 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; } } @@ -281,7 +290,7 @@ value_cast (struct type *type, struct value *arg2) arg2, 0, type2, 1); if (v) { - v->type = type; + deprecated_set_value_type (v, type); return v; } } @@ -305,13 +314,13 @@ value_cast (struct type *type, struct value *arg2) case TYPE_CODE_MEMBER: retvalp = value_from_longest (type, value_as_long (arg2)); /* force evaluation */ - ptr = (unsigned int *) VALUE_CONTENTS (retvalp); + ptr = (unsigned int *) value_contents (retvalp); *ptr &= ~0x20000000; /* zap 29th bit to remove bias */ return retvalp; /* 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 */ @@ -325,7 +334,7 @@ value_cast (struct type *type, struct value *arg2) sees a cast as a simple reinterpretation of the pointer's bits. */ if (code2 == TYPE_CODE_PTR) - longest = extract_unsigned_integer (VALUE_CONTENTS (arg2), + longest = extract_unsigned_integer (value_contents (arg2), TYPE_LENGTH (type2)); else longest = value_as_long (arg2); @@ -353,7 +362,7 @@ value_cast (struct type *type, struct value *arg2) { if (longest >= ((LONGEST) 1 << addr_bit) || longest <= -((LONGEST) 1 << addr_bit)) - warning ("value truncated"); + warning (_("value truncated")); } return value_from_longest (type, longest); } @@ -379,7 +388,7 @@ value_cast (struct type *type, struct value *arg2) if (v) { v = value_addr (v); - v->type = type; + deprecated_set_value_type (v, type); return v; } } @@ -397,16 +406,16 @@ value_cast (struct type *type, struct value *arg2) 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) @@ -417,7 +426,7 @@ value_cast (struct type *type, struct value *arg2) } else { - error ("Invalid cast."); + error (_("Invalid cast.")); return 0; } } @@ -428,8 +437,6 @@ struct value * value_zero (struct type *type, enum lval_type lv) { struct value *val = allocate_value (type); - - memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type))); VALUE_LVAL (val) = lv; return val; @@ -441,7 +448,7 @@ value_zero (struct type *type, enum lval_type lv) if we can be 'lazy' and defer the fetch, perhaps indefinately, 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 + is tested in the value_contents macro, which is used if and when the contents are actually required. Note: value_at does *NOT* handle embedded offsets; perform such @@ -453,11 +460,11 @@ value_at (struct type *type, CORE_ADDR addr) 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); - read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type)); + read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type)); VALUE_LVAL (val) = lval_memory; VALUE_ADDRESS (val) = addr; @@ -473,26 +480,27 @@ value_at_lazy (struct type *type, CORE_ADDR addr) 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); VALUE_LVAL (val) = lval_memory; VALUE_ADDRESS (val) = addr; - VALUE_LAZY (val) = 1; + set_value_lazy (val, 1); return val; } -/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros, - if the current data for a variable needs to be loaded into - VALUE_CONTENTS(VAL). Fetches the data from the user's process, and - clears the lazy flag to indicate that the data in the buffer is valid. +/* Called only from the value_contents and value_contents_all() + macros, if the current data for a variable needs to be loaded into + value_contents(VAL). Fetches the data from the user's process, and + clears the lazy flag to indicate that the data in the buffer is + valid. If the value is zero-length, we avoid calling read_memory, which would abort. We mark the value as fetched anyway -- all 0 bytes of it. - This function returns a value because it is used in the VALUE_CONTENTS + This function returns a value because it is used in the value_contents macro as part of an expression, where a void would not work. The value is ignored. */ @@ -500,13 +508,13 @@ int value_fetch_lazy (struct value *val) { CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val); - int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)); + int length = TYPE_LENGTH (value_enclosing_type (val)); struct type *type = value_type (val); if (length) - read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length); + read_memory (addr, value_contents_all_raw (val), length); - VALUE_LAZY (val) = 0; + set_value_lazy (val, 0); return 0; } @@ -521,8 +529,8 @@ value_assign (struct value *toval, struct value *fromval) 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); @@ -543,9 +551,9 @@ value_assign (struct value *toval, struct value *fromval) case lval_internalvar: 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); + val = value_change_enclosing_type (val, value_enclosing_type (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: @@ -558,10 +566,10 @@ value_assign (struct value *toval, struct value *fromval) case lval_memory: { - char *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)) { @@ -573,7 +581,7 @@ value_assign (struct value *toval, struct value *fromval) / 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), @@ -587,7 +595,7 @@ value_assign (struct value *toval, struct value *fromval) { changed_addr = VALUE_ADDRESS (toval) + value_offset (toval); changed_len = TYPE_LENGTH (type); - dest_buffer = VALUE_CONTENTS (fromval); + dest_buffer = value_contents (fromval); } write_memory (changed_addr, dest_buffer, changed_len); @@ -602,19 +610,11 @@ value_assign (struct value *toval, struct value *fromval) int value_reg; /* Figure out which frame this is in currently. */ - if (VALUE_LVAL (toval) == lval_register) - { - frame = get_current_frame (); - value_reg = VALUE_REGNUM (toval); - } - else - { - frame = frame_find_by_id (VALUE_FRAME_ID (toval)); - value_reg = VALUE_REGNUM (toval); - } + frame = frame_find_by_id (VALUE_FRAME_ID (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)) @@ -622,7 +622,7 @@ value_assign (struct value *toval, struct value *fromval) /* If TOVAL is a special machine register requiring conversion of program values to a special raw format. */ VALUE_TO_REGISTER (frame, VALUE_REGNUM (toval), - type, VALUE_CONTENTS (fromval)); + type, value_contents (fromval)); } else { @@ -631,7 +631,7 @@ value_assign (struct value *toval, struct value *fromval) 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; @@ -655,7 +655,7 @@ value_assign (struct value *toval, struct value *fromval) 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; @@ -669,7 +669,7 @@ value_assign (struct value *toval, struct value *fromval) value_as_long (fromval), value_bitpos (toval), value_bitsize (toval)); else - memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval), + memcpy (buffer + byte_offset, value_contents (fromval), TYPE_LENGTH (type)); /* Copy it out. */ @@ -686,7 +686,7 @@ value_assign (struct value *toval, struct value *fromval) } 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 @@ -736,12 +736,12 @@ value_assign (struct value *toval, struct value *fromval) } 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; - 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); + deprecated_set_value_type (val, type); + val = value_change_enclosing_type (val, value_enclosing_type (fromval)); + set_value_embedded_offset (val, value_embedded_offset (fromval)); + set_value_pointed_to_offset (val, value_pointed_to_offset (fromval)); return val; } @@ -754,15 +754,15 @@ value_repeat (struct value *arg1, int count) 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); + val = allocate_repeat_value (value_enclosing_type (arg1), count); read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1), - VALUE_CONTENTS_ALL_RAW (val), - TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))); + value_contents_all_raw (val), + TYPE_LENGTH (value_enclosing_type (val))); VALUE_LVAL (val) = lval_memory; VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1); @@ -784,16 +784,16 @@ value_of_variable (struct symbol *var, struct block *b) { 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; } @@ -827,7 +827,7 @@ value_coerce_array (struct value *arg1) 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))); @@ -842,7 +842,7 @@ value_coerce_function (struct value *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))); @@ -863,26 +863,26 @@ value_addr (struct value *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))); + 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; } @@ -899,7 +899,7 @@ value_ind (struct value *arg1) 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 @@ -913,74 +913,26 @@ value_ind (struct value *arg1) struct type *enc_type; /* We may be pointing to something embedded in a larger object */ /* Get the real type of the enclosing object */ - enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1)); + enc_type = check_typedef (value_enclosing_type (arg1)); 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 */ } -/* 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. @@ -1008,29 +960,29 @@ value_array (int lowbound, int highbound, struct value **elemvec) 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])); + typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0])); for (idx = 1; idx < nelem; idx++) { - if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength) + 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")); } } rangetype = create_range_type ((struct type *) NULL, builtin_type_int, lowbound, highbound); arraytype = create_array_type ((struct type *) NULL, - VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype); + value_enclosing_type (elemvec[0]), rangetype); if (!current_language->c_style_arrays) { val = allocate_value (arraytype); for (idx = 0; idx < nelem; idx++) { - memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength), - VALUE_CONTENTS_ALL (elemvec[idx]), + memcpy (value_contents_all_raw (val) + (idx * typelength), + value_contents_all (elemvec[idx]), typelength); } return val; @@ -1044,7 +996,8 @@ value_array (int lowbound, int highbound, struct value **elemvec) addr = allocate_space_in_inferior (nelem * typelength); for (idx = 0; idx < nelem; idx++) { - write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]), + write_memory (addr + (idx * typelength), + value_contents_all (elemvec[idx]), typelength); } @@ -1077,7 +1030,7 @@ value_string (char *ptr, int len) if (current_language->c_style_arrays == 0) { val = allocate_value (stringtype); - memcpy (VALUE_CONTENTS_RAW (val), ptr, len); + memcpy (value_contents_raw (val), ptr, len); return val; } @@ -1086,7 +1039,7 @@ value_string (char *ptr, int len) 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); @@ -1101,7 +1054,7 @@ value_bitstring (char *ptr, int len) struct type *type = create_set_type ((struct type *) NULL, domain_type); TYPE_CODE (type) = TYPE_CODE_BITSTRING; val = allocate_value (type); - memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type)); + memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type)); return val; } @@ -1128,7 +1081,7 @@ typecmp (int staticp, int varargs, int nargs, 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) @@ -1218,14 +1171,14 @@ search_struct_field (char *name, struct value *arg1, int offset, { 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; } @@ -1289,11 +1242,11 @@ search_struct_field (char *name, struct value *arg1, int offset, struct value *v2 = allocate_value (basetype); boffset = baseclass_offset (type, i, - VALUE_CONTENTS (arg1) + offset, + value_contents (arg1) + offset, 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 @@ -1305,9 +1258,9 @@ search_struct_field (char *name, struct value *arg1, int offset, CORE_ADDR base_addr; base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset; - if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2), + 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; } @@ -1315,12 +1268,13 @@ search_struct_field (char *name, struct value *arg1, int offset, { VALUE_LVAL (v2) = VALUE_LVAL (arg1); VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1); - v2->offset = value_offset (arg1) + boffset; - if (VALUE_LAZY (arg1)) - VALUE_LAZY (v2) = 1; + VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1); + set_value_offset (v2, value_offset (arg1) + boffset); + if (value_lazy (arg1)) + set_value_lazy (v2, 1); else - memcpy (VALUE_CONTENTS_RAW (v2), - VALUE_CONTENTS_RAW (arg1) + boffset, + memcpy (value_contents_raw (v2), + value_contents_raw (arg1) + boffset, TYPE_LENGTH (basetype)); } @@ -1361,8 +1315,9 @@ search_struct_field (char *name, struct value *arg1, int offset, * conventions. */ void -find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr, - int offset, int *boffset_p, int *skip_p) +find_rt_vbase_offset (struct type *type, struct type *basetype, + const gdb_byte *valaddr, int offset, int *boffset_p, + int *skip_p) { int boffset; /* offset of virtual base */ int index; /* displacement to use in virtual table */ @@ -1409,7 +1364,7 @@ find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr, /* 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 @@ -1468,7 +1423,7 @@ search_struct_method (char *name, struct value **arg1p, 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); @@ -1508,16 +1463,16 @@ search_struct_method (char *name, struct value **arg1p, according to HP/Taligent runtime spec. */ int skip; find_rt_vbase_offset (type, TYPE_BASECLASS (type, i), - VALUE_CONTENTS_ALL (*arg1p), - offset + VALUE_EMBEDDED_OFFSET (*arg1p), + value_contents_all (*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)); - char *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 @@ -1525,22 +1480,22 @@ search_struct_method (char *name, struct value **arg1p, if (offset < 0 || offset >= TYPE_LENGTH (type)) { - base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass)); + gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass)); if (target_read_memory (VALUE_ADDRESS (*arg1p) + value_offset (*arg1p) + offset, - base_valaddr, - TYPE_LENGTH (baseclass)) != 0) - error ("virtual baseclass botch"); + tmp, TYPE_LENGTH (baseclass)) != 0) + error (_("virtual baseclass botch")); + base_valaddr = tmp; } else - base_valaddr = VALUE_CONTENTS (*arg1p) + offset; + base_valaddr = value_contents (*arg1p) + offset; base_offset = baseclass_offset (type, i, base_valaddr, VALUE_ADDRESS (*arg1p) + value_offset (*arg1p) + offset); if (base_offset == -1) - error ("virtual baseclass botch"); + error (_("virtual baseclass botch")); } } else @@ -1603,11 +1558,11 @@ value_struct_elt (struct value **argp, struct value **args, } 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) @@ -1627,18 +1582,18 @@ value_struct_elt (struct value **argp, struct value **args, 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 method %s."), name); 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; } @@ -1657,13 +1612,13 @@ value_struct_elt (struct value **argp, struct value **args, 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 @@ -1671,7 +1626,7 @@ value_struct_elt (struct value **argp, struct value **args, 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) { @@ -1682,7 +1637,7 @@ value_struct_elt (struct value **argp, struct value **args, } if (!v) - error ("Structure has no component named %s.", name); + error (_("Structure has no component named %s."), name); return v; } @@ -1742,11 +1697,11 @@ find_method_list (struct value **argp, char *method, int offset, * according to HP/Taligent runtime spec. */ int skip; find_rt_vbase_offset (type, TYPE_BASECLASS (type, i), - VALUE_CONTENTS_ALL (*argp), - offset + VALUE_EMBEDDED_OFFSET (*argp), + value_contents_all (*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 { @@ -1754,10 +1709,10 @@ find_method_list (struct value **argp, char *method, int offset, base_offset = value_offset (*argp) + offset; base_offset = baseclass_offset (type, i, - VALUE_CONTENTS (*argp) + base_offset, + value_contents (*argp) + base_offset, VALUE_ADDRESS (*argp) + base_offset); if (base_offset == -1) - error ("virtual baseclass botch"); + error (_("virtual baseclass botch")); } } else @@ -1802,11 +1757,11 @@ value_find_oload_method_list (struct value **argp, char *method, int offset, } 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); } @@ -1878,7 +1833,7 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method, &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); @@ -1923,23 +1878,23 @@ find_overload_match (struct type **arg_types, int nargs, char *name, int method, 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); } @@ -2261,7 +2216,7 @@ destructor_name_p (const char *name, const struct type *type) 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; } @@ -2333,11 +2288,11 @@ check_field (struct value *arg1, const char *name) } 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); } @@ -2363,7 +2318,7 @@ value_aggregate_elt (struct type *curtype, 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")); } } @@ -2386,7 +2341,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, 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--) { @@ -2398,12 +2353,12 @@ value_struct_elt_for_reference (struct type *domain, int offset, { 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), @@ -2418,7 +2373,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, /* 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. */ @@ -2447,14 +2402,14 @@ value_struct_elt_for_reference (struct type *domain, int offset, 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; @@ -2526,7 +2481,7 @@ value_namespace_elt (const struct type *curtype, 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; @@ -2605,7 +2560,7 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop, real_type = value_rtti_type (argp, &full, &top, &using_enc); /* If no RTTI data, or if object is already complete, do nothing */ - if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp)) + if (!real_type || real_type == value_enclosing_type (argp)) return argp; /* If we have the full object, but for some reason the enclosing @@ -2619,7 +2574,7 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop, /* 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; } @@ -2629,9 +2584,11 @@ value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop, 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; } @@ -2652,7 +2609,7 @@ value_of_local (const char *name, int complain) if (deprecated_selected_frame == 0) { if (complain) - error ("no frame selected"); + error (_("no frame selected")); else return 0; } @@ -2661,7 +2618,7 @@ value_of_local (const char *name, int complain) if (!func) { if (complain) - error ("no `%s' in nameless context", name); + error (_("no `%s' in nameless context"), name); else return 0; } @@ -2670,7 +2627,7 @@ value_of_local (const char *name, int complain) if (dict_empty (BLOCK_DICT (b))) { if (complain) - error ("no args, no `%s'", name); + error (_("no args, no `%s'"), name); else return 0; } @@ -2681,14 +2638,14 @@ value_of_local (const char *name, int complain) 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; } @@ -2720,13 +2677,13 @@ value_slice (struct value *array, int lowbound, int length) 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, @@ -2741,16 +2698,16 @@ value_slice (struct value *array, int lowbound, int length) for (i = 0; i < length; i++) { int element = value_bit_index (array_type, - VALUE_CONTENTS (array), + 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; if (BITS_BIG_ENDIAN) j = TARGET_CHAR_BIT - 1 - j; - VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j); + value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j); } } /* We should set the address, bitssize, and bitspos, so the clice @@ -2766,17 +2723,19 @@ value_slice (struct value *array, int lowbound, int length) slice_range_type); TYPE_CODE (slice_type) = TYPE_CODE (array_type); slice = allocate_value (slice_type); - if (VALUE_LAZY (array)) - VALUE_LAZY (slice) = 1; + if (value_lazy (array)) + set_value_lazy (slice, 1); else - memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset, + memcpy (value_contents_writeable (slice), + value_contents (array) + offset, TYPE_LENGTH (slice_type)); if (VALUE_LVAL (array) == lval_internalvar) VALUE_LVAL (slice) = lval_internalvar_component; else VALUE_LVAL (slice) = VALUE_LVAL (array); VALUE_ADDRESS (slice) = VALUE_ADDRESS (array); - slice->offset = value_offset (array) + offset; + VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array); + set_value_offset (slice, value_offset (array) + offset); } return slice; } @@ -2797,10 +2756,10 @@ value_literal_complex (struct value *arg1, struct value *arg2, struct type *type arg1 = value_cast (real_type, arg1); arg2 = value_cast (real_type, arg2); - memcpy (VALUE_CONTENTS_RAW (val), - VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type)); - memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type), - VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type)); + memcpy (value_contents_raw (val), + value_contents (arg1), TYPE_LENGTH (real_type)); + memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type), + value_contents (arg2), TYPE_LENGTH (real_type)); return val; } @@ -2816,10 +2775,10 @@ cast_into_complex (struct type *type, struct value *val) struct value *re_val = allocate_value (val_real_type); struct value *im_val = allocate_value (val_real_type); - memcpy (VALUE_CONTENTS_RAW (re_val), - VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type)); - memcpy (VALUE_CONTENTS_RAW (im_val), - VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type), + memcpy (value_contents_raw (re_val), + value_contents (val), TYPE_LENGTH (val_real_type)); + memcpy (value_contents_raw (im_val), + value_contents (val) + TYPE_LENGTH (val_real_type), TYPE_LENGTH (val_real_type)); return value_literal_complex (re_val, im_val, type); @@ -2828,24 +2787,18 @@ cast_into_complex (struct type *type, struct value *val) || 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; }