*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / valops.c
index e73487746dbd145aacbfcbcf99d774bf717be0b9..3db7341df6e3e6fc22cdedc52fd71402daaa504e 100644 (file)
@@ -1,5 +1,6 @@
 /* Perform non-arithmetic operations on values, for GDB.
-   Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -30,6 +31,8 @@
 #include "demangle.h"
 #include "language.h"
 #include "gdbcmd.h"
+#include "regcache.h"
+#include "cp-abi.h"
 
 #include <errno.h>
 #include "gdb_string.h"
@@ -41,32 +44,34 @@ extern int hp_som_som_object_present;
 extern int overload_debug;
 /* Local functions.  */
 
-static int typecmp PARAMS ((int staticp, struct type * t1[], value_ptr t2[]));
+static int typecmp (int staticp, struct type *t1[], struct value *t2[]);
 
-static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
-static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
+static CORE_ADDR find_function_addr (struct value *, struct type **);
+static struct value *value_arg_coerce (struct value *, struct type *, int);
 
 
-static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
+static CORE_ADDR value_push (CORE_ADDR, struct value *);
 
-static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
-                                             struct type *, int));
+static struct value *search_struct_field (char *, struct value *, int,
+                                     struct type *, int);
 
-static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
-                                              value_ptr *,
-                                              int, int *, struct type *));
+static struct value *search_struct_method (char *, struct value **,
+                                      struct value **,
+                                      int, int *, struct type *);
 
-static int check_field_in PARAMS ((struct type *, const char *));
+static int check_field_in (struct type *, const char *);
 
-static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
+static CORE_ADDR allocate_space_in_inferior (int);
 
-static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
+static struct value *cast_into_complex (struct type *, struct value *);
 
-static struct fn_field *find_method_list PARAMS ((value_ptr * argp, char *method, int offset, int *static_memfuncp, struct type * type, int *num_fns, struct type ** basetype, int *boffset));
+static struct fn_field *find_method_list (struct value ** argp, char *method,
+                                         int offset, int *static_memfuncp,
+                                         struct type *type, int *num_fns,
+                                         struct type **basetype,
+                                         int *boffset);
 
-void _initialize_valops PARAMS ((void));
-
-#define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
+void _initialize_valops (void);
 
 /* Flag for whether we want to abandon failed expression evals by default.  */
 
@@ -87,9 +92,8 @@ int unwind_on_signal_p = 0;
 
 /* Find the address of function name NAME in the inferior.  */
 
-value_ptr
-find_function_in_inferior (name)
-     char *name;
+struct value *
+find_function_in_inferior (char *name)
 {
   register struct symbol *sym;
   sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
@@ -128,12 +132,11 @@ find_function_in_inferior (name)
 /* Allocate NBYTES of space in the inferior using the inferior's malloc
    and return a value that is a pointer to the allocated space. */
 
-value_ptr
-value_allocate_space_in_inferior (len)
-     int len;
+struct value *
+value_allocate_space_in_inferior (int len)
 {
-  value_ptr blocklen;
-  register value_ptr val = find_function_in_inferior ("malloc");
+  struct value *blocklen;
+  struct value *val = find_function_in_inferior ("malloc");
 
   blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
   val = call_function_by_hand (val, 1, &blocklen);
@@ -148,8 +151,7 @@ value_allocate_space_in_inferior (len)
 }
 
 static CORE_ADDR
-allocate_space_in_inferior (len)
-     int len;
+allocate_space_in_inferior (int len)
 {
   return value_as_long (value_allocate_space_in_inferior (len));
 }
@@ -159,10 +161,8 @@ allocate_space_in_inferior (len)
    and if ARG2 is an lvalue it can be cast into anything at all.  */
 /* In C++, casts may change pointer or object representations.  */
 
-value_ptr
-value_cast (type, arg2)
-     struct type *type;
-     register value_ptr arg2;
+struct value *
+value_cast (struct type *type, struct value *arg2)
 {
   register enum type_code code1;
   register enum type_code code2;
@@ -242,7 +242,7 @@ value_cast (type, arg2)
       /* Look in the type of the source to see if it contains the
          type of the target as a superclass.  If so, we'll need to
          offset the object in addition to changing its type.  */
-      value_ptr v = search_struct_field (type_name_no_tag (type),
+      struct value *v = search_struct_field (type_name_no_tag (type),
                                         arg2, 0, type2, 1);
       if (v)
        {
@@ -262,14 +262,15 @@ value_cast (type, arg2)
          (code2 == TYPE_CODE_PTR))
        {
          unsigned int *ptr;
-         value_ptr retvalp;
+         struct value *retvalp;
 
          switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
            {
              /* With HP aCC, pointers to data members have a bias */
            case TYPE_CODE_MEMBER:
              retvalp = value_from_longest (type, value_as_long (arg2));
-             ptr = (unsigned int *) VALUE_CONTENTS (retvalp);  /* force evaluation */
+             /* force evaluation */
+             ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
              *ptr &= ~0x20000000;      /* zap 29th bit to remove bias */
              return retvalp;
 
@@ -281,8 +282,45 @@ value_cast (type, arg2)
              break;            /* fall out and go to normal handling */
            }
        }
-      longest = value_as_long (arg2);
-      return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest);
+
+      /* When we cast pointers to integers, we mustn't use
+         POINTER_TO_ADDRESS to find the address the pointer
+         represents, as value_as_long would.  GDB should evaluate
+         expressions just as the compiler would --- and the compiler
+         sees a cast as a simple reinterpretation of the pointer's
+         bits.  */
+      if (code2 == TYPE_CODE_PTR)
+        longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
+                                            TYPE_LENGTH (type2));
+      else
+        longest = value_as_long (arg2);
+      return value_from_longest (type, convert_to_boolean ?
+                                (LONGEST) (longest ? 1 : 0) : longest);
+    }
+  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT  ||
+                                     code2 == TYPE_CODE_ENUM ||
+                                     code2 == TYPE_CODE_RANGE))
+    {
+      /* TYPE_LENGTH (type) is the length of a pointer, but we really
+        want the length of an address! -- we are really dealing with
+        addresses (i.e., gdb representations) not pointers (i.e.,
+        target representations) here.
+
+        This allows things like "print *(int *)0x01000234" to work
+        without printing a misleading message -- which would
+        otherwise occur when dealing with a target having two byte
+        pointers and four byte addresses.  */
+
+      int addr_bit = TARGET_ADDR_BIT;
+
+      LONGEST longest = value_as_long (arg2);
+      if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
+       {
+         if (longest >= ((LONGEST) 1 << addr_bit)
+             || longest <= -((LONGEST) 1 << addr_bit))
+           warning ("value truncated");
+       }
+      return value_from_longest (type, longest);
     }
   else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
     {
@@ -294,7 +332,7 @@ value_cast (type, arg2)
              && TYPE_CODE (t2) == TYPE_CODE_STRUCT
              && !value_logical_not (arg2))
            {
-             value_ptr v;
+             struct value *v;
 
              /* Look in the type of the source to see if it contains the
                 type of the target as a superclass.  If so, we'll need to
@@ -321,7 +359,7 @@ value_cast (type, arg2)
                                       value_zero (t1, not_lval), 0, t1, 1);
                  if (v)
                    {
-                     value_ptr v2 = value_ind (arg2);
+                     struct value *v2 = value_ind (arg2);
                      VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
                        + VALUE_OFFSET (v);
 
@@ -339,14 +377,14 @@ value_cast (type, arg2)
          /* No superclass found, just fall through to change ptr type.  */
        }
       VALUE_TYPE (arg2) = type;
-      VALUE_ENCLOSING_TYPE (arg2) = type;      /* pai: chk_val */
+      arg2 = value_change_enclosing_type (arg2, type);
       VALUE_POINTED_TO_OFFSET (arg2) = 0;      /* pai: chk_val */
       return arg2;
     }
   else if (chill_varying_type (type))
     {
       struct type *range1, *range2, *eltype1, *eltype2;
-      value_ptr val;
+      struct value *val;
       int count1, count2;
       LONGEST low_bound, high_bound;
       char *valaddr, *valaddr_data;
@@ -404,12 +442,10 @@ value_cast (type, arg2)
 
 /* Create a value of type TYPE that is zero, and return it.  */
 
-value_ptr
-value_zero (type, lv)
-     struct type *type;
-     enum lval_type lv;
+struct value *
+value_zero (struct type *type, enum lval_type lv)
 {
-  register value_ptr val = allocate_value (type);
+  struct value *val = allocate_value (type);
 
   memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
   VALUE_LVAL (val) = lv;
@@ -429,43 +465,17 @@ value_zero (type, lv)
    Note: value_at does *NOT* handle embedded offsets; perform such
    adjustments before or after calling it. */
 
-value_ptr
-value_at (type, addr, sect)
-     struct type *type;
-     CORE_ADDR addr;
-     asection *sect;
+struct value *
+value_at (struct type *type, CORE_ADDR addr, asection *sect)
 {
-  register value_ptr val;
+  struct value *val;
 
   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
     error ("Attempt to dereference a generic pointer.");
 
   val = allocate_value (type);
 
-  if (GDB_TARGET_IS_D10V
-      && TYPE_CODE (type) == TYPE_CODE_PTR
-      && TYPE_TARGET_TYPE (type)
-      && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
-    {
-      /* pointer to function */
-      unsigned long num;
-      unsigned short snum;
-      snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_IADDR (snum);
-      store_address (VALUE_CONTENTS_RAW (val), 4, num);
-    }
-  else if (GDB_TARGET_IS_D10V
-          && TYPE_CODE (type) == TYPE_CODE_PTR)
-    {
-      /* pointer to data */
-      unsigned long num;
-      unsigned short snum;
-      snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_DADDR (snum);
-      store_address (VALUE_CONTENTS_RAW (val), 4, num);
-    }
-  else
-    read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
+  read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
 
   VALUE_LVAL (val) = lval_memory;
   VALUE_ADDRESS (val) = addr;
@@ -476,13 +486,10 @@ value_at (type, addr, sect)
 
 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 
-value_ptr
-value_at_lazy (type, addr, sect)
-     struct type *type;
-     CORE_ADDR addr;
-     asection *sect;
+struct value *
+value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
 {
-  register value_ptr val;
+  struct value *val;
 
   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
     error ("Attempt to dereference a generic pointer.");
@@ -510,38 +517,15 @@ value_at_lazy (type, addr, sect)
    value is ignored.  */
 
 int
-value_fetch_lazy (val)
-     register value_ptr val;
+value_fetch_lazy (struct value *val)
 {
   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
   int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
 
   struct type *type = VALUE_TYPE (val);
-  if (GDB_TARGET_IS_D10V
-      && TYPE_CODE (type) == TYPE_CODE_PTR
-      && TYPE_TARGET_TYPE (type)
-      && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
-    {
-      /* pointer to function */
-      unsigned long num;
-      unsigned short snum;
-      snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_IADDR (snum);
-      store_address (VALUE_CONTENTS_RAW (val), 4, num);
-    }
-  else if (GDB_TARGET_IS_D10V
-          && TYPE_CODE (type) == TYPE_CODE_PTR)
-    {
-      /* pointer to data */
-      unsigned long num;
-      unsigned short snum;
-      snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_DADDR (snum);
-      store_address (VALUE_CONTENTS_RAW (val), 4, num);
-    }
-  else if (length)
-    read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
-                        VALUE_BFD_SECTION (val));
+  if (length)
+    read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+
   VALUE_LAZY (val) = 0;
   return 0;
 }
@@ -550,13 +534,12 @@ value_fetch_lazy (val)
 /* Store the contents of FROMVAL into the location of TOVAL.
    Return a new value with the location of TOVAL and contents of FROMVAL.  */
 
-value_ptr
-value_assign (toval, fromval)
-     register value_ptr toval, fromval;
+struct value *
+value_assign (struct value *toval, struct value *fromval)
 {
   register struct type *type;
-  register value_ptr val;
-  char raw_buffer[MAX_REGISTER_RAW_SIZE];
+  struct value *val;
+  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
   int use_buffer = 0;
 
   if (!toval->modifiable)
@@ -593,7 +576,7 @@ value_assign (toval, fromval)
     case lval_internalvar:
       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
       val = value_copy (VALUE_INTERNALVAR (toval)->value);
-      VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
+      val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
       VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
       return val;
@@ -656,7 +639,8 @@ value_assign (toval, fromval)
       if (VALUE_BITSIZE (toval))
        {
          char buffer[sizeof (LONGEST)];
-         int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
+         int len =
+               REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval);
 
          if (len > (int) sizeof (LONGEST))
            error ("Can't handle bitfields in registers larger than %d bits.",
@@ -713,6 +697,7 @@ value_assign (toval, fromval)
        int amount_copied;
 
        /* Make the buffer large enough in all cases.  */
+       /* FIXME (alloca): Not safe for very large data types. */
        char *buffer = (char *) alloca (amount_to_copy
                                        + sizeof (LONGEST)
                                        + MAX_REGISTER_RAW_SIZE);
@@ -806,7 +791,7 @@ value_assign (toval, fromval)
   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
          TYPE_LENGTH (type));
   VALUE_TYPE (val) = type;
-  VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
+  val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
   VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 
@@ -815,12 +800,10 @@ value_assign (toval, fromval)
 
 /* Extend a value VAL to COUNT repetitions of its type.  */
 
-value_ptr
-value_repeat (arg1, count)
-     value_ptr arg1;
-     int count;
+struct value *
+value_repeat (struct value *arg1, int count)
 {
-  register value_ptr val;
+  struct value *val;
 
   if (VALUE_LVAL (arg1) != lval_memory)
     error ("Only values in memory can be extended with '@'.");
@@ -838,12 +821,10 @@ value_repeat (arg1, count)
   return val;
 }
 
-value_ptr
-value_of_variable (var, b)
-     struct symbol *var;
-     struct block *b;
+struct value *
+value_of_variable (struct symbol *var, struct block *b)
 {
-  value_ptr val;
+  struct value *val;
   struct frame_info *frame = NULL;
 
   if (!b)
@@ -892,9 +873,8 @@ value_of_variable (var, b)
    the coercion to pointer type.
  */
 
-value_ptr
-value_coerce_array (arg1)
-     value_ptr arg1;
+struct value *
+value_coerce_array (struct value *arg1)
 {
   register struct type *type = check_typedef (VALUE_TYPE (arg1));
 
@@ -908,11 +888,10 @@ value_coerce_array (arg1)
 /* Given a value which is a function, return a value which is a pointer
    to it.  */
 
-value_ptr
-value_coerce_function (arg1)
-     value_ptr arg1;
+struct value *
+value_coerce_function (struct value *arg1)
 {
-  value_ptr retval;
+  struct value *retval;
 
   if (VALUE_LVAL (arg1) != lval_memory)
     error ("Attempt to take address of value not located in memory.");
@@ -925,11 +904,10 @@ value_coerce_function (arg1)
 
 /* Return a pointer value for the object for which ARG1 is the contents.  */
 
-value_ptr
-value_addr (arg1)
-     value_ptr arg1;
+struct value *
+value_addr (struct value *arg1)
 {
-  value_ptr arg2;
+  struct value *arg2;
 
   struct type *type = check_typedef (VALUE_TYPE (arg1));
   if (TYPE_CODE (type) == TYPE_CODE_REF)
@@ -955,7 +933,7 @@ value_addr (arg1)
 
   /* This may be a pointer to a base subobject; so remember the
      full derived object's type ... */
-  VALUE_ENCLOSING_TYPE (arg2) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1));
+  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
   /* ... and also the relative position of the subobject in the full object */
   VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
   VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
@@ -964,12 +942,11 @@ value_addr (arg1)
 
 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 
-value_ptr
-value_ind (arg1)
-     value_ptr arg1;
+struct value *
+value_ind (struct value *arg1)
 {
   struct type *base_type;
-  value_ptr arg2;
+  struct value *arg2;
 
   COERCE_ARRAY (arg1);
 
@@ -995,12 +972,12 @@ value_ind (arg1)
       enc_type = TYPE_TARGET_TYPE (enc_type);
       /* Retrieve the enclosing object pointed to */
       arg2 = value_at_lazy (enc_type,
-                  value_as_pointer (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
+                  value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
                            VALUE_BFD_SECTION (arg1));
       /* Re-adjust type */
       VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
       /* Add embedding info */
-      VALUE_ENCLOSING_TYPE (arg2) = enc_type;
+      arg2 = value_change_enclosing_type (arg2, enc_type);
       VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
 
       /* We may be pointing to an object of some derived type */
@@ -1017,12 +994,10 @@ value_ind (arg1)
 /* Push one word (the size of object that a register holds).  */
 
 CORE_ADDR
-push_word (sp, word)
-     CORE_ADDR sp;
-     ULONGEST word;
+push_word (CORE_ADDR sp, ULONGEST word)
 {
   register int len = REGISTER_SIZE;
-  char buffer[MAX_REGISTER_RAW_SIZE];
+  char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
 
   store_unsigned_integer (buffer, len, word);
   if (INNER_THAN (1, 2))
@@ -1044,10 +1019,7 @@ push_word (sp, word)
 /* Push LEN bytes with data at BUFFER.  */
 
 CORE_ADDR
-push_bytes (sp, buffer, len)
-     CORE_ADDR sp;
-     char *buffer;
-     int len;
+push_bytes (CORE_ADDR sp, char *buffer, int len)
 {
   if (INNER_THAN (1, 2))
     {
@@ -1073,9 +1045,7 @@ push_bytes (sp, buffer, len)
    it to be an argument to a function.  */
 
 static CORE_ADDR
-value_push (sp, arg)
-     register CORE_ADDR sp;
-     value_ptr arg;
+value_push (register CORE_ADDR sp, struct value *arg)
 {
   register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
   register int container_len = len;
@@ -1087,7 +1057,7 @@ value_push (sp, arg)
                     & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
 
   /* Are we going to put it at the high or low end of the container?  */
-  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
     offset = container_len - len;
   else
     offset = 0;
@@ -1108,17 +1078,9 @@ value_push (sp, arg)
   return sp;
 }
 
-#ifndef PUSH_ARGUMENTS
-#define PUSH_ARGUMENTS default_push_arguments
-#endif
-
 CORE_ADDR
-default_push_arguments (nargs, args, sp, struct_return, struct_addr)
-     int nargs;
-     value_ptr *args;
-     CORE_ADDR sp;
-     int struct_return;
-     CORE_ADDR struct_addr;
+default_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
+                       int struct_return, CORE_ADDR struct_addr)
 {
   /* ASSERT ( !struct_return); */
   int i;
@@ -1128,28 +1090,34 @@ default_push_arguments (nargs, args, sp, struct_return, struct_addr)
 }
 
 
-/* If we're calling a function declared without a prototype, should we
-   promote floats to doubles?  FORMAL and ACTUAL are the types of the
-   arguments; FORMAL may be NULL.
-
-   If we have no definition for this macro, either from the target or
-   from gdbarch, provide a default.  */
-#ifndef COERCE_FLOAT_TO_DOUBLE
-#define COERCE_FLOAT_TO_DOUBLE(formal, actual) \
-  (default_coerce_float_to_double ((formal), (actual)))
-#endif
-
-
-/* A default function for COERCE_FLOAT_TO_DOUBLE: do the coercion only
-   when we don't have any type for the argument at hand.  This occurs
-   when we have no debug info, or when passing varargs.
-
-   This is an annoying default: the rule the compiler follows is to do
-   the standard promotions whenever there is no prototype in scope,
-   and almost all targets want this behavior.  But there are some old
-   architectures which want this odd behavior.  If you want to go
-   through them all and fix them, please do.  Modern gdbarch-style
-   targets may find it convenient to use standard_coerce_float_to_double.  */
+/* Functions to use for the COERCE_FLOAT_TO_DOUBLE gdbarch method.
+
+   How you should pass arguments to a function depends on whether it
+   was defined in K&R style or prototype style.  If you define a
+   function using the K&R syntax that takes a `float' argument, then
+   callers must pass that argument as a `double'.  If you define the
+   function using the prototype syntax, then you must pass the
+   argument as a `float', with no promotion.
+
+   Unfortunately, on certain older platforms, the debug info doesn't
+   indicate reliably how each function was defined.  A function type's
+   TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
+   defined in prototype style.  When calling a function whose
+   TYPE_FLAG_PROTOTYPED flag is clear, GDB consults the
+   COERCE_FLOAT_TO_DOUBLE gdbarch method to decide what to do.
+
+   For modern targets, it is proper to assume that, if the prototype
+   flag is clear, that can be trusted: `float' arguments should be
+   promoted to `double'.  You should register the function
+   `standard_coerce_float_to_double' to get this behavior.
+
+   For some older targets, if the prototype flag is clear, that
+   doesn't tell us anything.  So we guess that, if we don't have a
+   type for the formal parameter (i.e., the first argument to
+   COERCE_FLOAT_TO_DOUBLE is null), then we should promote it;
+   otherwise, we should leave it alone.  The function
+   `default_coerce_float_to_double' provides this behavior; it is the
+   default value, for compatibility with older configurations.  */
 int
 default_coerce_float_to_double (struct type *formal, struct type *actual)
 {
@@ -1157,10 +1125,6 @@ default_coerce_float_to_double (struct type *formal, struct type *actual)
 }
 
 
-/* Always coerce floats to doubles when there is no prototype in scope.
-   If your architecture follows the standard type promotion rules for
-   calling unprototyped functions, your gdbarch init function can pass
-   this function to set_gdbarch_coerce_float_to_double to use its logic.  */
 int
 standard_coerce_float_to_double (struct type *formal, struct type *actual)
 {
@@ -1174,20 +1138,19 @@ standard_coerce_float_to_double (struct type *formal, struct type *actual)
    If PARAM_TYPE is non-NULL, it is the expected parameter type.
    IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
 
-static value_ptr
-value_arg_coerce (arg, param_type, is_prototyped)
-     value_ptr arg;
-     struct type *param_type;
-     int is_prototyped;
+static struct value *
+value_arg_coerce (struct value *arg, struct type *param_type,
+                 int is_prototyped)
 {
   register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
   register struct type *type
-  = param_type ? check_typedef (param_type) : arg_type;
+    = param_type ? check_typedef (param_type) : arg_type;
 
   switch (TYPE_CODE (type))
     {
     case TYPE_CODE_REF:
-      if (TYPE_CODE (arg_type) != TYPE_CODE_REF)
+      if (TYPE_CODE (arg_type) != TYPE_CODE_REF
+         && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
        {
          arg = value_addr (arg);
          VALUE_TYPE (arg) = param_type;
@@ -1254,9 +1217,7 @@ value_arg_coerce (arg, param_type, is_prototyped)
    Calls error() if the function is not valid for calling.  */
 
 static CORE_ADDR
-find_function_addr (function, retval_type)
-     value_ptr function;
-     struct type **retval_type;
+find_function_addr (struct value *function, struct type **retval_type)
 {
   register struct type *ftype = check_typedef (VALUE_TYPE (function));
   register enum type_code code = TYPE_CODE (ftype);
@@ -1274,17 +1235,12 @@ find_function_addr (function, retval_type)
     }
   else if (code == TYPE_CODE_PTR)
     {
-      funaddr = value_as_pointer (function);
+      funaddr = value_as_address (function);
       ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
       if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
          || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
        {
-#ifdef CONVERT_FROM_FUNC_PTR_ADDR
-         /* FIXME: This is a workaround for the unusual function
-            pointer representation on the RS/6000, see comment
-            in config/rs6000/tm-rs6000.h  */
          funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
-#endif
          value_type = TYPE_TARGET_TYPE (ftype);
        }
       else
@@ -1295,7 +1251,7 @@ find_function_addr (function, retval_type)
       /* Handle the case of functions lacking debugging info.
          Their values are characters since their addresses are char */
       if (TYPE_LENGTH (ftype) == 1)
-       funaddr = value_as_pointer (value_addr (function));
+       funaddr = value_as_address (value_addr (function));
       else
        /* Handle integer used as address of a function.  */
        funaddr = (CORE_ADDR) value_as_long (function);
@@ -1327,12 +1283,8 @@ find_function_addr (function, retval_type)
 
    ARGS is modified to contain coerced values. */
 
-static value_ptr hand_function_call PARAMS ((value_ptr function, int nargs, value_ptr * args));
-static value_ptr
-hand_function_call (function, nargs, args)
-     value_ptr function;
-     int nargs;
-     value_ptr *args;
+static struct value *
+hand_function_call (struct value *function, int nargs, struct value **args)
 {
   register CORE_ADDR sp;
   register int i;
@@ -1366,6 +1318,7 @@ hand_function_call (function, nargs, args)
   CORE_ADDR real_pc;
   struct type *param_type = NULL;
   struct type *ftype = check_typedef (SYMBOL_TYPE (function));
+  int n_method_args = 0;
 
   dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
   sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
@@ -1376,8 +1329,7 @@ hand_function_call (function, nargs, args)
     noprocess ();
 
   inf_status = save_inferior_status (1);
-  old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status,
-                           inf_status);
+  old_chain = make_cleanup_restore_inferior_status (inf_status);
 
   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
      (and POP_FRAME for restoring them).  (At least on most machines)
@@ -1471,11 +1423,31 @@ hand_function_call (function, nargs, args)
   sp = old_sp;                 /* It really is used, for some ifdef's... */
 #endif
 
-  if (nargs < TYPE_NFIELDS (ftype))
+  if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+    {
+      i = 0;
+      while (TYPE_CODE (TYPE_ARG_TYPES (ftype)[i]) != TYPE_CODE_VOID)
+       i++;
+      n_method_args = i;
+      if (nargs < i)
+       error ("too few arguments in method call");
+    }
+  else if (nargs < TYPE_NFIELDS (ftype))
     error ("too few arguments in function call");
 
   for (i = nargs - 1; i >= 0; i--)
     {
+      /* Assume that methods are always prototyped, unless they are off the
+        end (which we should only be allowing if there is a ``...'').  
+         FIXME.  */
+      if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+       {
+         if (i < n_method_args)
+           args[i] = value_arg_coerce (args[i], TYPE_ARG_TYPES (ftype)[i], 1);
+         else
+           args[i] = value_arg_coerce (args[i], NULL, 0);
+       }
+
       /* If we're off the end of the known arguments, do the standard
          promotions.  FIXME: if we had a prototype, this should only
          be allowed if ... were present.  */
@@ -1484,10 +1456,8 @@ hand_function_call (function, nargs, args)
 
       else
        {
-         int is_prototyped = TYPE_FLAGS (ftype) & TYPE_FLAG_PROTOTYPED;
          param_type = TYPE_FIELD_TYPE (ftype, i);
-
-         args[i] = value_arg_coerce (args[i], param_type, is_prototyped);
+         args[i] = value_arg_coerce (args[i], param_type, TYPE_PROTOTYPED (ftype));
        }
 
       /*elz: this code is to handle the case in which the function to be called
@@ -1522,72 +1492,65 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
                  }
     }
 
-#if defined (REG_STRUCT_HAS_ADDR)
-  {
-    /* This is a machine like the sparc, where we may need to pass a pointer
-       to the structure, not the structure itself.  */
-    for (i = nargs - 1; i >= 0; i--)
-      {
-       struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
-       if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
-            || TYPE_CODE (arg_type) == TYPE_CODE_UNION
-            || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
-            || TYPE_CODE (arg_type) == TYPE_CODE_STRING
-            || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
-            || TYPE_CODE (arg_type) == TYPE_CODE_SET
-            || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
-                && TYPE_LENGTH (arg_type) > 8)
-           )
-           && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
-         {
-           CORE_ADDR addr;
-           int len;            /*  = TYPE_LENGTH (arg_type); */
-           int aligned_len;
-           arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
-           len = TYPE_LENGTH (arg_type);
-
-#ifdef STACK_ALIGN
-           /* MVS 11/22/96: I think at least some of this stack_align code is
-              really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
-              a target-defined manner.  */
-           aligned_len = STACK_ALIGN (len);
-#else
-           aligned_len = len;
-#endif
-           if (INNER_THAN (1, 2))
-             {
-               /* stack grows downward */
-               sp -= aligned_len;
-             }
-           else
-             {
-               /* The stack grows up, so the address of the thing we push
-                  is the stack pointer before we push it.  */
-               addr = sp;
-             }
-           /* Push the structure.  */
-           write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
-           if (INNER_THAN (1, 2))
-             {
-               /* The stack grows down, so the address of the thing we push
-                  is the stack pointer after we push it.  */
-               addr = sp;
-             }
-           else
-             {
-               /* stack grows upward */
-               sp += aligned_len;
-             }
-           /* The value we're going to pass is the address of the thing
-              we just pushed.  */
-           /*args[i] = value_from_longest (lookup_pointer_type (value_type),
-              (LONGEST) addr); */
-           args[i] = value_from_pointer (lookup_pointer_type (arg_type),
-                                         addr);
-         }
-      }
-  }
-#endif /* REG_STRUCT_HAS_ADDR.  */
+  if (REG_STRUCT_HAS_ADDR_P ())
+    {
+      /* This is a machine like the sparc, where we may need to pass a
+        pointer to the structure, not the structure itself.  */
+      for (i = nargs - 1; i >= 0; i--)
+       {
+         struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+         if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
+              || TYPE_CODE (arg_type) == TYPE_CODE_UNION
+              || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
+              || TYPE_CODE (arg_type) == TYPE_CODE_STRING
+              || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
+              || TYPE_CODE (arg_type) == TYPE_CODE_SET
+              || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
+                  && TYPE_LENGTH (arg_type) > 8)
+              )
+             && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+           {
+             CORE_ADDR addr;
+             int len;          /*  = TYPE_LENGTH (arg_type); */
+             int aligned_len;
+             arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+             len = TYPE_LENGTH (arg_type);
+
+             if (STACK_ALIGN_P ())
+               /* MVS 11/22/96: I think at least some of this
+                  stack_align code is really broken.  Better to let
+                  PUSH_ARGUMENTS adjust the stack in a target-defined
+                  manner.  */
+               aligned_len = STACK_ALIGN (len);
+             else
+               aligned_len = len;
+             if (INNER_THAN (1, 2))
+               {
+                 /* stack grows downward */
+                 sp -= aligned_len;
+                 /* ... so the address of the thing we push is the
+                    stack pointer after we push it.  */
+                 addr = sp;
+               }
+             else
+               {
+                 /* The stack grows up, so the address of the thing
+                    we push is the stack pointer before we push it.  */
+                 addr = sp;
+                 sp += aligned_len;
+               }
+             /* Push the structure.  */
+             write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
+             /* The value we're going to pass is the address of the
+                thing we just pushed.  */
+             /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+               (LONGEST) addr); */
+             args[i] = value_from_pointer (lookup_pointer_type (arg_type),
+                                           addr);
+           }
+       }
+    }
+
 
   /* Reserve space for the return structure to be written on the
      stack, if necessary */
@@ -1595,12 +1558,11 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
   if (struct_return)
     {
       int len = TYPE_LENGTH (value_type);
-#ifdef STACK_ALIGN
-      /* MVS 11/22/96: I think at least some of this stack_align code is
-         really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
-         a target-defined manner.  */
-      len = STACK_ALIGN (len);
-#endif
+      if (STACK_ALIGN_P ())
+       /* MVS 11/22/96: I think at least some of this stack_align
+          code is really broken.  Better to let PUSH_ARGUMENTS adjust
+          the stack in a target-defined manner.  */
+       len = STACK_ALIGN (len);
       if (INNER_THAN (1, 2))
        {
          /* stack grows downward */
@@ -1615,47 +1577,44 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
        }
     }
 
-/* elz: on HPPA no need for this extra alignment, maybe it is needed
-   on other architectures. This is because all the alignment is taken care
-   of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
-   hppa_push_arguments */
-#ifndef NO_EXTRA_ALIGNMENT_NEEDED
-
-#if defined(STACK_ALIGN)
-  /* MVS 11/22/96: I think at least some of this stack_align code is
-     really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
-     a target-defined manner.  */
-  if (INNER_THAN (1, 2))
+  /* elz: on HPPA no need for this extra alignment, maybe it is needed
+     on other architectures. This is because all the alignment is
+     taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
+     in hppa_push_arguments */
+  if (EXTRA_STACK_ALIGNMENT_NEEDED)
     {
-      /* If stack grows down, we must leave a hole at the top. */
-      int len = 0;
-
-      for (i = nargs - 1; i >= 0; i--)
-       len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
-      if (CALL_DUMMY_STACK_ADJUST_P)
-       len += CALL_DUMMY_STACK_ADJUST;
-      sp -= STACK_ALIGN (len) - len;
+      /* MVS 11/22/96: I think at least some of this stack_align code
+        is really broken.  Better to let PUSH_ARGUMENTS adjust the
+        stack in a target-defined manner.  */
+      if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+       {
+         /* If stack grows down, we must leave a hole at the top. */
+         int len = 0;
+
+         for (i = nargs - 1; i >= 0; i--)
+           len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+         if (CALL_DUMMY_STACK_ADJUST_P)
+           len += CALL_DUMMY_STACK_ADJUST;
+         sp -= STACK_ALIGN (len) - len;
+       }
     }
-#endif /* STACK_ALIGN */
-#endif /* NO_EXTRA_ALIGNMENT_NEEDED */
 
   sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
 
-#ifdef PUSH_RETURN_ADDRESS     /* for targets that use no CALL_DUMMY */
-  /* There are a number of targets now which actually don't write any
-     CALL_DUMMY instructions into the target, but instead just save the
-     machine state, push the arguments, and jump directly to the callee
-     function.  Since this doesn't actually involve executing a JSR/BSR
-     instruction, the return address must be set up by hand, either by
-     pushing onto the stack or copying into a return-address register
-     as appropriate.  Formerly this has been done in PUSH_ARGUMENTS,
-     but that's overloading its functionality a bit, so I'm making it
-     explicit to do it here.  */
-  sp = PUSH_RETURN_ADDRESS (real_pc, sp);
-#endif /* PUSH_RETURN_ADDRESS */
-
-#if defined(STACK_ALIGN)
-  if (!INNER_THAN (1, 2))
+  if (PUSH_RETURN_ADDRESS_P ())
+    /* for targets that use no CALL_DUMMY */
+    /* There are a number of targets now which actually don't write
+       any CALL_DUMMY instructions into the target, but instead just
+       save the machine state, push the arguments, and jump directly
+       to the callee function.  Since this doesn't actually involve
+       executing a JSR/BSR instruction, the return address must be set
+       up by hand, either by pushing onto the stack or copying into a
+       return-address register as appropriate.  Formerly this has been
+       done in PUSH_ARGUMENTS, but that's overloading its
+       functionality a bit, so I'm making it explicit to do it here.  */
+    sp = PUSH_RETURN_ADDRESS (real_pc, sp);
+
+  if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
     {
       /* If stack grows up, we must leave a hole at the bottom, note
          that sp already has been advanced for the arguments!  */
@@ -1663,7 +1622,6 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
        sp += CALL_DUMMY_STACK_ADJUST;
       sp = STACK_ALIGN (sp);
     }
-#endif /* STACK_ALIGN */
 
 /* XXX This seems wrong.  For stacks that grow down we shouldn't do
    anything here!  */
@@ -1695,12 +1653,11 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
      wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
   write_sp (sp);
 
-#ifdef SAVE_DUMMY_FRAME_TOS
-  SAVE_DUMMY_FRAME_TOS (sp);
-#endif
+  if (SAVE_DUMMY_FRAME_TOS_P ())
+    SAVE_DUMMY_FRAME_TOS (sp);
 
   {
-    char retbuf[REGISTER_BYTES];
+    char *retbuf = (char*) alloca (REGISTER_BYTES);
     char *name;
     struct symbol *symbol;
 
@@ -1818,18 +1775,15 @@ the function call).", name);
 
 #ifdef VALUE_RETURNED_FROM_STACK
     if (struct_return)
-      return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
+      return (struct value *) VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
 #endif
 
     return value_being_returned (value_type, retbuf, struct_return);
   }
 }
 
-value_ptr
-call_function_by_hand (function, nargs, args)
-     value_ptr function;
-     int nargs;
-     value_ptr *args;
+struct value *
+call_function_by_hand (struct value *function, int nargs, struct value **args)
 {
   if (CALL_DUMMY_P)
     {
@@ -1853,16 +1807,13 @@ call_function_by_hand (function, nargs, args)
    first element, and all elements must have the same size (though we
    don't currently enforce any restriction on their types). */
 
-value_ptr
-value_array (lowbound, highbound, elemvec)
-     int lowbound;
-     int highbound;
-     value_ptr *elemvec;
+struct value *
+value_array (int lowbound, int highbound, struct value **elemvec)
 {
   int nelem;
   int idx;
   unsigned int typelength;
-  value_ptr val;
+  struct value *val;
   struct type *rangetype;
   struct type *arraytype;
   CORE_ADDR addr;
@@ -1928,12 +1879,10 @@ value_array (lowbound, highbound, elemvec)
    zero and an upper bound of LEN - 1.  Also note that the string may contain
    embedded null bytes. */
 
-value_ptr
-value_string (ptr, len)
-     char *ptr;
-     int len;
+struct value *
+value_string (char *ptr, int len)
 {
-  value_ptr val;
+  struct value *val;
   int lowbound = current_language->string_lower_bound;
   struct type *rangetype = create_range_type ((struct type *) NULL,
                                              builtin_type_int,
@@ -1960,12 +1909,10 @@ value_string (ptr, len)
   return (val);
 }
 
-value_ptr
-value_bitstring (ptr, len)
-     char *ptr;
-     int len;
+struct value *
+value_bitstring (char *ptr, int len)
 {
-  value_ptr val;
+  struct value *val;
   struct type *domain_type = create_range_type (NULL, builtin_type_int,
                                                0, len - 1);
   struct type *type = create_set_type ((struct type *) NULL, domain_type);
@@ -1991,10 +1938,7 @@ value_bitstring (ptr, len)
    requested operation is type secure, shouldn't we?  FIXME.  */
 
 static int
-typecmp (staticp, t1, t2)
-     int staticp;
-     struct type *t1[];
-     value_ptr t2[];
+typecmp (int staticp, struct type *t1[], struct value *t2[])
 {
   int i;
 
@@ -2026,12 +1970,22 @@ typecmp (staticp, t1, t2)
          continue;
        }
 
-      while (TYPE_CODE (tt1) == TYPE_CODE_PTR
-            && (TYPE_CODE (tt2) == TYPE_CODE_ARRAY
-                || TYPE_CODE (tt2) == TYPE_CODE_PTR))
+      /* djb - 20000715 - Until the new type structure is in the
+        place, and we can attempt things like implicit conversions,
+        we need to do this so you can take something like a map<const
+        char *>, and properly access map["hello"], because the
+        argument to [] will be a reference to a pointer to a char,
+        and the argument will be a pointer to a char. */
+      while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
+             TYPE_CODE (tt1) == TYPE_CODE_PTR)
+       {
+         tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+       }
+      while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
+             TYPE_CODE(tt2) == TYPE_CODE_PTR ||
+             TYPE_CODE(tt2) == TYPE_CODE_REF)
        {
-         tt1 = check_typedef (TYPE_TARGET_TYPE (tt1));
-         tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
+         tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
        }
       if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
        continue;
@@ -2056,13 +2010,9 @@ typecmp (staticp, t1, t2)
    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
    look for a baseclass named NAME.  */
 
-static value_ptr
-search_struct_field (name, arg1, offset, type, looking_for_baseclass)
-     char *name;
-     register value_ptr arg1;
-     int offset;
-     register struct type *type;
-     int looking_for_baseclass;
+static struct value *
+search_struct_field (char *name, struct value *arg1, int offset,
+                    register struct type *type, int looking_for_baseclass)
 {
   int i;
   int nbases = TYPE_N_BASECLASSES (type);
@@ -2076,7 +2026,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
 
        if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
          {
-           value_ptr v;
+           struct value *v;
            if (TYPE_FIELD_STATIC (type, i))
              v = value_static_field (type, i);
            else
@@ -2104,7 +2054,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
                   Each <variant alternative> is represented as a struct,
                   with a member for each <variant field>.  */
 
-               value_ptr v;
+               struct value *v;
                int new_offset = offset;
 
                /* This is pretty gross.  In G++, the offset in an anonymous
@@ -2127,7 +2077,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
 
   for (i = 0; i < nbases; i++)
     {
-      value_ptr v;
+      struct value *v;
       struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
       /* If we are looking for baseclasses, this is what we get when we
          hit them.  But it could happen that the base part's member name
@@ -2139,7 +2089,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
       if (BASETYPE_VIA_VIRTUAL (type, i))
        {
          int boffset;
-         value_ptr v2 = allocate_value (basetype);
+         struct value *v2 = allocate_value (basetype);
 
          boffset = baseclass_offset (type, i,
                                      VALUE_CONTENTS (arg1) + offset,
@@ -2214,19 +2164,14 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass)
  * conventions.  */
 
 void
-find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p)
-     struct type *type;
-     struct type *basetype;
-     char *valaddr;
-     int offset;
-     int *boffset_p;
-     int *skip_p;
+find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
+                     int offset, int *boffset_p, int *skip_p)
 {
   int boffset;                 /* offset of virtual base */
   int index;                   /* displacement to use in virtual table */
   int skip;
 
-  value_ptr vp;
+  struct value *vp;
   CORE_ADDR vtbl;              /* the virtual table pointer */
   struct type *pbc;            /* the primary base class */
 
@@ -2294,15 +2239,13 @@ find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p)
    If found, return value, else if name matched and args not return (value)-1,
    else return NULL. */
 
-static value_ptr
-search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
-     char *name;
-     register value_ptr *arg1p, *args;
-     int offset, *static_memfuncp;
-     register struct type *type;
+static struct value *
+search_struct_method (char *name, struct value **arg1p,
+                     struct value **args, int offset,
+                     int *static_memfuncp, register struct type *type)
 {
   int i;
-  value_ptr v;
+  struct value *v;
   int name_matched = 0;
   char dem_opname[64];
 
@@ -2328,23 +2271,32 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
 
          if (j > 0 && args == 0)
            error ("cannot resolve overloaded method `%s': no arguments supplied", name);
-         while (j >= 0)
+         else if (j == 0 && args == 0)
            {
              if (TYPE_FN_FIELD_STUB (f, j))
                check_stub_method (type, i, j);
-             if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
-                           TYPE_FN_FIELD_ARGS (f, j), args))
-               {
-                 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
-                   return value_virtual_fn_field (arg1p, f, j, type, offset);
-                 if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
-                   *static_memfuncp = 1;
-                 v = value_fn_field (arg1p, f, j, type, offset);
-                 if (v != NULL)
-                   return v;
-               }
-             j--;
+             v = value_fn_field (arg1p, f, j, type, offset);
+             if (v != NULL)
+               return v;
            }
+         else
+           while (j >= 0)
+             {
+               if (TYPE_FN_FIELD_STUB (f, j))
+                 check_stub_method (type, i, j);
+               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
+                             TYPE_FN_FIELD_ARGS (f, j), args))
+                 {
+                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+                     return value_virtual_fn_field (arg1p, f, j, type, offset);
+                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
+                     *static_memfuncp = 1;
+                   v = value_fn_field (arg1p, f, j, type, offset);
+                   if (v != NULL)
+                     return v;       
+                 }
+               j--;
+             }
        }
     }
 
@@ -2401,7 +2353,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
        }
       v = search_struct_method (name, arg1p, args, base_offset + offset,
                                static_memfuncp, TYPE_BASECLASS (type, i));
-      if (v == (value_ptr) - 1)
+      if (v == (struct value *) - 1)
        {
          name_matched = 1;
        }
@@ -2413,7 +2365,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
        }
     }
   if (name_matched)
-    return (value_ptr) - 1;
+    return (struct value *) - 1;
   else
     return NULL;
 }
@@ -2432,15 +2384,12 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
 
    ERR is an error message to be printed in case the field is not found.  */
 
-value_ptr
-value_struct_elt (argp, args, name, static_memfuncp, err)
-     register value_ptr *argp, *args;
-     char *name;
-     int *static_memfuncp;
-     char *err;
+struct value *
+value_struct_elt (struct value **argp, struct value **args,
+                 char *name, int *static_memfuncp, char *err)
 {
   register struct type *t;
-  value_ptr v;
+  struct value *v;
 
   COERCE_ARRAY (*argp);
 
@@ -2486,7 +2435,7 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
 
       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
 
-      if (v == (value_ptr) - 1)
+      if (v == (struct value *) - 1)
        error ("Cannot take address of a method");
       else if (v == 0)
        {
@@ -2523,10 +2472,10 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
     }
   else
     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
-
-  if (v == (value_ptr) - 1)
+  
+  if (v == (struct value *) - 1)
     {
-      error ("Argument list of %s mismatch with component in the structure.", name);
+      error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
     }
   else if (v == 0)
     {
@@ -2555,15 +2504,9 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
  * BOFFSET is the offset of the base subobject where the method is found */
 
 static struct fn_field *
-find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
-     value_ptr *argp;
-     char *method;
-     int offset;
-     int *static_memfuncp;
-     struct type *type;
-     int *num_fns;
-     struct type **basetype;
-     int *boffset;
+find_method_list (struct value **argp, char *method, int offset,
+                 int *static_memfuncp, struct type *type, int *num_fns,
+                 struct type **basetype, int *boffset)
 {
   int i;
   struct fn_field *f;
@@ -2638,14 +2581,9 @@ find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype
  * BOFFSET is the offset of the base subobject which defines the method */
 
 struct fn_field *
-value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
-     value_ptr *argp;
-     char *method;
-     int offset;
-     int *static_memfuncp;
-     int *num_fns;
-     struct type **basetype;
-     int *boffset;
+value_find_oload_method_list (struct value **argp, char *method, int offset,
+                             int *static_memfuncp, int *num_fns,
+                             struct type **basetype, int *boffset)
 {
   struct type *t;
 
@@ -2705,21 +2643,14 @@ value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, ba
  */
 
 int
-find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
-     struct type **arg_types;
-     int nargs;
-     char *name;
-     int method;
-     int lax;
-     value_ptr obj;
-     struct symbol *fsym;
-     value_ptr *valp;
-     struct symbol **symp;
-     int *staticp;
+find_overload_match (struct type **arg_types, int nargs, char *name, int method,
+                    int lax, struct value **objp, struct symbol *fsym,
+                    struct value **valp, struct symbol **symp, int *staticp)
 {
   int nparms;
   struct type **parm_types;
   int champ_nparms = 0;
+  struct value *obj = (objp ? *objp : NULL);
 
   short oload_champ = -1;      /* Index of best overloaded function */
   short oload_ambiguous = 0;   /* Current ambiguity state for overload resolution */
@@ -2731,7 +2662,7 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp,
   struct badness_vector *bv;   /* A measure of how good an overloaded instance is */
   struct badness_vector *oload_champ_bv = NULL;                /* The measure for the current best match */
 
-  value_ptr temp = obj;
+  struct value *temp = obj;
   struct fn_field *fns_ptr = NULL;     /* For methods, the list of overloaded methods */
   struct symbol **oload_syms = NULL;   /* For non-methods, the list of overloaded function symbols */
   int num_fns = 0;             /* Number of overloaded instances being considered */
@@ -2868,17 +2799,17 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp,
          default:
            break;
          }
-      free (parm_types);
-if (overload_debug)
-{
-      if (method)
-       fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
-      else
-       fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
-      for (jj = 0; jj < nargs; jj++)
-       fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
-      fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
-}
+      xfree (parm_types);
+      if (overload_debug)
+       {
+         if (method)
+           fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
+         else
+           fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
+         for (jj = 0; jj < nargs; jj++)
+           fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
+         fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
+       }
     }                          /* end loop over all candidates */
   /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
      if they have the exact same goodness. This is because there is no
@@ -2901,15 +2832,11 @@ if (overload_debug)
   /* Check how bad the best match is */
   for (ix = 1; ix <= nargs; ix++)
     {
-      switch (oload_champ_bv->rank[ix])
-       {
-       case 10:
-         oload_non_standard = 1;       /* non-standard type conversions needed */
-         break;
-       case 100:
-         oload_incompatible = 1;       /* truly mismatched types */
-         break;
-       }
+      if (oload_champ_bv->rank[ix] >= 100)
+       oload_incompatible = 1; /* truly mismatched types */
+
+      else if (oload_champ_bv->rank[ix] >= 10)
+       oload_non_standard = 1; /* non-standard type conversions needed */
     }
   if (oload_incompatible)
     {
@@ -2944,9 +2871,18 @@ if (overload_debug)
   else
     {
       *symp = oload_syms[oload_champ];
-      free (func_name);
+      xfree (func_name);
     }
 
+  if (objp)
+    {
+      if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
+         && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
+       {
+         temp = value_addr (temp);
+       }
+      *objp = temp;
+    }
   return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
 }
 
@@ -2954,9 +2890,7 @@ if (overload_debug)
    of type TYPE.  If TYPE does not have a destructor, or
    if NAME is inappropriate for TYPE, an error is signaled.  */
 int
-destructor_name_p (name, type)
-     const char *name;
-     const struct type *type;
+destructor_name_p (const char *name, const struct type *type)
 {
   /* destructors are a special case.  */
 
@@ -2984,9 +2918,7 @@ destructor_name_p (name, type)
    target structure/union is defined, otherwise, return 0. */
 
 static int
-check_field_in (type, name)
-     register struct type *type;
-     const char *name;
+check_field_in (register struct type *type, const char *name)
 {
   register int i;
 
@@ -3027,9 +2959,7 @@ check_field_in (type, name)
    target structure/union is defined, otherwise, return 0.  */
 
 int
-check_field (arg1, name)
-     register value_ptr arg1;
-     const char *name;
+check_field (struct value *arg1, const char *name)
 {
   register struct type *t;
 
@@ -3064,15 +2994,14 @@ check_field (arg1, name)
    "pointers to member functions".  This function is used
    to resolve user expressions of the form "DOMAIN::NAME".  */
 
-value_ptr
-value_struct_elt_for_reference (domain, offset, curtype, name, intype)
-     struct type *domain, *curtype, *intype;
-     int offset;
-     char *name;
+struct value *
+value_struct_elt_for_reference (struct type *domain, int offset,
+                               struct type *curtype, char *name,
+                               struct type *intype)
 {
   register struct type *t = curtype;
   register int i;
-  value_ptr v;
+  struct value *v;
 
   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
       && TYPE_CODE (t) != TYPE_CODE_UNION)
@@ -3180,7 +3109,7 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype)
     }
   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
     {
-      value_ptr v;
+      struct value *v;
       int base_offset;
 
       if (BASETYPE_VIA_VIRTUAL (t, i))
@@ -3199,243 +3128,15 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype)
 }
 
 
-/* Find the real run-time type of a value using RTTI.
- * V is a pointer to the value.
- * A pointer to the struct type entry of the run-time type
- * is returneed.
- * FULL is a flag that is set only if the value V includes
- * the entire contents of an object of the RTTI type.
- * TOP is the offset to the top of the enclosing object of
- * the real run-time type.  This offset may be for the embedded
- * object, or for the enclosing object of V.
- * USING_ENC is the flag that distinguishes the two cases.
- * If it is 1, then the offset is for the enclosing object,
- * otherwise for the embedded object.
- *
- */
-
-struct type *
-value_rtti_type (v, full, top, using_enc)
-     value_ptr v;
-     int *full;
-     int *top;
-     int *using_enc;
-{
-  struct type *known_type;
-  struct type *rtti_type;
-  CORE_ADDR coreptr;
-  value_ptr vp;
-  int using_enclosing = 0;
-  long top_offset = 0;
-  char rtti_type_name[256];
-
-  if (full)
-    *full = 0;
-  if (top)
-    *top = -1;
-  if (using_enc)
-    *using_enc = 0;
-
-  /* Get declared type */
-  known_type = VALUE_TYPE (v);
-  CHECK_TYPEDEF (known_type);
-  /* RTTI works only or class objects */
-  if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
-    return NULL;
-  if (TYPE_HAS_VTABLE(known_type))
-    {
-      /* If neither the declared type nor the enclosing type of the
-       * value structure has a HP ANSI C++ style virtual table,
-       * we can't do anything. */
-      if (!TYPE_HAS_VTABLE (known_type))
-       {
-         known_type = VALUE_ENCLOSING_TYPE (v);
-         CHECK_TYPEDEF (known_type);
-         if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
-             !TYPE_HAS_VTABLE (known_type))
-           return NULL;                /* No RTTI, or not HP-compiled types */
-         CHECK_TYPEDEF (known_type);
-         using_enclosing = 1;
-       }
-
-      if (using_enclosing && using_enc)
-       *using_enc = 1;
-
-      /* First get the virtual table address */
-      coreptr = *(CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
-                               + VALUE_OFFSET (v)
-                               + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
-      if (coreptr == 0)
-       return NULL;            /* return silently -- maybe called on gdb-generated value */
-
-      /* Fetch the top offset of the object */
-      /* FIXME possible 32x64 problem with pointer size & arithmetic */
-      vp = value_at (builtin_type_int,
-                    coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
-                    VALUE_BFD_SECTION (v));
-      top_offset = value_as_long (vp);
-      if (top)
-       *top = top_offset;
-
-      /* Fetch the typeinfo pointer */
-      /* FIXME possible 32x64 problem with pointer size & arithmetic */
-      vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
-      /* Indirect through the typeinfo pointer and retrieve the pointer
-       * to the string name */
-      coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
-      if (!coreptr)
-       error ("Retrieved null typeinfo pointer in trying to determine run-time type");
-      vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v));            /* 4 -> offset of name field */
-      /* FIXME possible 32x64 problem */
-
-      coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
-
-      read_memory_string (coreptr, rtti_type_name, 256);
-
-      if (strlen (rtti_type_name) == 0)
-       error ("Retrieved null type name from typeinfo");
-
-      /* search for type */
-      rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
-
-      if (!rtti_type)
-       error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
-      CHECK_TYPEDEF (rtti_type);
-#if 0
-      printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
-#endif
-      /* Check whether we have the entire object */
-      if (full                 /* Non-null pointer passed */
-         &&
-         /* Either we checked on the whole object in hand and found the
-            top offset to be zero */
-         (((top_offset == 0) &&
-           using_enclosing &&
-           TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
-          ||
-          /* Or we checked on the embedded object and top offset was the
-             same as the embedded offset */
-          ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
-           !using_enclosing &&
-           TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
-
-       *full = 1;
-    }
-  else
-    /*
-      Right now this is G++ RTTI. Plan on this changing in the
-      future as i get around to setting the vtables properly for G++
-      compiled stuff. Also, i'll be using the type info functions, 
-      which are always right. Deal with it until then.
-    */
-    {
-      CORE_ADDR vtbl;
-      struct minimal_symbol *minsym;
-      struct symbol *sym;
-      char *demangled_name;
-      struct type *btype;
-      /* If the type has no vptr fieldno, try to get it filled in */
-      if (TYPE_VPTR_FIELDNO(known_type) < 0)
-       fill_in_vptr_fieldno(known_type);
-
-      /* If we still can't find one, give up */
-      if (TYPE_VPTR_FIELDNO(known_type) < 0)
-       return NULL;
-
-      /* Make sure our basetype and known type match, otherwise, cast
-        so we can get at the vtable properly.
-      */
-      btype = TYPE_VPTR_BASETYPE (known_type);
-      CHECK_TYPEDEF (btype);
-      if (btype != known_type )
-       {
-         v = value_cast (btype, v);
-         if (using_enc)
-           *using_enc=1;
-       }
-      /*
-       We can't use value_ind here, because it would want to use RTTI, and 
-       we'd waste a bunch of time figuring out we already know the type.
-        Besides, we don't care about the type, just the actual pointer
-      */
-      if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)
-       return NULL;
-
-      /*
-        If we are enclosed by something that isn't us, adjust the
-        address properly and set using_enclosing.
-      */
-      if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
-       {
-         value_ptr tempval;
-         tempval=value_field(v,TYPE_VPTR_FIELDNO(known_type));
-         VALUE_ADDRESS(tempval)+=(TYPE_BASECLASS_BITPOS(known_type,TYPE_VPTR_FIELDNO(known_type))/8);
-         vtbl=value_as_pointer(tempval);
-         using_enclosing=1;
-       }
-      else
-       {
-         vtbl=value_as_pointer(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
-         using_enclosing=0;
-       }
-
-      /* Try to find a symbol that is the vtable */
-      minsym=lookup_minimal_symbol_by_pc(vtbl);
-      if (minsym==NULL || (demangled_name=SYMBOL_NAME(minsym))==NULL || !VTBL_PREFIX_P(demangled_name))
-       return NULL;
-
-      /* If we just skip the prefix, we get screwed by namespaces */
-      demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
-      *(strchr(demangled_name,' '))=0;
-
-      /* Lookup the type for the name */
-      rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
-
-      if (rtti_type==NULL)
-       return NULL;
-
-      if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)
-       {
-         if (top)
-           *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
-         if (top && ((*top) >0))
-           {
-             if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
-               {
-                 if (full)
-                   *full=0;
-               }
-             else
-               {
-                 if (full)
-                   *full=1;
-               }
-           }
-       }
-      else
-       {
-         if (full)
-           *full=1;
-       }
-      if (using_enc)
-       *using_enc=using_enclosing;
-    }
-  return rtti_type;
-}
-
 /* Given a pointer value V, find the real (RTTI) type
    of the object it points to.
    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
    and refer to the values computed for the object pointed to. */
 
 struct type *
-value_rtti_target_type (v, full, top, using_enc)
-     value_ptr v;
-     int *full;
-     int *top;
-     int *using_enc;
+value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc)
 {
-  value_ptr target;
+  struct value *target;
 
   target = value_ind (v);
 
@@ -3452,20 +3153,15 @@ value_rtti_target_type (v, full, top, using_enc)
    they can be supplied and a second call to value_rtti_type() is avoided.
    (Pass RTYPE == NULL if they're not available */
 
-value_ptr
-value_full_object (argp, rtype, xfull, xtop, xusing_enc)
-     value_ptr argp;
-     struct type *rtype;
-     int xfull;
-     int xtop;
-     int xusing_enc;
-
+struct value *
+value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
+                  int xusing_enc)
 {
   struct type *real_type;
   int full = 0;
   int top = -1;
   int using_enc = 0;
-  value_ptr new_val;
+  struct value *new_val;
 
   if (rtype)
     {
@@ -3485,7 +3181,7 @@ value_full_object (argp, rtype, xfull, xtop, xusing_enc)
      type is wrong, set it *//* pai: FIXME -- sounds iffy */
   if (full)
     {
-      VALUE_ENCLOSING_TYPE (argp) = real_type;
+      argp = value_change_enclosing_type (argp, real_type);
       return argp;
     }
 
@@ -3516,15 +3212,14 @@ value_full_object (argp, rtype, xfull, xtop, xusing_enc)
    Flag COMPLAIN signals an error if the request is made in an
    inappropriate context.  */
 
-value_ptr
-value_of_this (complain)
-     int complain;
+struct value *
+value_of_this (int complain)
 {
   struct symbol *func, *sym;
   struct block *b;
   int i;
   static const char funny_this[] = "this";
-  value_ptr this;
+  struct value *this;
 
   if (selected_frame == 0)
     {
@@ -3555,7 +3250,7 @@ value_of_this (complain)
 
   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
      symbol instead of the LOC_ARG one (if both exist).  */
-  sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
+  sym = lookup_block_symbol (b, funny_this, NULL, VAR_NAMESPACE);
   if (sym == NULL)
     {
       if (complain)
@@ -3574,14 +3269,12 @@ value_of_this (complain)
    long, starting at LOWBOUND.  The result has the same lower bound as
    the original ARRAY.  */
 
-value_ptr
-value_slice (array, lowbound, length)
-     value_ptr array;
-     int lowbound, length;
+struct value *
+value_slice (struct value *array, int lowbound, int length)
 {
   struct type *slice_range_type, *slice_type, *range_type;
   LONGEST lowerbound, upperbound, offset;
-  value_ptr slice;
+  struct value *slice;
   struct type *array_type;
   array_type = check_typedef (VALUE_TYPE (array));
   COERCE_VARYING_ARRAY (array, array_type);
@@ -3655,9 +3348,8 @@ value_slice (array, lowbound, length)
 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
    value as a fixed-length array. */
 
-value_ptr
-varying_to_slice (varray)
-     value_ptr varray;
+struct value *
+varying_to_slice (struct value *varray)
 {
   struct type *vtype = check_typedef (VALUE_TYPE (varray));
   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
@@ -3672,13 +3364,10 @@ varying_to_slice (varray)
    that figures out precision inteligently as opposed to assuming
    doubles. FIXME: fmb */
 
-value_ptr
-value_literal_complex (arg1, arg2, type)
-     value_ptr arg1;
-     value_ptr arg2;
-     struct type *type;
+struct value *
+value_literal_complex (struct value *arg1, struct value *arg2, struct type *type)
 {
-  register value_ptr val;
+  struct value *val;
   struct type *real_type = TYPE_TARGET_TYPE (type);
 
   val = allocate_value (type);
@@ -3694,17 +3383,15 @@ value_literal_complex (arg1, arg2, type)
 
 /* Cast a value into the appropriate complex data type. */
 
-static value_ptr
-cast_into_complex (type, val)
-     struct type *type;
-     register value_ptr val;
+static struct value *
+cast_into_complex (struct type *type, struct value *val)
 {
   struct type *real_type = TYPE_TARGET_TYPE (type);
   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
     {
       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
-      value_ptr re_val = allocate_value (val_real_type);
-      value_ptr im_val = allocate_value (val_real_type);
+      struct value *re_val = allocate_value (val_real_type);
+      struct value *im_val = allocate_value (val_real_type);
 
       memcpy (VALUE_CONTENTS_RAW (re_val),
              VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
@@ -3722,7 +3409,7 @@ cast_into_complex (type, val)
 }
 
 void
-_initialize_valops ()
+_initialize_valops (void)
 {
 #if 0
   add_show_from_set
This page took 0.048437 seconds and 4 git commands to generate.