#include "infcall.h"
#include "objc-lang.h"
#include "block.h"
-
-/* Defined in symtab.c */
-extern int hp_som_som_object_present;
+#include "parser-defs.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)
{
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 *substruct_type = struct_type;
fieldno++)
{
char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
- if (field_name != NULL && STREQ (field_name, label))
+ if (field_name != NULL && DEPRECATED_STREQ (field_name, label))
{
variantno = -1;
subfieldno = fieldno;
subfieldno < TYPE_NFIELDS (substruct_type);
subfieldno++)
{
- if (STREQ (TYPE_FIELD_NAME (substruct_type,
+ if (DEPRECATED_STREQ (TYPE_FIELD_NAME (substruct_type,
subfieldno),
label))
{
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;
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);
return arg1;
case OP_OBJC_MSGCALL:
{ /* Objective C message (method) call. */
- static unsigned long responds_selector = 0;
- static unsigned long method_selector = 0;
+ static CORE_ADDR responds_selector = 0;
+ static CORE_ADDR method_selector = 0;
- unsigned long selector = 0;
+ CORE_ADDR selector = 0;
int using_gcc = 0;
int struct_return = 0;
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
{
value_type = expect_type;
}
- struct_return = using_struct_return (method, funaddr, value_type, using_gcc);
+ struct_return = using_struct_return (value_type, using_gcc);
}
else if (expect_type != NULL)
{
- struct_return = using_struct_return (NULL, addr, check_typedef (expect_type), using_gcc);
+ struct_return = using_struct_return (check_typedef (expect_type), using_gcc);
}
/* Found a function symbol. Now we will substitute its
if (gnu_runtime && (method != NULL))
{
- ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
/* Function objc_msg_lookup returns a pointer. */
- argvec[0] = ret;
- ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+ 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);
}
- else
- ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+ ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
return ret;
}
break;
/* 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");
}
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 &&
+ 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 */
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 &&
+ 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 */
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");
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
{
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 &&
+ 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))
{
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;
pc = (*pos);
*/
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;
projects / deliverable / binutils-gdb.git / blobdiff