/* Evaluate expressions for GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005 Free
+ Software Foundation, Inc.
This file is part of GDB.
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 "gdb_string.h"
#include "language.h" /* For CAST_IS_CONVERSION */
#include "f-lang.h" /* for array bound stuff */
#include "cp-abi.h"
-
-/* Defined in symtab.c */
-extern int hp_som_som_object_present;
+#include "infcall.h"
+#include "objc-lang.h"
+#include "block.h"
+#include "parser-defs.h"
+#include "cp-support.h"
/* This is defined in valops.c */
extern int overload_resolution;
LONGEST, LONGEST);
static struct value *
-evaluate_subexp (struct type *expect_type, register struct expression *exp,
- register int *pos, enum noside noside)
+evaluate_subexp (struct type *expect_type, struct expression *exp,
+ int *pos, enum noside noside)
{
- return (*exp->language_defn->evaluate_exp) (expect_type, exp, pos, noside);
+ return (*exp->language_defn->la_exp_desc->evaluate_exp)
+ (expect_type, exp, pos, noside);
}
\f
/* Parse the string EXP as a C expression, evaluate it,
parse_and_eval_address (char *exp)
{
struct expression *expr = parse_expression (exp);
- register CORE_ADDR addr;
- register struct cleanup *old_chain =
+ CORE_ADDR addr;
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
addr = value_as_address (evaluate_expression (expr));
parse_and_eval_address_1 (char **expptr)
{
struct expression *expr = parse_exp_1 (expptr, (struct block *) 0, 0);
- register CORE_ADDR addr;
- register struct cleanup *old_chain =
+ CORE_ADDR addr;
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
addr = value_as_address (evaluate_expression (expr));
parse_and_eval_long (char *exp)
{
struct expression *expr = parse_expression (exp);
- register LONGEST retval;
- register struct cleanup *old_chain =
+ LONGEST retval;
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
retval = value_as_long (evaluate_expression (expr));
{
struct expression *expr = parse_expression (exp);
struct value *val;
- register struct cleanup *old_chain =
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
{
struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1);
struct value *val;
- register struct cleanup *old_chain =
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
returning the label. Otherwise, does nothing and returns NULL. */
static char *
-get_label (register struct expression *exp, int *pos)
+get_label (struct expression *exp, int *pos)
{
if (exp->elts[*pos].opcode == OP_LABELED)
{
return NULL;
}
-/* This function evaluates tuples (in (OBSOLETE) Chill) or
+/* This function evaluates tuples (in (the deleted) Chill) or
brace-initializers (in C/C++) for structure types. */
static struct value *
evaluate_struct_tuple (struct value *struct_val,
- register struct expression *exp,
- register int *pos, enum noside noside, int nargs)
+ struct expression *exp,
+ int *pos, enum noside noside, int nargs)
{
- struct type *struct_type = check_typedef (VALUE_TYPE (struct_val));
+ struct type *struct_type = check_typedef (value_type (struct_val));
struct type *substruct_type = struct_type;
struct type *field_type;
int fieldno = -1;
struct value *val = NULL;
int nlabels = 0;
int bitpos, bitsize;
- char *addr;
+ bfd_byte *addr;
/* Skip past the labels, and count them. */
while (get_label (exp, pos) != NULL)
fieldno++)
{
char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
- if (field_name != NULL && STREQ (field_name, label))
+ if (field_name != NULL && strcmp (field_name, label) == 0)
{
variantno = -1;
subfieldno = fieldno;
subfieldno < TYPE_NFIELDS (substruct_type);
subfieldno++)
{
- if (STREQ (TYPE_FIELD_NAME (substruct_type,
+ if (strcmp(TYPE_FIELD_NAME (substruct_type,
subfieldno),
- label))
+ label) == 0)
{
goto found;
}
}
}
}
- error ("there is no field named %s", label);
+ error (_("there is no field named %s"), label);
found:
;
}
if (variantno < 0)
{
fieldno++;
+ /* Skip static fields. */
+ while (fieldno < TYPE_NFIELDS (struct_type)
+ && TYPE_FIELD_STATIC_KIND (struct_type, fieldno))
+ fieldno++;
subfieldno = fieldno;
if (fieldno >= TYPE_NFIELDS (struct_type))
- error ("too many initializers");
+ error (_("too many initializers"));
field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
if (TYPE_CODE (field_type) == TYPE_CODE_UNION
&& TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
- error ("don't know which variant you want to set");
+ error (_("don't know which variant you want to set"));
}
}
/* Now actually set the field in struct_val. */
/* Assign val to field fieldno. */
- if (VALUE_TYPE (val) != field_type)
+ if (value_type (val) != field_type)
val = value_cast (field_type, val);
bitsize = TYPE_FIELD_BITSIZE (substruct_type, subfieldno);
bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
if (variantno >= 0)
bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno);
- addr = VALUE_CONTENTS (struct_val) + bitpos / 8;
+ addr = value_contents_writeable (struct_val) + bitpos / 8;
if (bitsize)
modify_field (addr, value_as_long (val),
bitpos % 8, bitsize);
else
- memcpy (addr, VALUE_CONTENTS (val),
- TYPE_LENGTH (VALUE_TYPE (val)));
+ memcpy (addr, value_contents (val),
+ TYPE_LENGTH (value_type (val)));
}
while (--nlabels > 0);
}
}
/* Recursive helper function for setting elements of array tuples for
- (OBSOLETE) Chill. The target is ARRAY (which has bounds LOW_BOUND
- to HIGH_BOUND); the element value is ELEMENT; EXP, POS and NOSIDE
- are as usual. Evaluates index expresions and sets the specified
- element(s) of ARRAY to ELEMENT. Returns last index value. */
+ (the deleted) Chill. The target is ARRAY (which has bounds
+ LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
+ and NOSIDE are as usual. Evaluates index expresions and sets the
+ specified element(s) of ARRAY to ELEMENT. Returns last index
+ value. */
static LONGEST
init_array_element (struct value *array, struct value *element,
- register struct expression *exp, register int *pos,
+ struct expression *exp, int *pos,
enum noside noside, LONGEST low_bound, LONGEST high_bound)
{
LONGEST index;
- int element_size = TYPE_LENGTH (VALUE_TYPE (element));
+ int element_size = TYPE_LENGTH (value_type (element));
if (exp->elts[*pos].opcode == BINOP_COMMA)
{
(*pos)++;
low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
if (low < low_bound || high > high_bound)
- error ("tuple range index out of range");
+ error (_("tuple range index out of range"));
for (index = low; index <= high; index++)
{
- memcpy (VALUE_CONTENTS_RAW (array)
+ memcpy (value_contents_raw (array)
+ (index - low_bound) * element_size,
- VALUE_CONTENTS (element), element_size);
+ value_contents (element), element_size);
}
}
else
{
index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
if (index < low_bound || index > high_bound)
- error ("tuple index out of range");
- memcpy (VALUE_CONTENTS_RAW (array) + (index - low_bound) * element_size,
- VALUE_CONTENTS (element), element_size);
+ error (_("tuple index out of range"));
+ memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
+ value_contents (element), element_size);
}
return index;
}
+struct value *
+value_f90_subarray (struct value *array,
+ struct expression *exp, int *pos, enum noside noside)
+{
+ int pc = (*pos) + 1;
+ LONGEST low_bound, high_bound;
+ struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
+ enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
+
+ *pos += 3;
+
+ if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
+ low_bound = TYPE_LOW_BOUND (range);
+ else
+ low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+
+ if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
+ high_bound = TYPE_HIGH_BOUND (range);
+ else
+ high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+
+ return value_slice (array, low_bound, high_bound - low_bound + 1);
+}
+
struct value *
evaluate_subexp_standard (struct type *expect_type,
- register struct expression *exp, register int *pos,
+ struct expression *exp, int *pos,
enum noside noside)
{
enum exp_opcode op;
int tem, tem2, tem3;
- register int pc, pc2 = 0, oldpos;
+ int pc, pc2 = 0, oldpos;
struct value *arg1 = NULL;
struct value *arg2 = NULL;
struct value *arg3;
case OP_SCOPE:
tem = longest_to_int (exp->elts[pc + 2].longconst);
(*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
- arg1 = value_struct_elt_for_reference (exp->elts[pc + 1].type,
- 0,
- exp->elts[pc + 1].type,
- &exp->elts[pc + 3].string,
- NULL_TYPE);
+ arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
+ &exp->elts[pc + 3].string,
+ noside);
if (arg1 == NULL)
- error ("There is no field named %s", &exp->elts[pc + 3].string);
+ error (_("There is no field named %s"), &exp->elts[pc + 3].string);
return arg1;
case OP_LONG:
case OP_REGISTER:
{
int regno = longest_to_int (exp->elts[pc + 1].longconst);
- struct value *val = value_of_register (regno, selected_frame);
+ struct value *val = value_of_register (regno, get_selected_frame (NULL));
(*pos) += 2;
if (val == NULL)
- error ("Value of register %s not available.",
- frame_map_regnum_to_name (regno));
+ error (_("Value of register %s not available."),
+ frame_map_regnum_to_name (get_selected_frame (NULL), regno));
else
return val;
}
goto nosideret;
return value_string (&exp->elts[pc + 2].string, tem);
+ case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant. */
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
+ if (noside == EVAL_SKIP)
+ {
+ goto nosideret;
+ }
+ return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
+
case OP_BITSTRING:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos)
&& TYPE_CODE (type) == TYPE_CODE_STRUCT)
{
struct value *rec = allocate_value (expect_type);
- memset (VALUE_CONTENTS_RAW (rec), '\0', TYPE_LENGTH (type));
+ memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
}
high_bound = (TYPE_LENGTH (type) / element_size) - 1;
}
index = low_bound;
- memset (VALUE_CONTENTS_RAW (array), 0, TYPE_LENGTH (expect_type));
+ memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
for (tem = nargs; --nargs >= 0;)
{
struct value *element;
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
}
element = evaluate_subexp (element_type, exp, pos, noside);
- if (VALUE_TYPE (element) != element_type)
+ if (value_type (element) != element_type)
element = value_cast (element_type, element);
if (index_pc)
{
{
if (index > high_bound)
/* to avoid memory corruption */
- error ("Too many array elements");
- memcpy (VALUE_CONTENTS_RAW (array)
+ error (_("Too many array elements"));
+ memcpy (value_contents_raw (array)
+ (index - low_bound) * element_size,
- VALUE_CONTENTS (element),
+ value_contents (element),
element_size);
}
index++;
&& TYPE_CODE (type) == TYPE_CODE_SET)
{
struct value *set = allocate_value (expect_type);
- char *valaddr = VALUE_CONTENTS_RAW (set);
+ gdb_byte *valaddr = value_contents_raw (set);
struct type *element_type = TYPE_INDEX_TYPE (type);
struct type *check_type = element_type;
LONGEST low_bound, high_bound;
check_type = TYPE_TARGET_TYPE (check_type);
if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
- error ("(power)set type with unknown size");
+ error (_("(power)set type with unknown size"));
memset (valaddr, '\0', TYPE_LENGTH (type));
for (tem = 0; tem < nargs; tem++)
{
{
(*pos)++;
elem_val = evaluate_subexp (element_type, exp, pos, noside);
- range_low_type = VALUE_TYPE (elem_val);
+ range_low_type = value_type (elem_val);
range_low = value_as_long (elem_val);
elem_val = evaluate_subexp (element_type, exp, pos, noside);
- range_high_type = VALUE_TYPE (elem_val);
+ range_high_type = value_type (elem_val);
range_high = value_as_long (elem_val);
}
else
{
elem_val = evaluate_subexp (element_type, exp, pos, noside);
- range_low_type = range_high_type = VALUE_TYPE (elem_val);
+ range_low_type = range_high_type = value_type (elem_val);
range_low = range_high = value_as_long (elem_val);
}
/* check types of elements to avoid mixture of elements from
(TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
(range_low_type != range_high_type)))
/* different element modes */
- error ("POWERSET tuple elements of different mode");
+ error (_("POWERSET tuple elements of different mode"));
if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
(TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
range_low_type != check_type))
- error ("incompatible POWERSET tuple elements");
+ error (_("incompatible POWERSET tuple elements"));
if (range_low > range_high)
{
- warning ("empty POWERSET tuple range");
+ warning (_("empty POWERSET tuple range"));
continue;
}
if (range_low < low_bound || range_high > high_bound)
- error ("POWERSET tuple element out of range");
+ error (_("POWERSET tuple element out of range"));
range_low -= low_bound;
range_high -= low_bound;
for (; range_low <= range_high; range_low++)
return arg2;
}
+ case OP_OBJC_SELECTOR:
+ { /* Objective C @selector operator. */
+ char *sel = &exp->elts[pc + 2].string;
+ int len = longest_to_int (exp->elts[pc + 1].longconst);
+
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+
+ if (sel[len] != 0)
+ sel[len] = 0; /* Make sure it's terminated. */
+ return value_from_longest (lookup_pointer_type (builtin_type_void),
+ lookup_child_selector (sel));
+ }
+
+ case OP_OBJC_MSGCALL:
+ { /* Objective C message (method) call. */
+
+ static CORE_ADDR responds_selector = 0;
+ static CORE_ADDR method_selector = 0;
+
+ CORE_ADDR selector = 0;
+
+ int using_gcc = 0;
+ int struct_return = 0;
+ int sub_no_side = 0;
+
+ static struct value *msg_send = NULL;
+ static struct value *msg_send_stret = NULL;
+ static int gnu_runtime = 0;
+
+ struct value *target = NULL;
+ struct value *method = NULL;
+ struct value *called_method = NULL;
+
+ struct type *selector_type = NULL;
+
+ struct value *ret = NULL;
+ CORE_ADDR addr = 0;
+
+ selector = exp->elts[pc + 1].longconst;
+ nargs = exp->elts[pc + 2].longconst;
+ argvec = (struct value **) alloca (sizeof (struct value *)
+ * (nargs + 5));
+
+ (*pos) += 3;
+
+ selector_type = lookup_pointer_type (builtin_type_void);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ sub_no_side = EVAL_NORMAL;
+ else
+ sub_no_side = noside;
+
+ target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
+
+ if (value_as_long (target) == 0)
+ return value_from_longest (builtin_type_long, 0);
+
+ if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
+ gnu_runtime = 1;
+
+ /* Find the method dispatch (Apple runtime) or method lookup
+ (GNU runtime) function for Objective-C. These will be used
+ to lookup the symbol information for the method. If we
+ can't find any symbol information, then we'll use these to
+ call the method, otherwise we can call the method
+ directly. The msg_send_stret function is used in the special
+ case of a method that returns a structure (Apple runtime
+ only). */
+ if (gnu_runtime)
+ {
+ struct type *type;
+ type = lookup_pointer_type (builtin_type_void);
+ type = lookup_function_type (type);
+ type = lookup_pointer_type (type);
+ type = lookup_function_type (type);
+ type = lookup_pointer_type (type);
+
+ msg_send = find_function_in_inferior ("objc_msg_lookup");
+ msg_send_stret = find_function_in_inferior ("objc_msg_lookup");
+
+ msg_send = value_from_pointer (type, value_as_address (msg_send));
+ msg_send_stret = value_from_pointer (type,
+ value_as_address (msg_send_stret));
+ }
+ else
+ {
+ msg_send = find_function_in_inferior ("objc_msgSend");
+ /* Special dispatcher for methods returning structs */
+ msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+ }
+
+ /* Verify the target object responds to this method. The
+ standard top-level 'Object' class uses a different name for
+ the verification method than the non-standard, but more
+ often used, 'NSObject' class. Make sure we check for both. */
+
+ responds_selector = lookup_child_selector ("respondsToSelector:");
+ if (responds_selector == 0)
+ responds_selector = lookup_child_selector ("respondsTo:");
+
+ if (responds_selector == 0)
+ error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
+
+ method_selector = lookup_child_selector ("methodForSelector:");
+ if (method_selector == 0)
+ method_selector = lookup_child_selector ("methodFor:");
+
+ if (method_selector == 0)
+ error (_("no 'methodFor:' or 'methodForSelector:' method"));
+
+ /* Call the verification method, to make sure that the target
+ class implements the desired method. */
+
+ argvec[0] = msg_send;
+ argvec[1] = target;
+ argvec[2] = value_from_longest (builtin_type_long, responds_selector);
+ argvec[3] = value_from_longest (builtin_type_long, selector);
+ argvec[4] = 0;
+
+ ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+ if (gnu_runtime)
+ {
+ /* Function objc_msg_lookup returns a pointer. */
+ argvec[0] = ret;
+ ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+ }
+ if (value_as_long (ret) == 0)
+ error (_("Target does not respond to this message selector."));
+
+ /* Call "methodForSelector:" method, to get the address of a
+ function method that implements this selector for this
+ class. If we can find a symbol at that address, then we
+ know the return type, parameter types etc. (that's a good
+ thing). */
+
+ argvec[0] = msg_send;
+ argvec[1] = target;
+ argvec[2] = value_from_longest (builtin_type_long, method_selector);
+ argvec[3] = value_from_longest (builtin_type_long, selector);
+ argvec[4] = 0;
+
+ ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+ if (gnu_runtime)
+ {
+ argvec[0] = ret;
+ ret = call_function_by_hand (argvec[0], 3, argvec + 1);
+ }
+
+ /* ret should now be the selector. */
+
+ addr = value_as_long (ret);
+ if (addr)
+ {
+ struct symbol *sym = NULL;
+ /* Is it a high_level symbol? */
+
+ sym = find_pc_function (addr);
+ if (sym != NULL)
+ method = value_of_variable (sym, 0);
+ }
+
+ /* If we found a method with symbol information, check to see
+ if it returns a struct. Otherwise assume it doesn't. */
+
+ if (method)
+ {
+ struct block *b;
+ CORE_ADDR funaddr;
+ struct type *value_type;
+
+ funaddr = find_function_addr (method, &value_type);
+
+ b = block_for_pc (funaddr);
+
+ /* If compiled without -g, assume GCC 2. */
+ using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
+
+ CHECK_TYPEDEF (value_type);
+
+ if ((value_type == NULL)
+ || (TYPE_CODE(value_type) == TYPE_CODE_ERROR))
+ {
+ if (expect_type != NULL)
+ value_type = expect_type;
+ }
+
+ struct_return = using_struct_return (value_type, using_gcc);
+ }
+ else if (expect_type != NULL)
+ {
+ struct_return = using_struct_return (check_typedef (expect_type), using_gcc);
+ }
+
+ /* Found a function symbol. Now we will substitute its
+ value in place of the message dispatcher (obj_msgSend),
+ so that we call the method directly instead of thru
+ the dispatcher. The main reason for doing this is that
+ we can now evaluate the return value and parameter values
+ according to their known data types, in case we need to
+ do things like promotion, dereferencing, special handling
+ of structs and doubles, etc.
+
+ We want to use the type signature of 'method', but still
+ jump to objc_msgSend() or objc_msgSend_stret() to better
+ mimic the behavior of the runtime. */
+
+ if (method)
+ {
+ if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
+ error (_("method address has symbol information with non-function type; skipping"));
+ if (struct_return)
+ VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
+ else
+ VALUE_ADDRESS (method) = value_as_address (msg_send);
+ called_method = method;
+ }
+ else
+ {
+ if (struct_return)
+ called_method = msg_send_stret;
+ else
+ called_method = msg_send;
+ }
+
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ /* If the return type doesn't look like a function type,
+ call an error. This can happen if somebody tries to
+ turn a variable into a function call. This is here
+ because people often want to call, eg, strcmp, which
+ gdb doesn't know is a function. If gdb isn't asked for
+ it's opinion (ie. through "whatis"), it won't offer
+ it. */
+
+ struct type *type = value_type (called_method);
+ if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+ type = TYPE_TARGET_TYPE (type);
+ type = TYPE_TARGET_TYPE (type);
+
+ if (type)
+ {
+ if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
+ return allocate_value (expect_type);
+ else
+ return allocate_value (type);
+ }
+ else
+ error (_("Expression of type other than \"method returning ...\" used as a method"));
+ }
+
+ /* Now depending on whether we found a symbol for the method,
+ we will either call the runtime dispatcher or the method
+ directly. */
+
+ argvec[0] = called_method;
+ argvec[1] = target;
+ argvec[2] = value_from_longest (builtin_type_long, selector);
+ /* User-supplied arguments. */
+ for (tem = 0; tem < nargs; tem++)
+ argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
+ argvec[tem + 3] = 0;
+
+ if (gnu_runtime && (method != NULL))
+ {
+ /* Function objc_msg_lookup returns a pointer. */
+ deprecated_set_value_type (argvec[0],
+ lookup_function_type (lookup_pointer_type (value_type (argvec[0]))));
+ argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+ }
+
+ ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+ return ret;
+ }
+ break;
+
case OP_FUNCALL:
(*pos) += 2;
op = exp->elts[*pos].opcode;
/* 1997-08-01 Currently we do not support function invocation
via pointers-to-methods with HP aCC. Pointer does not point
to the function, but possibly to some thunk. */
- if (hp_som_som_object_present)
+ if (deprecated_hp_som_som_object_present)
{
- error ("Not implemented: function invocation through pointer to method with HP aCC");
+ error (_("Not implemented: function invocation through pointer to method with HP aCC"));
}
nargs++;
int fnoffset = METHOD_PTR_TO_VOFFSET (fnptr);
struct type *basetype;
struct type *domain_type =
- TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
+ TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (value_type (arg1)));
int i, j;
- basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
+ basetype = TYPE_TARGET_TYPE (value_type (arg2));
if (domain_type != basetype)
arg2 = value_cast (lookup_pointer_type (domain_type), arg2);
basetype = TYPE_VPTR_BASETYPE (domain_type);
}
}
if (i < 0)
- error ("virtual function at index %d not found", fnoffset);
+ error (_("virtual function at index %d not found"), fnoffset);
}
else
{
- VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
+ deprecated_set_value_type (arg1, lookup_pointer_type (TYPE_TARGET_TYPE (value_type (arg1))));
}
got_it:
save_pos1 = *pos;
argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
tem = 1;
- type = VALUE_TYPE (argvec[0]);
+ type = value_type (argvec[0]);
if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
type = TYPE_TARGET_TYPE (type);
if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
/* Prepare list of argument types for overload resolution */
arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
for (ix = 1; ix <= nargs; ix++)
- arg_types[ix - 1] = VALUE_TYPE (argvec[ix]);
+ arg_types[ix - 1] = value_type (argvec[ix]);
(void) find_overload_match (arg_types, nargs, tstr,
1 /* method */ , 0 /* strict match */ ,
/* value_struct_elt updates temp with the correct value
of the ``this'' pointer if necessary, so modify argvec[1] to
reflect any ``this'' changes. */
- arg2 = value_from_longest (lookup_pointer_type(VALUE_TYPE (temp)),
- VALUE_ADDRESS (temp) + VALUE_OFFSET (temp)
- + VALUE_EMBEDDED_OFFSET (temp));
+ arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
+ VALUE_ADDRESS (temp) + value_offset (temp)
+ + value_embedded_offset (temp));
argvec[1] = arg2; /* the ``this'' pointer */
}
/* Prepare list of argument types for overload resolution */
arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
for (ix = 1; ix <= nargs; ix++)
- arg_types[ix - 1] = VALUE_TYPE (argvec[ix]);
+ arg_types[ix - 1] = value_type (argvec[ix]);
(void) find_overload_match (arg_types, nargs, NULL /* no need for name */ ,
0 /* not method */ , 0 /* strict match */ ,
if (noside == EVAL_SKIP)
goto nosideret;
if (argvec[0] == NULL)
- error ("Cannot evaluate function -- may be inlined");
+ error (_("Cannot evaluate function -- may be inlined"));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
/* If the return type doesn't look like a function type, call an
it won't offer it. */
struct type *ftype =
- TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0]));
+ TYPE_TARGET_TYPE (value_type (argvec[0]));
if (ftype)
- return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
+ return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0])));
else
- error ("Expression of type other than \"Function returning ...\" used as function");
+ error (_("Expression of type other than \"Function returning ...\" used as function"));
}
return call_function_by_hand (argvec[0], nargs, argvec + 1);
/* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
/* First determine the type code we are dealing with. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- type = check_typedef (VALUE_TYPE (arg1));
+ type = check_typedef (value_type (arg1));
code = TYPE_CODE (type);
+ if (code == TYPE_CODE_PTR)
+ {
+ /* Fortran always passes variable to subroutines as pointer.
+ So we need to look into its target type to see if it is
+ array, string or function. If it is, we need to switch
+ to the target value the original one points to. */
+ struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
+
+ if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
+ || TYPE_CODE (target_type) == TYPE_CODE_STRING
+ || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
+ {
+ arg1 = value_ind (arg1);
+ type = check_typedef (value_type (arg1));
+ code = TYPE_CODE (type);
+ }
+ }
+
switch (code)
{
case TYPE_CODE_ARRAY:
- goto multi_f77_subscript;
+ if (exp->elts[*pos].opcode == OP_F90_RANGE)
+ return value_f90_subarray (arg1, exp, pos, noside);
+ else
+ goto multi_f77_subscript;
case TYPE_CODE_STRING:
- goto op_f77_substr;
+ if (exp->elts[*pos].opcode == OP_F90_RANGE)
+ return value_f90_subarray (arg1, exp, pos, noside);
+ else
+ {
+ arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+ return value_subscript (arg1, arg2);
+ }
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
goto do_call_it;
default:
- error ("Cannot perform substring on this type");
+ error (_("Cannot perform substring on this type"));
}
- op_f77_substr:
- /* We have a substring operation on our hands here,
- let us get the string we will be dealing with */
-
- /* Now evaluate the 'from' and 'to' */
-
- arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
-
- if (nargs < 2)
- return value_subscript (arg1, arg2);
-
- arg3 = evaluate_subexp_with_coercion (exp, pos, noside);
-
- if (noside == EVAL_SKIP)
- goto nosideret;
-
- tem2 = value_as_long (arg2);
- tem3 = value_as_long (arg3);
-
- return value_slice (arg1, tem2, tem3 - tem2 + 1);
-
case OP_COMPLEX:
/* We have a complex number, There should be 2 floating
point numbers that compose it */
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
+ return value_zero (lookup_struct_elt_type (value_type (arg1),
&exp->elts[pc + 2].string,
0),
lval_memory);
with rtti type in order to continue on with successful
lookup of member / method only available in the rtti type. */
{
- struct type *type = VALUE_TYPE (arg1);
+ struct type *type = value_type (arg1);
struct type *real_type;
int full, top, using_enc;
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
+ return value_zero (lookup_struct_elt_type (value_type (arg1),
&exp->elts[pc + 2].string,
0),
lval_memory);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
/* With HP aCC, pointers to methods do not point to the function code */
- if (hp_som_som_object_present &&
- (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR) &&
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_METHOD))
- error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
+ if (deprecated_hp_som_som_object_present &&
+ (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD))
+ error (_("Pointers to methods not supported with HP aCC")); /* 1997-08-19 */
mem_offset = value_as_long (arg2);
goto handle_pointer_to_member;
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
/* With HP aCC, pointers to methods do not point to the function code */
- if (hp_som_som_object_present &&
- (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR) &&
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_METHOD))
- error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
+ if (deprecated_hp_som_som_object_present &&
+ (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg2))) == TYPE_CODE_METHOD))
+ error (_("Pointers to methods not supported with HP aCC")); /* 1997-08-19 */
mem_offset = value_as_long (arg2);
handle_pointer_to_member:
/* HP aCC generates offsets that have bit #29 set; turn it off to get
a real offset to the member. */
- if (hp_som_som_object_present)
+ if (deprecated_hp_som_som_object_present)
{
if (!mem_offset) /* no bias -> really null */
- error ("Attempted dereference of null pointer-to-member");
+ error (_("Attempted dereference of null pointer-to-member"));
mem_offset &= ~0x20000000;
}
if (noside == EVAL_SKIP)
goto nosideret;
- type = check_typedef (VALUE_TYPE (arg2));
+ type = check_typedef (value_type (arg2));
if (TYPE_CODE (type) != TYPE_CODE_PTR)
goto bad_pointer_to_member;
type = check_typedef (TYPE_TARGET_TYPE (type));
if (TYPE_CODE (type) == TYPE_CODE_METHOD)
- error ("not implemented: pointer-to-method in pointer-to-member construct");
+ error (_("not implemented: pointer-to-method in pointer-to-member construct"));
if (TYPE_CODE (type) != TYPE_CODE_MEMBER)
goto bad_pointer_to_member;
/* Now, convert these values to an address. */
value_as_long (arg1) + mem_offset);
return value_ind (arg3);
bad_pointer_to_member:
- error ("non-pointer-to-member value used in pointer-to-member construct");
+ error (_("non-pointer-to-member value used in pointer-to-member construct"));
case BINOP_CONCAT:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
case BINOP_ASSIGN:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
/* Do special stuff for HP aCC pointers to members */
- if (hp_som_som_object_present)
+ if (deprecated_hp_som_som_object_present)
{
/* 1997-08-19 Can't assign HP aCC pointers to methods. No details of
the implementation yet; but the pointer appears to point to a code
sequence (thunk) in memory -- in any case it is *not* the address
of the function as it would be in a naive implementation. */
- if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR) &&
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_METHOD))
- error ("Assignment to pointers to methods not implemented with HP aCC");
+ if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD))
+ error (_("Assignment to pointers to methods not implemented with HP aCC"));
/* HP aCC pointers to data members require a constant bias */
- if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR) &&
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_MEMBER))
+ if ((TYPE_CODE (value_type (arg1)) == TYPE_CODE_PTR) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER))
{
- unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (arg2); /* forces evaluation */
+ unsigned int *ptr = (unsigned int *) value_contents (arg2); /* forces evaluation */
*ptr |= 0x20000000; /* set 29th bit */
}
}
case BINOP_ASSIGN_MODIFY:
(*pos) += 2;
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
op = exp->elts[pc + 1].opcode;
else
return value_sub (arg1, arg2);
+ case BINOP_EXP:
case BINOP_MUL:
case BINOP_DIV:
case BINOP_REM:
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
else if (noside == EVAL_AVOID_SIDE_EFFECTS
&& (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
- return value_zero (VALUE_TYPE (arg1), not_lval);
+ return value_zero (value_type (arg1), not_lval);
else
return value_binop (arg1, arg2, op);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- error ("':' operator used in invalid context");
+ error (_("':' operator used in invalid context"));
case BINOP_SUBSCRIPT:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
array or pointer type (like a plain int variable for example),
then report this as an error. */
- COERCE_REF (arg1);
- type = check_typedef (VALUE_TYPE (arg1));
+ arg1 = coerce_ref (arg1);
+ type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
&& TYPE_CODE (type) != TYPE_CODE_PTR)
{
if (TYPE_NAME (type))
- error ("cannot subscript something of type `%s'",
+ error (_("cannot subscript something of type `%s'"),
TYPE_NAME (type));
else
- error ("cannot subscript requested type");
+ error (_("cannot subscript requested type"));
}
if (noside == EVAL_AVOID_SIDE_EFFECTS)
type (like a plain int variable for example), then report this
as an error. */
- type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
+ type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
if (type != NULL)
{
arg1 = value_zero (type, VALUE_LVAL (arg1));
}
else
{
- error ("cannot subscript something of type `%s'",
- TYPE_NAME (VALUE_TYPE (arg1)));
+ error (_("cannot subscript something of type `%s'"),
+ TYPE_NAME (value_type (arg1)));
}
}
multi_f77_subscript:
{
- int subscript_array[MAX_FORTRAN_DIMS + 1]; /* 1-based array of
- subscripts, max == 7 */
- int array_size_array[MAX_FORTRAN_DIMS + 1];
+ int subscript_array[MAX_FORTRAN_DIMS];
+ int array_size_array[MAX_FORTRAN_DIMS];
int ndimensions = 1, i;
struct type *tmp_type;
int offset_item; /* The array offset where the item lives */
if (nargs > MAX_FORTRAN_DIMS)
- error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS);
+ error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
- tmp_type = check_typedef (VALUE_TYPE (arg1));
+ tmp_type = check_typedef (value_type (arg1));
ndimensions = calc_f77_array_dims (type);
if (nargs != ndimensions)
- error ("Wrong number of subscripts");
+ error (_("Wrong number of subscripts"));
/* Now that we know we have a legal array subscript expression
let us actually find out where this element exists in the array. */
offset_item = 0;
- for (i = 1; i <= nargs; i++)
+ /* Take array indices left to right */
+ for (i = 0; i < nargs; i++)
{
/* Evaluate each subscript, It must be a legal integer in F77 */
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
/* Fill in the subscript and array size arrays */
subscript_array[i] = value_as_long (arg2);
+ }
+ /* Internal type of array is arranged right to left */
+ for (i = 0; i < nargs; i++)
+ {
retcode = f77_get_dynamic_upperbound (tmp_type, &upper);
if (retcode == BOUND_FETCH_ERROR)
- error ("Cannot obtain dynamic upper bound");
+ error (_("Cannot obtain dynamic upper bound"));
retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
if (retcode == BOUND_FETCH_ERROR)
- error ("Cannot obtain dynamic lower bound");
+ error (_("Cannot obtain dynamic lower bound"));
- array_size_array[i] = upper - lower + 1;
+ array_size_array[nargs - i - 1] = upper - lower + 1;
/* Zero-normalize subscripts so that offsetting will work. */
- subscript_array[i] -= lower;
+ subscript_array[nargs - i - 1] -= lower;
/* If we are at the bottom of a multidimensional
array type then keep a ptr to the last ARRAY
of base element type that we apply a simple
offset to. */
- if (i < nargs)
+ if (i < nargs - 1)
tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
}
/* Now let us calculate the offset for this item */
- offset_item = subscript_array[ndimensions];
+ offset_item = subscript_array[ndimensions - 1];
- for (i = ndimensions - 1; i >= 1; i--)
+ for (i = ndimensions - 1; i > 0; --i)
offset_item =
- array_size_array[i] * offset_item + subscript_array[i];
+ array_size_array[i - 1] * offset_item + subscript_array[i - 1];
/* Construct a value node with the value of the offset */
type, this will ensure that value_subscript()
returns the correct type value */
- VALUE_TYPE (arg1) = tmp_type;
+ deprecated_set_value_type (arg1, tmp_type);
return value_ind (value_add (value_coerce_array (arg1), arg2));
}
case BINOP_EQUAL:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
case BINOP_NOTEQUAL:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
case BINOP_LESS:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
case BINOP_GTR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
case BINOP_GEQ:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
case BINOP_LEQ:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
+ arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- type = check_typedef (VALUE_TYPE (arg2));
+ type = check_typedef (value_type (arg2));
if (TYPE_CODE (type) != TYPE_CODE_INT)
- error ("Non-integral right operand for \"@\" operator.");
+ error (_("Non-integral right operand for \"@\" operator."));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- return allocate_repeat_value (VALUE_TYPE (arg1),
+ return allocate_repeat_value (value_type (arg1),
longest_to_int (value_as_long (arg2)));
}
else
evaluate_subexp (NULL_TYPE, exp, pos, noside);
return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ case UNOP_PLUS:
+ arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ if (unop_user_defined_p (op, arg1))
+ return value_x_unop (arg1, op, noside);
+ else
+ return value_pos (arg1);
+
case UNOP_NEG:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
- if ((TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) &&
- ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_METHOD) ||
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_MEMBER)))
- error ("Attempt to dereference pointer to member without an object");
+ if ((TYPE_TARGET_TYPE (value_type (arg1))) &&
+ ((TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_METHOD) ||
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (arg1))) == TYPE_CODE_MEMBER)))
+ error (_("Attempt to dereference pointer to member without an object"));
if (noside == EVAL_SKIP)
goto nosideret;
if (unop_user_defined_p (op, arg1))
return value_x_unop (arg1, op, noside);
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- type = check_typedef (VALUE_TYPE (arg1));
+ type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_PTR
|| TYPE_CODE (type) == TYPE_CODE_REF
/* In C you can dereference an array to get the 1st elt. */
/* 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."));
}
return value_ind (arg1);
{
struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside);
/* If HP aCC object, use bias for pointers to members */
- if (hp_som_som_object_present &&
- (TYPE_CODE (VALUE_TYPE (retvalp)) == TYPE_CODE_PTR) &&
- (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (retvalp))) == TYPE_CODE_MEMBER))
+ if (deprecated_hp_som_som_object_present &&
+ (TYPE_CODE (value_type (retvalp)) == TYPE_CODE_PTR) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (value_type (retvalp))) == TYPE_CODE_MEMBER))
{
- unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* forces evaluation */
+ unsigned int *ptr = (unsigned int *) value_contents (retvalp); /* forces evaluation */
*ptr |= 0x20000000; /* set 29th bit */
}
return retvalp;
arg1 = evaluate_subexp (type, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (type != VALUE_TYPE (arg1))
+ if (type != value_type (arg1))
arg1 = value_cast (type, arg1);
return arg1;
return value_zero (exp->elts[pc + 1].type, lval_memory);
else
return value_at_lazy (exp->elts[pc + 1].type,
- value_as_address (arg1),
- NULL);
+ value_as_address (arg1));
case UNOP_PREINCREMENT:
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
(*pos) += 1;
return value_of_this (1);
+ case OP_OBJC_SELF:
+ (*pos) += 1;
+ return value_of_local ("self", 1);
+
case OP_TYPE:
- error ("Attempt to use a type name as an expression");
+ /* The value is not supposed to be used. This is here to make it
+ easier to accommodate expressions that contain types. */
+ (*pos) += 2;
+ if (noside == EVAL_SKIP)
+ goto nosideret;
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return allocate_value (exp->elts[pc + 1].type);
+ else
+ error (_("Attempt to use a type name as an expression"));
default:
/* Removing this case and compiling with gcc -Wall reveals that
then they should be separate cases, with more descriptive
error messages. */
- error ("\
-GDB does not (yet) know how to evaluate that kind of expression");
+ error (_("\
+GDB does not (yet) know how to evaluate that kind of expression"));
}
nosideret:
then only the type of the result need be correct. */
static struct value *
-evaluate_subexp_for_address (register struct expression *exp, register int *pos,
+evaluate_subexp_for_address (struct expression *exp, int *pos,
enum noside noside)
{
enum exp_opcode op;
- register int pc;
+ int pc;
struct symbol *var;
+ struct value *x;
pc = (*pos);
op = exp->elts[pc].opcode;
{
case UNOP_IND:
(*pos)++;
- return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+
+ /* We can't optimize out "&*" if there's a user-defined operator*. */
+ if (unop_user_defined_p (op, x))
+ {
+ x = value_x_unop (x, op, noside);
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ if (VALUE_LVAL (x) == lval_memory)
+ return value_zero (lookup_pointer_type (value_type (x)),
+ not_lval);
+ else
+ error (_("Attempt to take address of non-lval"));
+ }
+ return value_addr (x);
+ }
+
+ return x;
case UNOP_MEMVAL:
(*pos) += 3;
|| sym_class == LOC_CONST_BYTES
|| sym_class == LOC_REGISTER
|| sym_class == LOC_REGPARM)
- error ("Attempt to take address of register or constant.");
+ error (_("Attempt to take address of register or constant."));
return
value_zero (type, not_lval);
default:
default_case:
+ x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct value *x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (VALUE_LVAL (x) == lval_memory)
- return value_zero (lookup_pointer_type (VALUE_TYPE (x)),
+ return value_zero (lookup_pointer_type (value_type (x)),
not_lval);
else
- error ("Attempt to take address of non-lval");
+ error (_("Attempt to take address of non-lval"));
}
- return value_addr (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ return value_addr (x);
}
}
When used in contexts where arrays will be coerced anyway, this is
equivalent to `evaluate_subexp' but much faster because it avoids
actually fetching array contents (perhaps obsolete now that we have
- VALUE_LAZY).
+ value_lazy()).
Note that we currently only do the coercion for C expressions, where
arrays are zero based and the coercion is correct. For other languages,
*/
struct value *
-evaluate_subexp_with_coercion (register struct expression *exp,
- register int *pos, enum noside noside)
+evaluate_subexp_with_coercion (struct expression *exp,
+ int *pos, enum noside noside)
{
- register enum exp_opcode op;
- register int pc;
+ enum exp_opcode op;
+ int pc;
struct value *val;
struct symbol *var;
Advance *POS over the subexpression. */
static struct value *
-evaluate_subexp_for_sizeof (register struct expression *exp, register int *pos)
+evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
{
enum exp_opcode op;
- register int pc;
+ int pc;
struct type *type;
struct value *val;
case UNOP_IND:
(*pos)++;
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
- type = check_typedef (VALUE_TYPE (val));
+ type = check_typedef (value_type (val));
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF
&& TYPE_CODE (type) != TYPE_CODE_ARRAY)
- error ("Attempt to take contents of a non-pointer value.");
+ error (_("Attempt to take contents of a non-pointer value."));
type = check_typedef (TYPE_TARGET_TYPE (type));
return value_from_longest (builtin_type_int, (LONGEST)
TYPE_LENGTH (type));
default:
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
return value_from_longest (builtin_type_int,
- (LONGEST) TYPE_LENGTH (VALUE_TYPE (val)));
+ (LONGEST) TYPE_LENGTH (value_type (val)));
}
}
tmp[length + 3] = '\0';
expr = parse_expression (tmp);
if (expr->elts[0].opcode != UNOP_CAST)
- error ("Internal error in eval_type.");
+ error (_("Internal error in eval_type."));
return expr->elts[1].type;
}
struct type *tmp_type;
if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
- error ("Can't get dimensions for a non-array type");
+ error (_("Can't get dimensions for a non-array type"));
tmp_type = array_type;
projects / binutils.git / blobdiff