/* Evaluate expressions for GDB.
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,
+ 2009 Free Software Foundation, Inc.
This file is part of GDB.
#include "exceptions.h"
#include "regcache.h"
#include "user-regs.h"
+#include "valprint.h"
+#include "python/python.h"
#include "gdb_assert.h"
+#include <ctype.h>
+
/* This is defined in valops.c */
extern int overload_resolution;
-/* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
- on with successful lookup for member/method of the rtti type. */
-extern int objectprint;
-
/* Prototypes for local functions. */
static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
fieldno++;
/* Skip static fields. */
while (fieldno < TYPE_NFIELDS (struct_type)
- && TYPE_FIELD_STATIC_KIND (struct_type, fieldno))
+ && field_is_static (&TYPE_FIELD (struct_type,
+ fieldno)))
fieldno++;
subfieldno = fieldno;
if (fieldno >= TYPE_NFIELDS (struct_type))
return index;
}
-struct value *
+static struct value *
value_f90_subarray (struct value *array,
struct expression *exp, int *pos, enum noside noside)
{
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
&& TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
- struct type *range_type = TYPE_FIELD_TYPE (type, 0);
+ struct type *range_type = TYPE_INDEX_TYPE (type);
struct type *element_type = TYPE_TARGET_TYPE (type);
struct value *array = allocate_value (expect_type);
int element_size = TYPE_LENGTH (check_typedef (element_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 = find_function_in_inferior ("objc_msg_lookup", NULL);
+ msg_send_stret
+ = find_function_in_inferior ("objc_msg_lookup", NULL);
msg_send = value_from_pointer (type, value_as_address (msg_send));
msg_send_stret = value_from_pointer (type,
}
else
{
- msg_send = find_function_in_inferior ("objc_msgSend");
+ msg_send = find_function_in_inferior ("objc_msgSend", NULL);
/* Special dispatcher for methods returning structs */
- msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+ msg_send_stret
+ = find_function_in_inferior ("objc_msgSend_stret", NULL);
}
/* Verify the target object responds to this method. The
else
error (_("Expression of type other than \"Function returning ...\" used as function"));
}
+ if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
+ return call_internal_function (argvec[0], nargs, argvec + 1);
+
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 */
struct type *type = value_type (arg1);
struct type *real_type;
int full, top, using_enc;
-
- if (objectprint && TYPE_TARGET_TYPE(type) &&
+ struct value_print_options opts;
+
+ get_user_print_options (&opts);
+ if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
(TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
if (nargs != ndimensions)
error (_("Wrong number of subscripts"));
+ gdb_assert (nargs > 0);
+
/* Now that we know we have a legal array subscript expression
let us actually find out where this element exists in the array. */
/* 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"));
-
- retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
- if (retcode == BOUND_FETCH_ERROR)
- error (_("Cannot obtain dynamic lower bound"));
+ upper = f77_get_upperbound (tmp_type);
+ lower = f77_get_lowerbound (tmp_type);
array_size_array[nargs - i - 1] = upper - lower + 1;
/* Construct a value node with the value of the offset */
- arg2 = value_from_longest (builtin_type_f_integer, offset_item);
+ arg2 = value_from_longest (builtin_type_int32, offset_item);
/* Let us now play a dirty trick: we will take arg1
which is a value node pointing to the topmost level
if (noside == EVAL_SKIP)
goto nosideret;
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return allocate_value (exp->elts[pc + 1].type);
+ {
+ struct type *type = exp->elts[pc + 1].type;
+ /* If this is a typedef, then find its immediate target. We
+ use check_typedef to resolve stubs, but we ignore its
+ result because we do not want to dig past all
+ typedefs. */
+ check_typedef (type);
+ if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ type = TYPE_TARGET_TYPE (type);
+ return allocate_value (type);
+ }
else
error (_("Attempt to use a type name as an expression"));
return
value_zero (type, not_lval);
}
- else if (symbol_read_needs_frame (var))
- return
- locate_var_value
- (var,
- block_innermost_frame (exp->elts[pc + 1].block));
else
- return locate_var_value (var, NULL);
+ return address_of_variable (var, exp->elts[pc + 1].block);
case OP_SCOPE:
tem = longest_to_int (exp->elts[pc + 2].longconst);
int pc;
struct value *val;
struct symbol *var;
+ struct type *type;
pc = (*pos);
op = exp->elts[pc].opcode;
{
case OP_VAR_VALUE:
var = exp->elts[pc + 2].symbol;
- if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
+ type = check_typedef (SYMBOL_TYPE (var));
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY
&& CAST_IS_CONVERSION)
{
(*pos) += 4;
- val =
- locate_var_value
- (var, block_innermost_frame (exp->elts[pc + 1].block));
- return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
+ val = address_of_variable (var, exp->elts[pc + 1].block);
+ return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
val);
}
/* FALLTHROUGH */
projects / deliverable / binutils-gdb.git / blobdiff