/* Evaluate expressions for GDB.
- Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
+ Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-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. */
+ 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. */
#include "defs.h"
#include "gdb_string.h"
#include "target.h"
#include "frame.h"
#include "demangle.h"
-#include "language.h" /* For CAST_IS_CONVERSION */
-#include "f-lang.h" /* for array bound stuff */
-/* start-sanitize-gm */
-#ifdef GENERAL_MAGIC
-#include "gmagic.h"
-#endif /* GENERAL_MAGIC */
-/* end-sanitize-gm */
+#include "language.h" /* For CAST_IS_CONVERSION */
+#include "f-lang.h" /* for array bound stuff */
+
+/* Defined in symtab.c */
+extern int hp_som_som_object_present;
+
+/* 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 value_ptr evaluate_subexp_for_sizeof PARAMS ((struct expression *,
- int *));
+static value_ptr evaluate_subexp_for_sizeof (struct expression *, int *);
-static value_ptr evaluate_subexp_for_address PARAMS ((struct expression *,
- int *, enum noside));
+static value_ptr evaluate_subexp_for_address (struct expression *,
+ int *, enum noside);
-static value_ptr evaluate_subexp PARAMS ((struct type *, struct expression *,
- int *, enum noside));
+static value_ptr evaluate_subexp (struct type *, struct expression *,
+ int *, enum noside);
-static char *get_label PARAMS ((struct expression *, int *));
+static char *get_label (struct expression *, int *);
static value_ptr
-evaluate_struct_tuple PARAMS ((value_ptr, struct expression *, int *,
- enum noside, int));
+evaluate_struct_tuple (value_ptr, struct expression *, int *,
+ enum noside, int);
static LONGEST
-init_array_element PARAMS ((value_ptr, value_ptr, struct expression *,
- int *, enum noside, LONGEST, LONGEST));
+init_array_element (value_ptr, value_ptr, struct expression *,
+ int *, enum noside, LONGEST, LONGEST);
-#ifdef __GNUC__
+#if defined (__GNUC__) && !__STDC__
inline
#endif
static value_ptr
-evaluate_subexp (expect_type, exp, pos, noside)
- struct type *expect_type;
- register struct expression *exp;
- register int *pos;
- enum noside noside;
+evaluate_subexp (struct type *expect_type, register struct expression *exp,
+ register int *pos, enum noside noside)
{
return (*exp->language_defn->evaluate_exp) (expect_type, exp, pos, noside);
}
and return the result as a number. */
CORE_ADDR
-parse_and_eval_address (exp)
- char *exp;
+parse_and_eval_address (char *exp)
{
struct expression *expr = parse_expression (exp);
register CORE_ADDR addr;
- register struct cleanup *old_chain =
- make_cleanup (free_current_contents, &expr);
+ register struct cleanup *old_chain =
+ make_cleanup (free_current_contents, &expr);
addr = value_as_pointer (evaluate_expression (expr));
do_cleanups (old_chain);
and advanced that variable across the characters parsed. */
CORE_ADDR
-parse_and_eval_address_1 (expptr)
- char **expptr;
+parse_and_eval_address_1 (char **expptr)
{
- struct expression *expr = parse_exp_1 (expptr, (struct block *)0, 0);
+ struct expression *expr = parse_exp_1 (expptr, (struct block *) 0, 0);
register CORE_ADDR addr;
register struct cleanup *old_chain =
- make_cleanup (free_current_contents, &expr);
+ make_cleanup (free_current_contents, &expr);
addr = value_as_pointer (evaluate_expression (expr));
do_cleanups (old_chain);
}
value_ptr
-parse_and_eval (exp)
- char *exp;
+parse_and_eval (char *exp)
{
struct expression *expr = parse_expression (exp);
register value_ptr val;
register struct cleanup *old_chain
- = make_cleanup (free_current_contents, &expr);
+ = make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
do_cleanups (old_chain);
EXPP is advanced to point to the comma. */
value_ptr
-parse_to_comma_and_eval (expp)
- char **expp;
+parse_to_comma_and_eval (char **expp)
{
struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1);
register value_ptr val;
register struct cleanup *old_chain
- = make_cleanup (free_current_contents, &expr);
+ = make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
do_cleanups (old_chain);
See expression.h for info on the format of an expression. */
value_ptr
-evaluate_expression (exp)
- struct expression *exp;
+evaluate_expression (struct expression *exp)
{
int pc = 0;
return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
and getting a value whose type alone is correct. */
value_ptr
-evaluate_type (exp)
- struct expression *exp;
+evaluate_type (struct expression *exp)
{
int pc = 0;
return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
/* If the next expression is an OP_LABELED, skips past it,
returning the label. Otherwise, does nothing and returns NULL. */
-static char*
-get_label (exp, pos)
- register struct expression *exp;
- int *pos;
+static char *
+get_label (register struct expression *exp, int *pos)
{
if (exp->elts[*pos].opcode == OP_LABELED)
{
return NULL;
}
-/* This function evaluates tupes (in Chill) or brace-initializers
+/* This function evaluates tuples (in Chill) or brace-initializers
(in C/C++) for structure types. */
static value_ptr
-evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
- value_ptr struct_val;
- register struct expression *exp;
- register int *pos;
- enum noside noside;
- int nargs;
+evaluate_struct_tuple (value_ptr struct_val, register struct expression *exp,
+ register int *pos, enum noside noside, int nargs)
{
struct type *struct_type = check_typedef (VALUE_TYPE (struct_val));
struct type *substruct_type = struct_type;
int fieldno = -1;
int variantno = -1;
int subfieldno = -1;
- while (--nargs >= 0)
+ while (--nargs >= 0)
{
int pc = *pos;
value_ptr val = NULL;
int nlabels = 0;
int bitpos, bitsize;
char *addr;
-
+
/* Skip past the labels, and count them. */
while (get_label (exp, pos) != NULL)
nlabels++;
substruct_type
= TYPE_FIELD_TYPE (field_type, variantno);
if (TYPE_CODE (substruct_type) == TYPE_CODE_STRUCT)
- {
+ {
for (subfieldno = 0;
- subfieldno < TYPE_NFIELDS (substruct_type);
+ subfieldno < TYPE_NFIELDS (substruct_type);
subfieldno++)
{
if (STREQ (TYPE_FIELD_NAME (substruct_type,
else
memcpy (addr, VALUE_CONTENTS (val),
TYPE_LENGTH (VALUE_TYPE (val)));
- } while (--nlabels > 0);
+ }
+ while (--nlabels > 0);
}
return struct_val;
}
Returns last index value. */
static LONGEST
-init_array_element (array, element, exp, pos, noside, low_bound, high_bound)
- value_ptr array, element;
- register struct expression *exp;
- register int *pos;
- enum noside noside;
- LONGEST low_bound, high_bound;
+init_array_element (value_ptr array, value_ptr element,
+ register struct expression *exp, register int *pos,
+ enum noside noside, LONGEST low_bound, LONGEST high_bound)
{
LONGEST index;
int element_size = TYPE_LENGTH (VALUE_TYPE (element));
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");
- for (index = low ; index <= high; index++)
+ for (index = low; index <= high; index++)
{
memcpy (VALUE_CONTENTS_RAW (array)
+ (index - low_bound) * element_size,
}
value_ptr
-evaluate_subexp_standard (expect_type, exp, pos, noside)
- struct type *expect_type;
- register struct expression *exp;
- register int *pos;
- enum noside noside;
+evaluate_subexp_standard (struct type *expect_type,
+ register struct expression *exp, register int *pos,
+ enum noside noside)
{
enum exp_opcode op;
int tem, tem2, tem3;
struct type *type;
int nargs;
value_ptr *argvec;
- int upper, lower, retcode;
+ int upper, lower, retcode;
int code;
-
- /* This expect_type crap should not be used for C. C expressions do
- not have any notion of expected types, never has and (goddess
- willing) never will. The C++ code uses it for some twisted
- purpose (I haven't investigated but I suspect it just the usual
- combination of Stroustrup figuring out some crazy language
- feature and Tiemann figuring out some crazier way to try to
- implement it). CHILL has the tuple stuff; I don't know enough
- about CHILL to know whether expected types is the way to do it.
- FORTRAN I don't know. */
- if (exp->language_defn->la_language != language_cplus
- && exp->language_defn->la_language != language_chill)
- expect_type = NULL_TYPE;
+ int ix;
+ long mem_offset;
+ struct type **arg_types;
+ int save_pos1;
pc = (*pos)++;
op = exp->elts[pc].opcode;
0,
exp->elts[pc + 1].type,
&exp->elts[pc + 3].string,
- expect_type);
+ NULL_TYPE);
if (arg1 == NULL)
error ("There is no field named %s", &exp->elts[pc + 3].string);
return arg1;
(*pos) += 3;
if (noside == EVAL_SKIP)
goto nosideret;
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- struct symbol * sym = exp->elts[pc + 2].symbol;
- enum lval_type lv;
- switch (SYMBOL_CLASS (sym))
- {
- case LOC_CONST:
- case LOC_LABEL:
- case LOC_CONST_BYTES:
- lv = not_lval;
- break;
-
- case LOC_REGISTER:
- case LOC_REGPARM:
- lv = lval_register;
- break;
-
- default:
- lv = lval_memory;
- break;
- }
+ /* JYG: We used to just return value_zero of the symbol type
+ if we're asked to avoid side effects. Otherwise we return
+ value_of_variable (...). However I'm not sure if
+ value_of_variable () has any side effect.
+ 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. */
- return value_zero (SYMBOL_TYPE (sym), lv);
- }
- else
return value_of_variable (exp->elts[pc + 2].symbol,
exp->elts[pc + 1].block);
access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
case OP_REGISTER:
- (*pos) += 2;
- return value_of_register (longest_to_int (exp->elts[pc + 1].longconst));
+ {
+ int regno = longest_to_int (exp->elts[pc + 1].longconst);
+ value_ptr val = value_of_register (regno);
+ (*pos) += 2;
+ if (val == NULL)
+ error ("Value of register %s not available.", REGISTER_NAME (regno));
+ else
+ return val;
+ }
case OP_BOOL:
(*pos) += 2;
return value_from_longest (LA_BOOL_TYPE,
- exp->elts[pc + 1].longconst);
+ exp->elts[pc + 1].longconst);
case OP_INTERNALVAR:
(*pos) += 2;
}
index = low_bound;
memset (VALUE_CONTENTS_RAW (array), 0, TYPE_LENGTH (expect_type));
- for (tem = nargs; --nargs >= 0; )
+ for (tem = nargs; --nargs >= 0;)
{
value_ptr element;
int index_pc = 0;
range_low = range_high = value_as_long (elem_val);
}
/* 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 */
+ different types. Also check if type of element is "compatible"
+ 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)
error ("POWERSET tuple element out of range");
range_low -= low_bound;
range_high -= low_bound;
- for ( ; range_low <= range_high; range_low++)
+ for (; range_low <= range_high; range_low++)
{
int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
if (BITS_BIG_ENDIAN)
bit_index = TARGET_CHAR_BIT - 1 - bit_index;
- valaddr [(unsigned) range_low / TARGET_CHAR_BIT]
+ valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
|= 1 << bit_index;
}
}
{
value_ptr array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
int lowbound
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
int upper
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
if (noside == EVAL_SKIP)
goto nosideret;
return value_slice (array, lowbound, upper - lowbound + 1);
{
value_ptr array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
int lowbound
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
int length
- = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+ = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
return value_slice (array, lowbound, length);
}
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 = (value_ptr *) alloca (sizeof (value_ptr) * (nargs + 3));
if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
{
LONGEST fnptr;
+ /* 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)
+ {
+ error ("Not implemented: function invocation through pointer to method with HP aCC");
+ }
+
nargs++;
/* First, evaluate the structure into arg2 */
pc2 = (*pos)++;
fnptr = value_as_long (arg1);
- if (METHOD_PTR_IS_VIRTUAL(fnptr))
+ if (METHOD_PTR_IS_VIRTUAL (fnptr))
{
- int fnoffset = METHOD_PTR_TO_VOFFSET(fnptr);
+ 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));
if (domain_type != basetype)
- arg2 = value_cast(lookup_pointer_type (domain_type), arg2);
+ arg2 = value_cast (lookup_pointer_type (domain_type), arg2);
basetype = TYPE_VPTR_BASETYPE (domain_type);
for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
{
if (op == STRUCTOP_STRUCT)
{
/* If v is a variable in a register, and the user types
- v.method (), this will produce an error, because v has
- no address.
-
- A possible way around this would be to allocate a
- copy of the variable on the stack, copy in the
- contents, call the function, and copy out the
- contents. I.e. convert this from call by reference
- to call by copy-return (or whatever it's called).
- However, this does not work because it is not the
- same: the method being called could stash a copy of
- the address, and then future uses through that address
- (after the method returns) would be expected to
- use the variable itself, not some copy of it. */
+ v.method (), this will produce an error, because v has
+ no address.
+
+ A possible way around this would be to allocate a
+ copy of the variable on the stack, copy in the
+ contents, call the function, and copy out the
+ contents. I.e. convert this from call by reference
+ to call by copy-return (or whatever it's called).
+ However, this does not work because it is not the
+ same: the method being called could stash a copy of
+ the address, and then future uses through that address
+ (after the method returns) would be expected to
+ use the variable itself, not some copy of it. */
arg2 = evaluate_subexp_for_address (exp, pos, noside);
}
else
}
else
{
+ /* Non-method function call */
+ save_pos1 = *pos;
argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
tem = 1;
type = VALUE_TYPE (argvec[0]);
{
for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
{
- argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem-1),
+ /* pai: FIXME This seems to be coercing arguments before
+ * overload resolution has been done! */
+ argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem - 1),
exp, pos, noside);
}
}
}
+ /* Evaluate arguments */
for (; tem <= nargs; tem++)
{
/* Ensure that array expressions are coerced into pointer objects. */
-
argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
}
{
int static_memfuncp;
value_ptr temp = arg2;
- char tstr[64];
+ char tstr[256];
+
+ /* Method invocation : stuff "this" as first parameter */
+ /* pai: this used to have lookup_pointer_type for some reason,
+ * but temp is already a pointer to the object */
+ argvec[1]
+ = value_from_pointer (VALUE_TYPE (temp),
+ VALUE_ADDRESS (temp) + VALUE_OFFSET (temp));
+ /* Name of method from expression */
+ strcpy (tstr, &exp->elts[pc2 + 2].string);
+
+ if (overload_resolution && (exp->language_defn->la_language == language_cplus))
+ {
+ /* Language is C++, do some overload resolution before evaluation */
+ value_ptr valp = NULL;
- argvec[1] = arg2;
- argvec[0] = 0;
- strcpy(tstr, &exp->elts[pc2+2].string);
- if (!argvec[0])
+ /* Prepare list of argument types for overload resolution */
+ arg_types = (struct type **) xmalloc (nargs * (sizeof (struct type *)));
+ for (ix = 1; ix <= nargs; ix++)
+ arg_types[ix - 1] = VALUE_TYPE (argvec[ix]);
+
+ (void) find_overload_match (arg_types, nargs, tstr,
+ 1 /* method */ , 0 /* strict match */ ,
+ arg2 /* the object */ , NULL,
+ &valp, NULL, &static_memfuncp);
+
+
+ argvec[1] = arg2; /* the ``this'' pointer */
+ argvec[0] = valp; /* use the method found after overload resolution */
+ }
+ else
+ /* Non-C++ case -- or no overload resolution */
{
temp = arg2;
- argvec[0] =
- value_struct_elt (&temp, argvec+1, tstr,
- &static_memfuncp,
- op == STRUCTOP_STRUCT
- ? "structure" : "structure pointer");
+ argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
+ &static_memfuncp,
+ op == STRUCTOP_STRUCT
+ ? "structure" : "structure pointer");
+ argvec[1] = arg2; /* the ``this'' pointer */
}
- arg2 = value_from_longest (lookup_pointer_type(VALUE_TYPE (temp)),
- VALUE_ADDRESS (temp)+VALUE_OFFSET (temp));
- argvec[1] = arg2;
if (static_memfuncp)
{
argvec[1] = arg2;
argvec[0] = arg1;
}
+ else if (op == OP_VAR_VALUE)
+ {
+ /* 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 */
+
+ if (overload_resolution && (exp->language_defn->la_language == language_cplus))
+ {
+ /* Language is C++, do some overload resolution before evaluation */
+ struct symbol *symp;
+
+ /* Prepare list of argument types for overload resolution */
+ arg_types = (struct type **) xmalloc (nargs * (sizeof (struct type *)));
+ for (ix = 1; ix <= nargs; 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 */ ,
+ NULL, exp->elts[save_pos1+2].symbol /* the function */ ,
+ NULL, &symp, NULL);
+
+ /* Now fix the expression being evaluated */
+ exp->elts[save_pos1+2].symbol = symp;
+ argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
+ }
+ else
+ {
+ /* 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 */
+ }
do_call_it:
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])));
else
error ("Expression of type other than \"Function returning ...\" used as function");
}
+ if (argvec[0] == NULL)
+ error ("Cannot evaluate function -- may be inlined");
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 */
- case OP_F77_UNDETERMINED_ARGLIST:
+ case OP_F77_UNDETERMINED_ARGLIST:
/* Remember that in F77, functions, substring ops and
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. */
+ If it is a function, we process just as if we got an OP_FUNCALL. */
- nargs = longest_to_int (exp->elts[pc+1].longconst);
+ nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 2;
- /* First determine the type code we are dealing with. */
+ /* First determine the type code we are dealing with. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
type = check_typedef (VALUE_TYPE (arg1));
code = TYPE_CODE (type);
- switch (code)
+ switch (code)
{
case TYPE_CODE_ARRAY:
goto multi_f77_subscript;
tem = 1;
for (; tem <= nargs; tem++)
argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
- argvec[tem] = 0; /* signal end of arglist */
+ argvec[tem] = 0; /* signal end of arglist */
goto do_call_it;
default:
- error ("Cannot perform substring on this type");
+ error ("Cannot perform substring on this type");
}
op_f77_substr:
arg3 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
- goto nosideret;
-
+ 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 */
+ point numbers that compose it */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
return value_literal_complex (arg1, arg2, builtin_type_f_complex_s16);
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
+
+ /* 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. */
+ {
+ struct type *type = VALUE_TYPE (arg1);
+ struct type *real_type;
+ int full, top, using_enc;
+
+ if (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 (real_type)
+ {
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ real_type = lookup_pointer_type (real_type);
+ else
+ real_type = lookup_reference_type (real_type);
+
+ arg1 = value_cast (real_type, arg1);
+ }
+ }
+ }
+
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
&exp->elts[pc + 2].string,
NULL, "structure pointer");
}
-/* start-sanitize-gm */
-#ifdef GENERAL_MAGIC
- case STRUCTOP_FIELD:
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (noside == EVAL_SKIP)
- goto nosideret;
- {
- CORE_ADDR object = value_as_long (arg1);
- struct type *type = type_of_object (object);
-
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (lookup_struct_elt_type (type,
- &exp->elts[pc + 2].string,
- 0),
- lval_memory);
- else
- {
- value_ptr temp = value_from_longest (builtin_type_unsigned_long,
- baseptr_of_object (value_as_long(arg1)));
-
- VALUE_TYPE (temp) = type;
- return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
- NULL, "structure pointer");
- }
- }
-#endif /* GENERAL_MAGIC */
-/* end-sanitize-gm */
-
case STRUCTOP_MEMBER:
arg1 = evaluate_subexp_for_address (exp, pos, noside);
+ 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 */
+
+ mem_offset = value_as_long (arg2);
goto handle_pointer_to_member;
+
case STRUCTOP_MPTR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- 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 */
+
+ 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 (!mem_offset) /* no bias -> really null */
+ error ("Attempted dereference of null pointer-to-member");
+ mem_offset &= ~0x20000000;
+ }
if (noside == EVAL_SKIP)
goto nosideret;
type = check_typedef (VALUE_TYPE (arg2));
/* Now, convert these values to an address. */
arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
arg1);
- arg3 = value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
- value_as_long (arg1) + value_as_long (arg2));
+ arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+ 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);
+
+ /* Do special stuff for HP aCC pointers to members */
+ if (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");
+
+ /* 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))
+ {
+ unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (arg2); /* forces evaluation */
+ *ptr |= 0x20000000; /* set 29th bit */
+ }
+ }
+
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
if (binop_user_defined_p (op, arg1, arg2))
goto nosideret;
if (binop_user_defined_p (op, arg1, arg2))
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);
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS
+ && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
+ return value_zero (VALUE_TYPE (arg1), not_lval);
else
return value_binop (arg1, arg2, op);
if (binop_user_defined_p (op, arg1, arg2))
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
else
- {
+ {
/* 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. */
return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
else
return value_subscript (arg1, arg2);
- }
+ }
case BINOP_IN:
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
return value_in (arg1, arg2);
-
+
case MULTI_SUBSCRIPT:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
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. */
-
+ type (like a plain int variable for example), then report this
+ as an error. */
+
type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
if (type != NULL)
{
TYPE_NAME (VALUE_TYPE (arg1)));
}
}
-
+
if (binop_user_defined_p (op, arg1, arg2))
{
arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
return (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 ndimensions=1,i;
- struct type *tmp_type;
- int offset_item; /* The array offset where the item lives */
+ {
+ int subscript_array[MAX_FORTRAN_DIMS + 1]; /* 1-based array of
+ subscripts, max == 7 */
+ int array_size_array[MAX_FORTRAN_DIMS + 1];
+ 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 ("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. */
+ let us actually find out where this element exists in the array. */
- offset_item = 0;
+ offset_item = 0;
for (i = 1; 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);
-
+
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);
+ 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;
-
- /* Zero-normalize subscripts so that offsetting will work. */
-
+
+ /* Zero-normalize subscripts so that offsetting will work. */
+
subscript_array[i] -= lower;
/* If we are at the bottom of a multidimensional
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)
- tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
+ if (i < nargs)
+ 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];
+
for (i = ndimensions - 1; i >= 1; i--)
- offset_item =
+ offset_item =
array_size_array[i] * offset_item + subscript_array[i];
/* 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_f_integer, offset_item);
/* Let us now play a dirty trick: we will take arg1
which is a value node pointing to the topmost level
type, this will ensure that value_subscript()
returns the correct type value */
- VALUE_TYPE (arg1) = tmp_type;
+ VALUE_TYPE (arg1) = tmp_type;
return value_ind (value_add (value_coerce_array (arg1), arg2));
}
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
goto nosideret;
}
-
+
oldpos = *pos;
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
*pos = oldpos;
-
- if (binop_user_defined_p (op, arg1, arg2))
+
+ if (binop_user_defined_p (op, arg1, arg2))
{
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(tem ? EVAL_SKIP : noside));
return value_from_longest (LA_BOOL_TYPE,
- (LONGEST) (!tem && !value_logical_not (arg2)));
+ (LONGEST) (!tem && !value_logical_not (arg2)));
}
case BINOP_LOGICAL_OR:
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
goto nosideret;
}
-
+
oldpos = *pos;
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
*pos = oldpos;
-
- if (binop_user_defined_p (op, arg1, arg2))
+
+ if (binop_user_defined_p (op, arg1, arg2))
{
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(!tem ? EVAL_SKIP : noside));
return value_from_longest (LA_BOOL_TYPE,
- (LONGEST) (!tem || !value_logical_not (arg2)));
+ (LONGEST) (!tem || !value_logical_not (arg2)));
}
case BINOP_EQUAL:
{
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
}
- else
+ else
{
tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
return value_from_longest (LA_BOOL_TYPE, (LONGEST) tem);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
return allocate_repeat_value (VALUE_TYPE (arg1),
- longest_to_int (value_as_long (arg2)));
+ longest_to_int (value_as_long (arg2)));
}
else
return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
if (unop_user_defined_p (op, arg1))
return value_x_unop (arg1, op, noside);
else
- return value_from_longest (builtin_type_int,
+ return value_from_longest (LA_BOOL_TYPE,
(LONGEST) value_logical_not (arg1));
case UNOP_IND:
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
- expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
+ 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 (noside == EVAL_SKIP)
goto nosideret;
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ 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));
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. */
+ /* In C you can dereference an array to get the 1st elt. */
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
- )
+ )
return value_zero (TYPE_TARGET_TYPE (type),
lval_memory);
else if (TYPE_CODE (type) == TYPE_CODE_INT)
case UNOP_ADDR:
/* C++: check for and handle pointer to members. */
-
+
op = exp->elts[*pos].opcode;
if (noside == EVAL_SKIP)
{
if (op == OP_SCOPE)
{
- int temm = longest_to_int (exp->elts[pc+3].longconst);
+ int temm = longest_to_int (exp->elts[pc + 3].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (temm + 1);
}
else
- evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
+ evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
goto nosideret;
}
-
- return evaluate_subexp_for_address (exp, pos, noside);
+ else
+ {
+ value_ptr 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))
+ {
+ unsigned int *ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* forces evaluation */
+ *ptr |= 0x20000000; /* set 29th bit */
+ }
+ return retvalp;
+ }
case UNOP_SIZEOF:
if (noside == EVAL_SKIP)
}
else
{
- arg2 = value_add (arg1, value_from_longest (builtin_type_char,
- (LONGEST) 1));
+ arg2 = value_add (arg1, value_from_longest (builtin_type_char,
+ (LONGEST) 1));
return value_assign (arg1, arg2);
}
}
else
{
- arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
- (LONGEST) 1));
+ arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
+ (LONGEST) 1));
return value_assign (arg1, arg2);
}
}
else
{
- arg2 = value_add (arg1, value_from_longest (builtin_type_char,
- (LONGEST) 1));
+ arg2 = value_add (arg1, value_from_longest (builtin_type_char,
+ (LONGEST) 1));
value_assign (arg1, arg2);
return arg1;
}
}
else
{
- arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
- (LONGEST) 1));
+ arg2 = value_sub (arg1, value_from_longest (builtin_type_char,
+ (LONGEST) 1));
value_assign (arg1, arg2);
return arg1;
}
-
+
case OP_THIS:
(*pos) += 1;
return value_of_this (1);
default:
/* Removing this case and compiling with gcc -Wall reveals that
- a lot of cases are hitting this case. Some of these should
- probably be removed from expression.h (e.g. do we need a BINOP_SCOPE
- and an OP_SCOPE?); others are legitimate expressions which are
- (apparently) not fully implemented.
+ a lot of cases are hitting this case. Some of these should
+ probably be removed from expression.h; others are legitimate
+ expressions which are (apparently) not fully implemented.
- If there are any cases landing here which mean a user error,
- then they should be separate cases, with more descriptive
- error messages. */
+ If there are any cases landing here which mean a user error,
+ then they should be separate cases, with more descriptive
+ error messages. */
error ("\
GDB does not (yet) know how to evaluate that kind of expression");
}
- nosideret:
+nosideret:
return value_from_longest (builtin_type_long, (LONGEST) 1);
}
\f
then only the type of the result need be correct. */
static value_ptr
-evaluate_subexp_for_address (exp, pos, noside)
- register struct expression *exp;
- register int *pos;
- enum noside noside;
+evaluate_subexp_for_address (register struct expression *exp, register int *pos,
+ enum noside noside)
{
enum exp_opcode op;
register int pc;
/* C++: The "address" of a reference should yield the address
* of the object pointed to. Let value_addr() deal with it. */
if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
- goto default_case;
+ goto default_case;
(*pos) += 4;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *type =
- lookup_pointer_type (SYMBOL_TYPE (var));
+ lookup_pointer_type (SYMBOL_TYPE (var));
enum address_class sym_class = SYMBOL_CLASS (var);
if (sym_class == LOC_CONST
|| sym_class == LOC_REGPARM)
error ("Attempt to take address of register or constant.");
- return
- value_zero (type, not_lval);
+ return
+ value_zero (type, not_lval);
}
else
return
locate_var_value
- (var,
- block_innermost_frame (exp->elts[pc + 1].block));
+ (var,
+ block_innermost_frame (exp->elts[pc + 1].block));
default:
default_case:
with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
to decide if coercion is appropriate.
- */
+ */
value_ptr
-evaluate_subexp_with_coercion (exp, pos, noside)
- register struct expression *exp;
- register int *pos;
- enum noside noside;
+evaluate_subexp_with_coercion (register struct expression *exp,
+ register int *pos, enum noside noside)
{
register enum exp_opcode op;
register int pc;
(*pos) += 4;
val =
locate_var_value
- (var, block_innermost_frame (exp->elts[pc + 1].block));
- return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (var))),
+ (var, block_innermost_frame (exp->elts[pc + 1].block));
+ return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
val);
}
/* FALLTHROUGH */
Advance *POS over the subexpression. */
static value_ptr
-evaluate_subexp_for_sizeof (exp, pos)
- register struct expression *exp;
- register int *pos;
+evaluate_subexp_for_sizeof (register struct expression *exp, register int *pos)
{
enum exp_opcode op;
register int pc;
switch (op)
{
/* This case is handled specially
- so that we avoid creating a value for the result type.
- If the result type is very big, it's desirable not to
- create a value unnecessarily. */
+ so that we avoid creating a value for the result type.
+ If the result type is very big, it's desirable not to
+ create a value unnecessarily. */
case UNOP_IND:
(*pos)++;
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
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));
+ TYPE_LENGTH (type));
case UNOP_MEMVAL:
(*pos) += 3;
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)));
}
}
/* Parse a type expression in the string [P..P+LENGTH). */
struct type *
-parse_and_eval_type (p, length)
- char *p;
- int length;
+parse_and_eval_type (char *p, int length)
{
- char *tmp = (char *)alloca (length + 4);
- struct expression *expr;
- tmp[0] = '(';
- memcpy (tmp+1, p, length);
- tmp[length+1] = ')';
- tmp[length+2] = '0';
- tmp[length+3] = '\0';
- expr = parse_expression (tmp);
- if (expr->elts[0].opcode != UNOP_CAST)
- error ("Internal error in eval_type.");
- return expr->elts[1].type;
+ char *tmp = (char *) alloca (length + 4);
+ struct expression *expr;
+ tmp[0] = '(';
+ memcpy (tmp + 1, p, length);
+ tmp[length + 1] = ')';
+ tmp[length + 2] = '0';
+ tmp[length + 3] = '\0';
+ expr = parse_expression (tmp);
+ if (expr->elts[0].opcode != UNOP_CAST)
+ error ("Internal error in eval_type.");
+ return expr->elts[1].type;
}
int
-calc_f77_array_dims (array_type)
- struct type *array_type;
+calc_f77_array_dims (struct type *array_type)
{
int ndimen = 1;
struct type *tmp_type;
- if ((TYPE_CODE(array_type) != TYPE_CODE_ARRAY))
+ if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
error ("Can't get dimensions for a non-array type");
-
- tmp_type = array_type;
+
+ tmp_type = array_type;
while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
{
if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
++ndimen;
}
- return ndimen;
+ return ndimen;
}