2011-01-07 Michael Snyder <msnyder@vmware.com>
* ada-lang.c: Comment cleanup, mostly periods and spaces. * ada-lang.h: Ditto. * ada-tasks.c: Ditto. * ada-valprint.c: Ditto. * aix-threads.c: Ditto. * alpha-linux-nat.c: Ditto. * alpha-linux-tdep.c: Ditto. * alpha-mdebug-tdep.c: Ditto. * alpha-nat.c: Ditto. * alpha-osf1-tdep.c: Ditto. * alpha-tdep.c: Ditto. * alphabsd-nat.c: Ditto. * alphabsd-tdep.c: Ditto. * amd64-darwin-tdep.c: Ditto. * amd64-linux-nat.c: Ditto. * amd64-linux-tdep.c: Ditto. * amd64-sol2-tdep.c: Ditto. * amd64-tdep.c: Ditto. * amd64-fbsd-tdep.c: Ditto. * amd64-nbsd-tdep.c: Ditto. * amd64-obsd-tdep.c: Ditto. * amd64-linux-nat.c: Ditto. * amd64-linux-tdep.c: Ditto. * arm-tdep.c: Ditto. * arm-tdep.h: Ditto. * armnbsd-nat.c: Ditto. * avr-tdep.c: Ditto. * bfin-tdep.c: Ditto. * bsd-kvm.c: Ditto. * c-typeprintc: Ditto. * c-valprint.c: Ditto. * coff-pe-read.h: Ditto. * coffreead.c: Ditto. * cris-tdep.c: Ditto. * d-lang.c: Ditto. * darwin-nat-info.c: Ditto. * darwin-nat.c: Ditto. * dbug-rom.c: Ditto. * dbxread.c: Ditto. * dcache.c: Ditto. * dcache.h: Ditto. * dec-thread.c: Ditto. * defs.h: Ditto. * demangle.c: Ditto. * dicos-tdep.c: Ditto. * dictionary.c: Ditto. * dictionary.h: Ditto. * dink32-rom.c: Ditto. * disasm.c: Ditto. * doublest.c: Ditto. * dsrec.c: Ditto. * dummy-frame.c: Ditto. * dwarf2-frame.c: Ditto. * dwarf2expr.c: Ditto. * dwarf2loc.c: Ditto. * dwarf2read.c: Ditto. * elfread.c: Ditto. * environ.c: Ditto. * eval.c: Ditto. * event-top.h: Ditto. * exceptions.c: Ditto. * exceptions.h: Ditto. * exec.c: Ditto. * expprint.c: Ditto. * expression.h: Ditto. * f-exp.y: Ditto. * f-lang.c: Ditto. * f-lang.h: Ditto. * f-typeprint.c: Ditto. * f-valprint.c: Ditto. * fbsd-nat.c: Ditto. * findvar.c: Ditto. * fork-child.c: Ditto. * frame.c: Ditto. * frame.h: Ditto. * frv-linux-tdep.c: Ditto. * frv-tdep.c: Ditto. * gcore.c: Ditto. * gdb-stabs.h: Ditto. * gdb_assert.h: Ditto. * gdb_string.h: Ditto. * gdb_thread_db.h: Ditto. * gdb_wait.h: Ditto. * gdbarch.sh: Ditto. * gdbcore.h: Ditto. * gdbthread.h: Ditto. * gdbtypes.c: Ditto. * gdbtypes.h: Ditto. * gnu-nat.c: Ditto. * gnu-nat.h: Ditto. * gnu-v2-abi.c: Ditto. * gnu-v3-abi.c: Ditto. * go32-nat.c: Ditto. * gdbarch.c: Regenerate. * gdbarch.h: Regenerate.
This commit is contained in:
Michael Snyder
parent
87973e9f82
commit
0963b4bd45
97 changed files with 1538 additions and 1304 deletions
160
gdb/eval.c
160
gdb/eval.c
|
|
@ -27,8 +27,8 @@
|
|||
#include "expression.h"
|
||||
#include "target.h"
|
||||
#include "frame.h"
|
||||
#include "language.h" /* For CAST_IS_CONVERSION */
|
||||
#include "f-lang.h" /* for array bound stuff */
|
||||
#include "language.h" /* For CAST_IS_CONVERSION. */
|
||||
#include "f-lang.h" /* For array bound stuff. */
|
||||
#include "cp-abi.h"
|
||||
#include "infcall.h"
|
||||
#include "objc-lang.h"
|
||||
|
|
@ -52,7 +52,7 @@
|
|||
/* This is defined in valops.c */
|
||||
extern int overload_resolution;
|
||||
|
||||
/* Prototypes for local functions. */
|
||||
/* Prototypes for local functions. */
|
||||
|
||||
static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
|
||||
|
||||
|
|
@ -110,7 +110,7 @@ parse_and_eval_address_1 (char **expptr)
|
|||
}
|
||||
|
||||
/* Like parse_and_eval_address, but treats the value of the expression
|
||||
as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
|
||||
as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
|
||||
LONGEST
|
||||
parse_and_eval_long (char *exp)
|
||||
{
|
||||
|
|
@ -288,7 +288,7 @@ extract_field_op (struct expression *exp, int *subexp)
|
|||
}
|
||||
|
||||
/* If the next expression is an OP_LABELED, skips past it,
|
||||
returning the label. Otherwise, does nothing and returns NULL. */
|
||||
returning the label. Otherwise, does nothing and returns NULL. */
|
||||
|
||||
static char *
|
||||
get_label (struct expression *exp, int *pos)
|
||||
|
|
@ -329,7 +329,7 @@ evaluate_struct_tuple (struct value *struct_val,
|
|||
int bitpos, bitsize;
|
||||
bfd_byte *addr;
|
||||
|
||||
/* Skip past the labels, and count them. */
|
||||
/* Skip past the labels, and count them. */
|
||||
while (get_label (exp, pos) != NULL)
|
||||
nlabels++;
|
||||
|
||||
|
|
@ -390,7 +390,7 @@ evaluate_struct_tuple (struct value *struct_val,
|
|||
}
|
||||
else
|
||||
{
|
||||
/* Unlabelled tuple element - go to next field. */
|
||||
/* Unlabelled tuple element - go to next field. */
|
||||
if (variantno >= 0)
|
||||
{
|
||||
subfieldno++;
|
||||
|
|
@ -425,15 +425,15 @@ evaluate_struct_tuple (struct value *struct_val,
|
|||
The value fieldno is the index of the top-level (normal or
|
||||
anonymous union) field in struct_field, while the value
|
||||
subfieldno is the index of the actual real (named inner) field
|
||||
in substruct_type. */
|
||||
in substruct_type. */
|
||||
|
||||
field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
|
||||
if (val == 0)
|
||||
val = evaluate_subexp (field_type, exp, pos, noside);
|
||||
|
||||
/* Now actually set the field in struct_val. */
|
||||
/* Now actually set the field in struct_val. */
|
||||
|
||||
/* Assign val to field fieldno. */
|
||||
/* Assign val to field fieldno. */
|
||||
if (value_type (val) != field_type)
|
||||
val = value_cast (field_type, val);
|
||||
|
||||
|
|
@ -852,7 +852,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
We need a full value object returned here for whatis_exp ()
|
||||
to call evaluate_type () and then pass the full value to
|
||||
value_rtti_target_type () if we are dealing with a pointer
|
||||
or reference to a base class and print object is on. */
|
||||
or reference to a base class and print object is on. */
|
||||
|
||||
{
|
||||
volatile struct gdb_exception except;
|
||||
|
|
@ -1004,7 +1004,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
else
|
||||
{
|
||||
if (index > high_bound)
|
||||
/* to avoid memory corruption */
|
||||
/* To avoid memory corruption. */
|
||||
error (_("Too many array elements"));
|
||||
memcpy (value_contents_raw (array)
|
||||
+ (index - low_bound) * element_size,
|
||||
|
|
@ -1025,7 +1025,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
struct type *check_type = element_type;
|
||||
LONGEST low_bound, high_bound;
|
||||
|
||||
/* get targettype of elementtype */
|
||||
/* Get targettype of elementtype. */
|
||||
while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
|
||||
|| TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
|
||||
check_type = TYPE_TARGET_TYPE (check_type);
|
||||
|
|
@ -1055,9 +1055,9 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
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
|
||||
/* Check types of elements to avoid mixture of elements from
|
||||
different types. Also check if type of element is "compatible"
|
||||
with element type of powerset */
|
||||
with element type of powerset. */
|
||||
if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
|
||||
range_low_type = TYPE_TARGET_TYPE (range_low_type);
|
||||
if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
|
||||
|
|
@ -1065,7 +1065,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
|
||||
|| (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
|
||||
&& (range_low_type != range_high_type)))
|
||||
/* different element modes */
|
||||
/* different element modes. */
|
||||
error (_("POWERSET tuple elements of different mode"));
|
||||
if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
|
||||
|| (TYPE_CODE (check_type) == TYPE_CODE_ENUM
|
||||
|
|
@ -1096,7 +1096,8 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
|
||||
for (tem = 0; tem < nargs; tem++)
|
||||
{
|
||||
/* Ensure that array expressions are coerced into pointer objects. */
|
||||
/* Ensure that array expressions are coerced into pointer
|
||||
objects. */
|
||||
argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
|
||||
}
|
||||
if (noside == EVAL_SKIP)
|
||||
|
|
@ -1213,7 +1214,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
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
|
||||
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)
|
||||
|
|
@ -1236,15 +1237,15 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
else
|
||||
{
|
||||
msg_send = find_function_in_inferior ("objc_msgSend", NULL);
|
||||
/* Special dispatcher for methods returning structs */
|
||||
/* Special dispatcher for methods returning structs. */
|
||||
msg_send_stret
|
||||
= find_function_in_inferior ("objc_msgSend_stret", NULL);
|
||||
}
|
||||
|
||||
/* Verify the target object responds to this method. The
|
||||
/* 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. */
|
||||
often used, 'NSObject' class. Make sure we check for both. */
|
||||
|
||||
responds_selector
|
||||
= lookup_child_selector (exp->gdbarch, "respondsToSelector:");
|
||||
|
|
@ -1265,7 +1266,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
error (_("no 'methodFor:' or 'methodForSelector:' method"));
|
||||
|
||||
/* Call the verification method, to make sure that the target
|
||||
class implements the desired method. */
|
||||
class implements the desired method. */
|
||||
|
||||
argvec[0] = msg_send;
|
||||
argvec[1] = target;
|
||||
|
|
@ -1287,7 +1288,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
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). */
|
||||
thing). */
|
||||
|
||||
argvec[0] = msg_send;
|
||||
argvec[1] = target;
|
||||
|
|
@ -1401,11 +1402,11 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
{
|
||||
/* 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
|
||||
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. */
|
||||
it. */
|
||||
|
||||
struct type *type = value_type (called_method);
|
||||
|
||||
|
|
@ -1456,13 +1457,13 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
op = exp->elts[*pos].opcode;
|
||||
nargs = longest_to_int (exp->elts[pc + 1].longconst);
|
||||
/* Allocate arg vector, including space for the function to be
|
||||
called in argvec[0] and a terminating NULL */
|
||||
called in argvec[0] and a terminating NULL. */
|
||||
argvec = (struct value **)
|
||||
alloca (sizeof (struct value *) * (nargs + 3));
|
||||
if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
|
||||
{
|
||||
nargs++;
|
||||
/* First, evaluate the structure into arg2 */
|
||||
/* First, evaluate the structure into arg2. */
|
||||
pc2 = (*pos)++;
|
||||
|
||||
if (noside == EVAL_SKIP)
|
||||
|
|
@ -1499,16 +1500,16 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
else
|
||||
arg1 = cplus_method_ptr_to_value (&arg2, arg1);
|
||||
|
||||
/* Now, say which argument to start evaluating from */
|
||||
/* Now, say which argument to start evaluating from. */
|
||||
tem = 2;
|
||||
}
|
||||
else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
|
||||
{
|
||||
/* Hair for method invocations */
|
||||
/* Hair for method invocations. */
|
||||
int tem2;
|
||||
|
||||
nargs++;
|
||||
/* First, evaluate the structure into arg2 */
|
||||
/* First, evaluate the structure into arg2. */
|
||||
pc2 = (*pos)++;
|
||||
tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
|
||||
*pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
|
||||
|
|
@ -1560,7 +1561,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
arg2 = value;
|
||||
}
|
||||
}
|
||||
/* Now, say which argument to start evaluating from */
|
||||
/* Now, say which argument to start evaluating from. */
|
||||
tem = 2;
|
||||
}
|
||||
else if (op == OP_SCOPE
|
||||
|
|
@ -1617,7 +1618,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
}
|
||||
else
|
||||
{
|
||||
/* Non-method function call */
|
||||
/* Non-method function call. */
|
||||
save_pos1 = *pos;
|
||||
tem = 1;
|
||||
|
||||
|
|
@ -1647,14 +1648,15 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
}
|
||||
}
|
||||
|
||||
/* Evaluate arguments */
|
||||
/* Evaluate arguments. */
|
||||
for (; tem <= nargs; tem++)
|
||||
{
|
||||
/* Ensure that array expressions are coerced into pointer objects. */
|
||||
/* Ensure that array expressions are coerced into pointer
|
||||
objects. */
|
||||
argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
|
||||
}
|
||||
|
||||
/* signal end of arglist */
|
||||
/* Signal end of arglist. */
|
||||
argvec[tem] = 0;
|
||||
if (op == OP_ADL_FUNC)
|
||||
{
|
||||
|
|
@ -1668,7 +1670,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
func_name = (char *) alloca (name_len + 1);
|
||||
strcpy (func_name, &exp->elts[string_pc + 1].string);
|
||||
|
||||
/* Prepare list of argument types for overload resolution */
|
||||
/* Prepare list of argument types for overload resolution. */
|
||||
arg_types = (struct type **)
|
||||
alloca (nargs * (sizeof (struct type *)));
|
||||
for (ix = 1; ix <= nargs; ix++)
|
||||
|
|
@ -1692,12 +1694,12 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
int static_memfuncp;
|
||||
char *tstr;
|
||||
|
||||
/* Method invocation : stuff "this" as first parameter */
|
||||
/* Method invocation : stuff "this" as first parameter. */
|
||||
argvec[1] = arg2;
|
||||
|
||||
if (op != OP_SCOPE)
|
||||
{
|
||||
/* Name of method from expression */
|
||||
/* Name of method from expression. */
|
||||
tstr = &exp->elts[pc2 + 2].string;
|
||||
}
|
||||
else
|
||||
|
|
@ -1707,10 +1709,10 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
== language_cplus))
|
||||
{
|
||||
/* Language is C++, do some overload resolution before
|
||||
evaluation */
|
||||
evaluation. */
|
||||
struct value *valp = NULL;
|
||||
|
||||
/* Prepare list of argument types for overload resolution */
|
||||
/* Prepare list of argument types for overload resolution. */
|
||||
arg_types = (struct type **)
|
||||
alloca (nargs * (sizeof (struct type *)));
|
||||
for (ix = 1; ix <= nargs; ix++)
|
||||
|
|
@ -1731,11 +1733,11 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
function_name);
|
||||
}
|
||||
argvec[1] = arg2; /* the ``this'' pointer */
|
||||
argvec[0] = valp; /* use the method found after overload
|
||||
resolution */
|
||||
argvec[0] = valp; /* Use the method found after overload
|
||||
resolution. */
|
||||
}
|
||||
else
|
||||
/* Non-C++ case -- or no overload resolution */
|
||||
/* Non-C++ case -- or no overload resolution. */
|
||||
{
|
||||
struct value *temp = arg2;
|
||||
|
||||
|
|
@ -1767,16 +1769,16 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
}
|
||||
else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
|
||||
{
|
||||
/* Non-member function being called */
|
||||
/* Non-member function being called. */
|
||||
/* fn: This can only be done for C++ functions. A C-style function
|
||||
in a C++ program, for instance, does not have the fields that
|
||||
are expected here */
|
||||
are expected here. */
|
||||
|
||||
if (overload_resolution && (exp->language_defn->la_language
|
||||
== language_cplus))
|
||||
{
|
||||
/* Language is C++, do some overload resolution before
|
||||
evaluation */
|
||||
evaluation. */
|
||||
struct symbol *symp;
|
||||
int no_adl = 0;
|
||||
|
||||
|
|
@ -1787,7 +1789,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
if (op == OP_VAR_VALUE)
|
||||
function = exp->elts[save_pos1+2].symbol;
|
||||
|
||||
/* Prepare list of argument types for overload resolution */
|
||||
/* Prepare list of argument types for overload resolution. */
|
||||
arg_types = (struct type **)
|
||||
alloca (nargs * (sizeof (struct type *)));
|
||||
for (ix = 1; ix <= nargs; ix++)
|
||||
|
|
@ -1802,7 +1804,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
|
||||
if (op == OP_VAR_VALUE)
|
||||
{
|
||||
/* Now fix the expression being evaluated */
|
||||
/* Now fix the expression being evaluated. */
|
||||
exp->elts[save_pos1+2].symbol = symp;
|
||||
argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
|
||||
noside);
|
||||
|
|
@ -1812,14 +1814,14 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
}
|
||||
else
|
||||
{
|
||||
/* Not C++, or no overload resolution allowed */
|
||||
/* nothing to be done; argvec already correctly set up */
|
||||
/* Not C++, or no overload resolution allowed. */
|
||||
/* Nothing to be done; argvec already correctly set up. */
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* It is probably a C-style function */
|
||||
/* nothing to be done; argvec already correctly set up */
|
||||
/* It is probably a C-style function. */
|
||||
/* Nothing to be done; argvec already correctly set up. */
|
||||
}
|
||||
|
||||
do_call_it:
|
||||
|
|
@ -1832,10 +1834,10 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
{
|
||||
/* 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
|
||||
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. */
|
||||
it won't offer it. */
|
||||
|
||||
struct type *ftype = value_type (argvec[0]);
|
||||
|
||||
|
|
@ -1867,8 +1869,8 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
array subscript operations cannot be disambiguated
|
||||
at parse time. We have made all array subscript operations,
|
||||
substring operations as well as function calls come here
|
||||
and we now have to discover what the heck this thing actually was.
|
||||
If it is a function, we process just as if we got an OP_FUNCALL. */
|
||||
and we now have to discover what the heck this thing actually was.
|
||||
If it is a function, we process just as if we got an OP_FUNCALL. */
|
||||
|
||||
nargs = longest_to_int (exp->elts[pc + 1].longconst);
|
||||
(*pos) += 2;
|
||||
|
|
@ -1915,9 +1917,9 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
|
||||
case TYPE_CODE_PTR:
|
||||
case TYPE_CODE_FUNC:
|
||||
/* It's a function call. */
|
||||
/* It's a function call. */
|
||||
/* Allocate arg vector, including space for the function to be
|
||||
called in argvec[0] and a terminating NULL */
|
||||
called in argvec[0] and a terminating NULL. */
|
||||
argvec = (struct value **)
|
||||
alloca (sizeof (struct value *) * (nargs + 2));
|
||||
argvec[0] = arg1;
|
||||
|
|
@ -1933,7 +1935,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
|
||||
case OP_COMPLEX:
|
||||
/* We have a complex number, There should be 2 floating
|
||||
point numbers that compose it */
|
||||
point numbers that compose it. */
|
||||
(*pos) += 2;
|
||||
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
||||
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
||||
|
|
@ -1989,7 +1991,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
|
||||
/* JYG: if print object is on we need to replace the base type
|
||||
with rtti type in order to continue on with successful
|
||||
lookup of member / method only available in the rtti type. */
|
||||
lookup of member / method only available in the rtti type. */
|
||||
{
|
||||
struct type *type = value_type (arg1);
|
||||
struct type *real_type;
|
||||
|
|
@ -2248,7 +2250,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
{
|
||||
/* If the user attempts to subscript something that is not an
|
||||
array or pointer type (like a plain int variable for example),
|
||||
then report this as an error. */
|
||||
then report this as an error. */
|
||||
|
||||
arg1 = coerce_ref (arg1);
|
||||
type = check_typedef (value_type (arg1));
|
||||
|
|
@ -2283,7 +2285,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
while (nargs-- > 0)
|
||||
{
|
||||
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
|
||||
/* FIXME: EVAL_SKIP handling may not be correct. */
|
||||
/* FIXME: EVAL_SKIP handling may not be correct. */
|
||||
if (noside == EVAL_SKIP)
|
||||
{
|
||||
if (nargs > 0)
|
||||
|
|
@ -2295,12 +2297,12 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
goto nosideret;
|
||||
}
|
||||
}
|
||||
/* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
|
||||
/* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
|
||||
if (noside == EVAL_AVOID_SIDE_EFFECTS)
|
||||
{
|
||||
/* If the user attempts to subscript something that has no target
|
||||
type (like a plain int variable for example), then report this
|
||||
as an error. */
|
||||
as an error. */
|
||||
|
||||
type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
|
||||
if (type != NULL)
|
||||
|
|
@ -2356,7 +2358,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
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 */
|
||||
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);
|
||||
|
|
@ -2370,21 +2372,21 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
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. */
|
||||
let us actually find out where this element exists in the array. */
|
||||
|
||||
offset_item = 0;
|
||||
/* Take array indices left to right */
|
||||
/* Take array indices left to right. */
|
||||
for (i = 0; i < nargs; i++)
|
||||
{
|
||||
/* Evaluate each subscript, It must be a legal integer in F77 */
|
||||
/* 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 */
|
||||
/* Fill in the subscript and array size arrays. */
|
||||
|
||||
subscript_array[i] = value_as_long (arg2);
|
||||
}
|
||||
|
||||
/* Internal type of array is arranged right to left */
|
||||
/* Internal type of array is arranged right to left. */
|
||||
for (i = 0; i < nargs; i++)
|
||||
{
|
||||
upper = f77_get_upperbound (tmp_type);
|
||||
|
|
@ -2392,23 +2394,23 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
|
||||
array_size_array[nargs - i - 1] = upper - lower + 1;
|
||||
|
||||
/* Zero-normalize subscripts so that offsetting will work. */
|
||||
/* Zero-normalize subscripts so that offsetting will work. */
|
||||
|
||||
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
|
||||
type around for use when calling value_subscript()
|
||||
below. This is done because we pretend to value_subscript
|
||||
below. This is done because we pretend to value_subscript
|
||||
that we actually have a one-dimensional array
|
||||
of base element type that we apply a simple
|
||||
offset to. */
|
||||
offset to. */
|
||||
|
||||
if (i < nargs - 1)
|
||||
tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
|
||||
}
|
||||
|
||||
/* Now let us calculate the offset for this item */
|
||||
/* Now let us calculate the offset for this item. */
|
||||
|
||||
offset_item = subscript_array[ndimensions - 1];
|
||||
|
||||
|
|
@ -2421,7 +2423,7 @@ evaluate_subexp_standard (struct type *expect_type,
|
|||
of the multidimensional array-set and pretend
|
||||
that it is actually a array of the final element
|
||||
type, this will ensure that value_subscript()
|
||||
returns the correct type value */
|
||||
returns the correct type value. */
|
||||
|
||||
deprecated_set_value_type (arg1, tmp_type);
|
||||
return value_subscripted_rvalue (arg1, offset_item, 0);
|
||||
|
|
@ -2967,7 +2969,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
|
|||
var = exp->elts[pc + 2].symbol;
|
||||
|
||||
/* C++: The "address" of a reference should yield the address
|
||||
* of the object pointed to. Let value_addr() deal with it. */
|
||||
* of the object pointed to. Let value_addr() deal with it. */
|
||||
if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
|
||||
goto default_case;
|
||||
|
||||
|
|
@ -3030,9 +3032,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
|
|||
Note that we currently only do the coercion for C expressions, where
|
||||
arrays are zero based and the coercion is correct. For other languages,
|
||||
with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
|
||||
to decide if coercion is appropriate.
|
||||
|
||||
*/
|
||||
to decide if coercion is appropriate. */
|
||||
|
||||
struct value *
|
||||
evaluate_subexp_with_coercion (struct expression *exp,
|
||||
|
|
@ -3120,7 +3120,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
|
|||
}
|
||||
}
|
||||
|
||||
/* Parse a type expression in the string [P..P+LENGTH). */
|
||||
/* Parse a type expression in the string [P..P+LENGTH). */
|
||||
|
||||
struct type *
|
||||
parse_and_eval_type (char *p, int length)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue