X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Futils.c;h=e3e88dffae99a1647cbb9f56484808d583c15895;hb=fba45db2faf619e71856ee38ec63949c0ef6903e;hp=8e2c5c550f8761f166c096b4bb5eca02eb6a8b9d;hpb=5683e87aa5680099320f4900de6ec7edc99d9f5d;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/utils.c b/gdb/utils.c
index 8e2c5c550f..e3e88dffae 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -50,6 +50,8 @@
 #include "language.h"
 #include "annotate.h"
 
+#include "inferior.h" /* for signed_pointer_to_address */
+
 #include <readline/readline.h>
 
 #undef XMALLOC
@@ -58,7 +60,7 @@
 /* readline defines this.  */
 #undef savestring
 
-void (*error_begin_hook) PARAMS ((void));
+void (*error_begin_hook) (void);
 
 /* Holds the last error message issued by gdb */
 
@@ -72,17 +74,14 @@ static void vfprintf_maybe_filtered (struct ui_file *, const char *,
 static void fputs_maybe_filtered (const char *, struct ui_file *, int);
 
 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
-static void malloc_botch PARAMS ((void));
+static void malloc_botch (void);
 #endif
 
-static void
-prompt_for_continue PARAMS ((void));
+static void prompt_for_continue (void);
 
-static void
-set_width_command PARAMS ((char *, int, struct cmd_list_element *));
+static void set_width_command (char *, int, struct cmd_list_element *);
 
-static void
-set_width PARAMS ((void));
+static void set_width (void);
 
 /* Chain of cleanup actions established with make_cleanup,
    to be executed if an error happens.  */
@@ -190,15 +189,13 @@ make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
 }
 
 static void
-do_freeargv (arg)
-     void *arg;
+do_freeargv (void *arg)
 {
   freeargv ((char **) arg);
 }
 
 struct cleanup *
-make_cleanup_freeargv (arg)
-     char **arg;
+make_cleanup_freeargv (char **arg)
 {
   return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
 }
@@ -215,6 +212,19 @@ make_cleanup_bfd_close (bfd *abfd)
   return make_cleanup (do_bfd_close_cleanup, abfd);
 }
 
+static void
+do_close_cleanup (void *arg)
+{
+  close ((int) arg);
+}
+
+struct cleanup *
+make_cleanup_close (int fd)
+{
+  /* int into void*. Outch!! */
+  return make_cleanup (do_close_cleanup, (void *) fd);
+}
+
 static void
 do_ui_file_delete (void *arg)
 {
@@ -247,44 +257,38 @@ make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
 
 void
-do_cleanups (old_chain)
-     register struct cleanup *old_chain;
+do_cleanups (register struct cleanup *old_chain)
 {
   do_my_cleanups (&cleanup_chain, old_chain);
 }
 
 void
-do_final_cleanups (old_chain)
-     register struct cleanup *old_chain;
+do_final_cleanups (register struct cleanup *old_chain)
 {
   do_my_cleanups (&final_cleanup_chain, old_chain);
 }
 
 void
-do_run_cleanups (old_chain)
-     register struct cleanup *old_chain;
+do_run_cleanups (register struct cleanup *old_chain)
 {
   do_my_cleanups (&run_cleanup_chain, old_chain);
 }
 
 void
-do_exec_cleanups (old_chain)
-     register struct cleanup *old_chain;
+do_exec_cleanups (register struct cleanup *old_chain)
 {
   do_my_cleanups (&exec_cleanup_chain, old_chain);
 }
 
 void
-do_exec_error_cleanups (old_chain)
-     register struct cleanup *old_chain;
+do_exec_error_cleanups (register struct cleanup *old_chain)
 {
   do_my_cleanups (&exec_error_cleanup_chain, old_chain);
 }
 
 void
-do_my_cleanups (pmy_chain, old_chain)
-     register struct cleanup **pmy_chain;
-     register struct cleanup *old_chain;
+do_my_cleanups (register struct cleanup **pmy_chain,
+		register struct cleanup *old_chain)
 {
   register struct cleanup *ptr;
   while ((ptr = *pmy_chain) != old_chain)
@@ -299,30 +303,26 @@ do_my_cleanups (pmy_chain, old_chain)
    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
 
 void
-discard_cleanups (old_chain)
-     register struct cleanup *old_chain;
+discard_cleanups (register struct cleanup *old_chain)
 {
   discard_my_cleanups (&cleanup_chain, old_chain);
 }
 
 void
-discard_final_cleanups (old_chain)
-     register struct cleanup *old_chain;
+discard_final_cleanups (register struct cleanup *old_chain)
 {
   discard_my_cleanups (&final_cleanup_chain, old_chain);
 }
 
 void
-discard_exec_error_cleanups (old_chain)
-     register struct cleanup *old_chain;
+discard_exec_error_cleanups (register struct cleanup *old_chain)
 {
   discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
 }
 
 void
-discard_my_cleanups (pmy_chain, old_chain)
-     register struct cleanup **pmy_chain;
-     register struct cleanup *old_chain;
+discard_my_cleanups (register struct cleanup **pmy_chain,
+		     register struct cleanup *old_chain)
 {
   register struct cleanup *ptr;
   while ((ptr = *pmy_chain) != old_chain)
@@ -334,20 +334,19 @@ discard_my_cleanups (pmy_chain, old_chain)
 
 /* Set the cleanup_chain to 0, and return the old cleanup chain.  */
 struct cleanup *
-save_cleanups ()
+save_cleanups (void)
 {
   return save_my_cleanups (&cleanup_chain);
 }
 
 struct cleanup *
-save_final_cleanups ()
+save_final_cleanups (void)
 {
   return save_my_cleanups (&final_cleanup_chain);
 }
 
 struct cleanup *
-save_my_cleanups (pmy_chain)
-     struct cleanup **pmy_chain;
+save_my_cleanups (struct cleanup **pmy_chain)
 {
   struct cleanup *old_chain = *pmy_chain;
 
@@ -357,23 +356,19 @@ save_my_cleanups (pmy_chain)
 
 /* Restore the cleanup chain from a previously saved chain.  */
 void
-restore_cleanups (chain)
-     struct cleanup *chain;
+restore_cleanups (struct cleanup *chain)
 {
   restore_my_cleanups (&cleanup_chain, chain);
 }
 
 void
-restore_final_cleanups (chain)
-     struct cleanup *chain;
+restore_final_cleanups (struct cleanup *chain)
 {
   restore_my_cleanups (&final_cleanup_chain, chain);
 }
 
 void
-restore_my_cleanups (pmy_chain, chain)
-     struct cleanup **pmy_chain;
-     struct cleanup *chain;
+restore_my_cleanups (struct cleanup **pmy_chain, struct cleanup *chain)
 {
   *pmy_chain = chain;
 }
@@ -416,7 +411,7 @@ null_cleanup (void *arg)
    cmd_continuation. The new continuation will be added at the front.*/
 void
 add_continuation (continuation_hook, arg_list)
-     void (*continuation_hook) PARAMS ((struct continuation_arg *));
+     void (*continuation_hook) (struct continuation_arg *);
      struct continuation_arg *arg_list;
 {
   struct continuation *continuation_ptr;
@@ -437,7 +432,7 @@ add_continuation (continuation_hook, arg_list)
    and do the continuations from there on, instead of using the
    global beginning of list as our iteration pointer.*/
 void
-do_all_continuations ()
+do_all_continuations (void)
 {
   struct continuation *continuation_ptr;
   struct continuation *saved_continuation;
@@ -462,7 +457,7 @@ do_all_continuations ()
 /* Walk down the cmd_continuation list, and get rid of all the
    continuations. */
 void
-discard_all_continuations ()
+discard_all_continuations (void)
 {
   struct continuation *continuation_ptr;
 
@@ -478,7 +473,7 @@ discard_all_continuations ()
    intermediate_continuation. The new continuation will be added at the front.*/
 void
 add_intermediate_continuation (continuation_hook, arg_list)
-     void (*continuation_hook) PARAMS ((struct continuation_arg *));
+     void (*continuation_hook) (struct continuation_arg *);
      struct continuation_arg *arg_list;
 {
   struct continuation *continuation_ptr;
@@ -499,7 +494,7 @@ add_intermediate_continuation (continuation_hook, arg_list)
    and do the continuations from there on, instead of using the
    global beginning of list as our iteration pointer.*/
 void
-do_all_intermediate_continuations ()
+do_all_intermediate_continuations (void)
 {
   struct continuation *continuation_ptr;
   struct continuation *saved_continuation;
@@ -524,7 +519,7 @@ do_all_intermediate_continuations ()
 /* Walk down the cmd_continuation list, and get rid of all the
    continuations. */
 void
-discard_all_intermediate_continuations ()
+discard_all_intermediate_continuations (void)
 {
   struct continuation *continuation_ptr;
 
@@ -548,7 +543,7 @@ discard_all_intermediate_continuations ()
    Is this anything other than a historical accident?  */
 
 void
-warning_begin ()
+warning_begin (void)
 {
   target_terminal_ours ();
   wrap_here ("");		/* Force out any buffered output */
@@ -587,7 +582,7 @@ warning (const char *string,...)
    that the error message can be formatted with a single printf call,
    but this is more general.  */
 void
-error_begin ()
+error_begin (void)
 {
   if (error_begin_hook)
     error_begin_hook ();
@@ -748,8 +743,7 @@ internal_error (char *string, ...)
    printable string. */
 
 char *
-safe_strerror (errnum)
-     int errnum;
+safe_strerror (int errnum)
 {
   char *msg;
   static char buf[32];
@@ -762,33 +756,12 @@ safe_strerror (errnum)
   return (msg);
 }
 
-/* The strsignal() function can return NULL for signal values that are
-   out of range.  Provide a "safe" version that always returns a
-   printable string. */
-
-char *
-safe_strsignal (signo)
-     int signo;
-{
-  char *msg;
-  static char buf[32];
-
-  if ((msg = strsignal (signo)) == NULL)
-    {
-      sprintf (buf, "(undocumented signal %d)", signo);
-      msg = buf;
-    }
-  return (msg);
-}
-
-
 /* Print the system error message for errno, and also mention STRING
    as the file name for which the error was encountered.
    Then return to command level.  */
 
 NORETURN void
-perror_with_name (string)
-     char *string;
+perror_with_name (char *string)
 {
   char *err;
   char *combined;
@@ -812,9 +785,7 @@ perror_with_name (string)
    as the file name for which the error was encountered.  */
 
 void
-print_sys_errmsg (string, errcode)
-     char *string;
-     int errcode;
+print_sys_errmsg (char *string, int errcode)
 {
   char *err;
   char *combined;
@@ -834,7 +805,7 @@ print_sys_errmsg (string, errcode)
 /* Control C eventually causes this to be called, at a convenient time.  */
 
 void
-quit ()
+quit (void)
 {
   serial_t gdb_stdout_serial = serial_fdopen (1);
 
@@ -889,7 +860,7 @@ quit ()
  */
 
 void
-notice_quit ()
+notice_quit (void)
 {
   int k = win32pollquit ();
   if (k == 1)
@@ -901,7 +872,7 @@ notice_quit ()
 #else /* !defined(_MSC_VER) */
 
 void
-notice_quit ()
+notice_quit (void)
 {
   /* Done by signals */
 }
@@ -910,8 +881,7 @@ notice_quit ()
 
 /* Control C comes here */
 void
-request_quit (signo)
-     int signo;
+request_quit (int signo)
 {
   quit_flag = 1;
   /* Restore the signal handler.  Harmless with BSD-style signals, needed
@@ -946,18 +916,13 @@ mcalloc (PTR md, size_t number, size_t size)
 }
 
 PTR
-mmalloc (md, size)
-     PTR md;
-     size_t size;
+mmalloc (PTR md, size_t size)
 {
   return malloc (size);
 }
 
 PTR
-mrealloc (md, ptr, size)
-     PTR md;
-     PTR ptr;
-     size_t size;
+mrealloc (PTR md, PTR ptr, size_t size)
 {
   if (ptr == 0)			/* Guard against old realloc's */
     return malloc (size);
@@ -966,9 +931,7 @@ mrealloc (md, ptr, size)
 }
 
 void
-mfree (md, ptr)
-     PTR md;
-     PTR ptr;
+mfree (PTR md, PTR ptr)
 {
   free (ptr);
 }
@@ -985,7 +948,7 @@ init_malloc (void *md)
 #else /* Have mmalloc and want corruption checking */
 
 static void
-malloc_botch ()
+malloc_botch (void)
 {
   fprintf_unfiltered (gdb_stderr, "Memory corruption\n");
   abort ();
@@ -1033,8 +996,7 @@ init_malloc (void *md)
    memory requested in SIZE. */
 
 NORETURN void
-nomem (size)
-     long size;
+nomem (long size)
 {
   if (size > 0)
     {
@@ -1052,9 +1014,7 @@ nomem (size)
    byte of zero'd storage, is a religious issue. */
 
 PTR
-xmmalloc (md, size)
-     PTR md;
-     long size;
+xmmalloc (PTR md, long size)
 {
   register PTR val;
 
@@ -1072,10 +1032,7 @@ xmmalloc (md, size)
 /* Like mrealloc but get error if no storage available.  */
 
 PTR
-xmrealloc (md, ptr, size)
-     PTR md;
-     PTR ptr;
-     long size;
+xmrealloc (PTR md, PTR ptr, long size)
 {
   register PTR val;
 
@@ -1098,8 +1055,7 @@ xmrealloc (md, ptr, size)
    the caller wanting to allocate zero bytes.  */
 
 PTR
-xmalloc (size)
-     size_t size;
+xmalloc (size_t size)
 {
   return (xmmalloc ((PTR) NULL, size));
 }
@@ -1118,9 +1074,7 @@ xcalloc (size_t number, size_t size)
 /* Like mrealloc but get error if no storage available.  */
 
 PTR
-xrealloc (ptr, size)
-     PTR ptr;
-     size_t size;
+xrealloc (PTR ptr, size_t size)
 {
   return (xmrealloc ((PTR) NULL, ptr, size));
 }
@@ -1130,10 +1084,7 @@ xrealloc (ptr, size)
    Used like `read' but keeps going if `read' returns too soon.  */
 
 int
-myread (desc, addr, len)
-     int desc;
-     char *addr;
-     int len;
+myread (int desc, char *addr, int len)
 {
   register int val;
   int orglen = len;
@@ -1156,9 +1107,7 @@ myread (desc, addr, len)
    Uses malloc to get the space.  Returns the address of the copy.  */
 
 char *
-savestring (ptr, size)
-     const char *ptr;
-     int size;
+savestring (const char *ptr, int size)
 {
   register char *p = (char *) xmalloc (size + 1);
   memcpy (p, ptr, size);
@@ -1179,8 +1128,7 @@ msavestring (void *md, const char *ptr, int size)
    in <string.h>.  FIXME: This should be named "xstrsave", shouldn't it?
    Doesn't real strsave return NULL if out of memory?  */
 char *
-strsave (ptr)
-     const char *ptr;
+strsave (const char *ptr)
 {
   return savestring (ptr, strlen (ptr));
 }
@@ -1192,9 +1140,7 @@ mstrsave (void *md, const char *ptr)
 }
 
 void
-print_spaces (n, file)
-     register int n;
-     register struct ui_file *file;
+print_spaces (register int n, register struct ui_file *file)
 {
   fputs_unfiltered (n_spaces (n), file);
 }
@@ -1335,8 +1281,7 @@ query (char *ctlstr,...)
    after the zeros.  A value of 0 does not mean end of string.  */
 
 int
-parse_escape (string_ptr)
-     char **string_ptr;
+parse_escape (char **string_ptr)
 {
   register int c = *(*string_ptr)++;
   switch (c)
@@ -1411,8 +1356,8 @@ static void printchar (int c, void (*do_fputs) (const char *, struct ui_file*),
 static void
 printchar (c, do_fputs, do_fprintf, stream, quoter)
      int c;
-     void (*do_fputs) PARAMS ((const char *, struct ui_file*));
-     void (*do_fprintf) PARAMS ((struct ui_file*, const char *, ...));
+     void (*do_fputs) (const char *, struct ui_file *);
+     void (*do_fprintf) (struct ui_file *, const char *, ...);
      struct ui_file *stream;
      int quoter;
 {
@@ -1465,31 +1410,21 @@ printchar (c, do_fputs, do_fprintf, stream, quoter)
    the language of the program being debugged. */
 
 void
-fputstr_filtered (str, quoter, stream)
-     const char *str;
-     int quoter;
-     struct ui_file *stream;
+fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
 {
   while (*str)
     printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
 }
 
 void
-fputstr_unfiltered (str, quoter, stream)
-     const char *str;
-     int quoter;
-     struct ui_file *stream;
+fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
 {
   while (*str)
     printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
 }
 
 void
-fputstrn_unfiltered (str, n, quoter, stream)
-     const char *str;
-     int n;
-     int quoter;
-     struct ui_file *stream;
+fputstrn_unfiltered (const char *str, int n, int quoter, struct ui_file *stream)
 {
   int i;
   for (i = 0; i < n; i++)
@@ -1500,7 +1435,7 @@ fputstrn_unfiltered (str, n, quoter, stream)
 
 /* Number of lines per page or UINT_MAX if paging is disabled.  */
 static unsigned int lines_per_page;
-/* Number of chars per line or UNIT_MAX if line folding is disabled.  */
+/* Number of chars per line or UINT_MAX if line folding is disabled.  */
 static unsigned int chars_per_line;
 /* Current count of lines printed on this page, chars on this line.  */
 static unsigned int lines_printed, chars_printed;
@@ -1532,7 +1467,7 @@ static int wrap_column;
 
 /* Inialize the lines and chars per page */
 void
-init_page_info ()
+init_page_info (void)
 {
 #if defined(TUI)
   if (tui_version && m_winPtrNotNull (cmdWin))
@@ -1606,7 +1541,7 @@ init_page_info ()
 }
 
 static void
-set_width ()
+set_width (void)
 {
   if (chars_per_line == 0)
     init_page_info ();
@@ -1623,10 +1558,7 @@ set_width ()
 
 /* ARGSUSED */
 static void
-set_width_command (args, from_tty, c)
-     char *args;
-     int from_tty;
-     struct cmd_list_element *c;
+set_width_command (char *args, int from_tty, struct cmd_list_element *c)
 {
   set_width ();
 }
@@ -1635,7 +1567,7 @@ set_width_command (args, from_tty, c)
    to continue by pressing RETURN.  */
 
 static void
-prompt_for_continue ()
+prompt_for_continue (void)
 {
   char *ignore;
   char cont_prompt[120];
@@ -1695,7 +1627,7 @@ prompt_for_continue ()
 /* Reinitialize filter; ie. tell it to reset to original values.  */
 
 void
-reinitialize_more_filter ()
+reinitialize_more_filter (void)
 {
   lines_printed = 0;
   chars_printed = 0;
@@ -1723,8 +1655,7 @@ reinitialize_more_filter ()
    used to force out output from the wrap_buffer.  */
 
 void
-wrap_here (indent)
-     char *indent;
+wrap_here (char *indent)
 {
   /* This should have been allocated, but be paranoid anyway. */
   if (!wrap_buffer)
@@ -1764,7 +1695,7 @@ wrap_here (indent)
    line.  Otherwise do nothing. */
 
 void
-begin_line ()
+begin_line (void)
 {
   if (chars_printed > 0)
     {
@@ -1787,10 +1718,8 @@ begin_line ()
    routine should not be called when cleanups are not in place.  */
 
 static void
-fputs_maybe_filtered (linebuffer, stream, filter)
-     const char *linebuffer;
-     struct ui_file *stream;
-     int filter;
+fputs_maybe_filtered (const char *linebuffer, struct ui_file *stream,
+		      int filter)
 {
   const char *lineptr;
 
@@ -1891,16 +1820,13 @@ fputs_maybe_filtered (linebuffer, stream, filter)
 }
 
 void
-fputs_filtered (linebuffer, stream)
-     const char *linebuffer;
-     struct ui_file *stream;
+fputs_filtered (const char *linebuffer, struct ui_file *stream)
 {
   fputs_maybe_filtered (linebuffer, stream, 1);
 }
 
 int
-putchar_unfiltered (c)
-     int c;
+putchar_unfiltered (int c)
 {
   char buf = c;
   ui_file_write (gdb_stdout, &buf, 1);
@@ -1908,9 +1834,7 @@ putchar_unfiltered (c)
 }
 
 int
-fputc_unfiltered (c, stream)
-     int c;
-     struct ui_file *stream;
+fputc_unfiltered (int c, struct ui_file *stream)
 {
   char buf = c;
   ui_file_write (stream, &buf, 1);
@@ -1918,9 +1842,7 @@ fputc_unfiltered (c, stream)
 }
 
 int
-fputc_filtered (c, stream)
-     int c;
-     struct ui_file *stream;
+fputc_filtered (int c, struct ui_file *stream)
 {
   char buf[2];
 
@@ -1934,10 +1856,7 @@ fputc_filtered (c, stream)
    characters in printable fashion.  */
 
 void
-puts_debug (prefix, string, suffix)
-     char *prefix;
-     char *string;
-     char *suffix;
+puts_debug (char *prefix, char *string, char *suffix)
 {
   int ch;
 
@@ -2033,11 +1952,8 @@ puts_debug (prefix, string, suffix)
    called when cleanups are not in place.  */
 
 static void
-vfprintf_maybe_filtered (stream, format, args, filter)
-     struct ui_file *stream;
-     const char *format;
-     va_list args;
-     int filter;
+vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
+			 va_list args, int filter)
 {
   char *linebuffer;
   struct cleanup *old_cleanups;
@@ -2055,19 +1971,13 @@ vfprintf_maybe_filtered (stream, format, args, filter)
 
 
 void
-vfprintf_filtered (stream, format, args)
-     struct ui_file *stream;
-     const char *format;
-     va_list args;
+vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
 {
   vfprintf_maybe_filtered (stream, format, args, 1);
 }
 
 void
-vfprintf_unfiltered (stream, format, args)
-     struct ui_file *stream;
-     const char *format;
-     va_list args;
+vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
 {
   char *linebuffer;
   struct cleanup *old_cleanups;
@@ -2084,17 +1994,13 @@ vfprintf_unfiltered (stream, format, args)
 }
 
 void
-vprintf_filtered (format, args)
-     const char *format;
-     va_list args;
+vprintf_filtered (const char *format, va_list args)
 {
   vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
 }
 
 void
-vprintf_unfiltered (format, args)
-     const char *format;
-     va_list args;
+vprintf_unfiltered (const char *format, va_list args)
 {
   vfprintf_unfiltered (gdb_stdout, format, args);
 }
@@ -2170,15 +2076,13 @@ printfi_filtered (int spaces, const char *format,...)
    This one doesn't, and had better not!  */
 
 void
-puts_filtered (string)
-     const char *string;
+puts_filtered (const char *string)
 {
   fputs_filtered (string, gdb_stdout);
 }
 
 void
-puts_unfiltered (string)
-     const char *string;
+puts_unfiltered (const char *string)
 {
   fputs_unfiltered (string, gdb_stdout);
 }
@@ -2186,8 +2090,7 @@ puts_unfiltered (string)
 /* Return a pointer to N spaces and a null.  The pointer is good
    until the next call to here.  */
 char *
-n_spaces (n)
-     int n;
+n_spaces (int n)
 {
   char *t;
   static char *spaces = 0;
@@ -2209,9 +2112,7 @@ n_spaces (n)
 
 /* Print N spaces.  */
 void
-print_spaces_filtered (n, stream)
-     int n;
-     struct ui_file *stream;
+print_spaces_filtered (int n, struct ui_file *stream)
 {
   fputs_filtered (n_spaces (n), stream);
 }
@@ -2224,11 +2125,8 @@ print_spaces_filtered (n, stream)
    demangling is off, the name is printed in its "raw" form. */
 
 void
-fprintf_symbol_filtered (stream, name, lang, arg_mode)
-     struct ui_file *stream;
-     char *name;
-     enum language lang;
-     int arg_mode;
+fprintf_symbol_filtered (struct ui_file *stream, char *name, enum language lang,
+			 int arg_mode)
 {
   char *demangled;
 
@@ -2275,9 +2173,7 @@ fprintf_symbol_filtered (stream, name, lang, arg_mode)
    function). */
 
 int
-strcmp_iw (string1, string2)
-     const char *string1;
-     const char *string2;
+strcmp_iw (const char *string1, const char *string2)
 {
   while ((*string1 != '\0') && (*string2 != '\0'))
     {
@@ -2310,9 +2206,7 @@ strcmp_iw (string1, string2)
    **    at index 0.
  */
 int
-subset_compare (string_to_compare, template_string)
-     char *string_to_compare;
-     char *template_string;
+subset_compare (char *string_to_compare, char *template_string)
 {
   int match;
   if (template_string != (char *) NULL && string_to_compare != (char *) NULL &&
@@ -2326,27 +2220,23 @@ subset_compare (string_to_compare, template_string)
 }
 
 
-static void pagination_on_command PARAMS ((char *arg, int from_tty));
+static void pagination_on_command (char *arg, int from_tty);
 static void
-pagination_on_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+pagination_on_command (char *arg, int from_tty)
 {
   pagination_enabled = 1;
 }
 
-static void pagination_on_command PARAMS ((char *arg, int from_tty));
+static void pagination_on_command (char *arg, int from_tty);
 static void
-pagination_off_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+pagination_off_command (char *arg, int from_tty)
 {
   pagination_enabled = 0;
 }
 
 
 void
-initialize_utils ()
+initialize_utils (void)
 {
   struct cmd_list_element *c;
 
@@ -2427,21 +2317,15 @@ SIGWINCH_HANDLER_BODY
    a system header, what we do if not, etc.  */
 #define FLOATFORMAT_CHAR_BIT 8
 
-static unsigned long get_field PARAMS ((unsigned char *,
-					enum floatformat_byteorders,
-					unsigned int,
-					unsigned int,
-					unsigned int));
+static unsigned long get_field (unsigned char *,
+				enum floatformat_byteorders,
+				unsigned int, unsigned int, unsigned int);
 
 /* Extract a field which starts at START and is LEN bytes long.  DATA and
    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 static unsigned long
-get_field (data, order, total_len, start, len)
-     unsigned char *data;
-     enum floatformat_byteorders order;
-     unsigned int total_len;
-     unsigned int start;
-     unsigned int len;
+get_field (unsigned char *data, enum floatformat_byteorders order,
+	   unsigned int total_len, unsigned int start, unsigned int len)
 {
   unsigned long result;
   unsigned int cur_byte;
@@ -2500,10 +2384,8 @@ get_field (data, order, total_len, start, len)
    Store the DOUBLEST in *TO.  */
 
 void
-floatformat_to_doublest (fmt, from, to)
-     const struct floatformat *fmt;
-     char *from;
-     DOUBLEST *to;
+floatformat_to_doublest (const struct floatformat *fmt, char *from,
+			 DOUBLEST *to)
 {
   unsigned char *ufrom = (unsigned char *) from;
   DOUBLEST dto;
@@ -2607,22 +2489,16 @@ floatformat_to_doublest (fmt, from, to)
   *to = dto;
 }
 
-static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
-			       unsigned int,
-			       unsigned int,
-			       unsigned int,
-			       unsigned long));
+static void put_field (unsigned char *, enum floatformat_byteorders,
+		       unsigned int,
+		       unsigned int, unsigned int, unsigned long);
 
 /* Set a field which starts at START and is LEN bytes long.  DATA and
    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 static void
-put_field (data, order, total_len, start, len, stuff_to_put)
-     unsigned char *data;
-     enum floatformat_byteorders order;
-     unsigned int total_len;
-     unsigned int start;
-     unsigned int len;
-     unsigned long stuff_to_put;
+put_field (unsigned char *data, enum floatformat_byteorders order,
+	   unsigned int total_len, unsigned int start, unsigned int len,
+	   unsigned long stuff_to_put)
 {
   unsigned int cur_byte;
   int cur_bitshift;
@@ -2682,12 +2558,10 @@ put_field (data, order, total_len, start, len, stuff_to_put)
    The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
    frexp, but operates on the long double data type.  */
 
-static long double ldfrexp PARAMS ((long double value, int *eptr));
+static long double ldfrexp (long double value, int *eptr);
 
 static long double
-ldfrexp (value, eptr)
-     long double value;
-     int *eptr;
+ldfrexp (long double value, int *eptr)
 {
   long double tmp;
   int exp;
@@ -2730,10 +2604,8 @@ ldfrexp (value, eptr)
    restrictions.  */
 
 void
-floatformat_from_doublest (fmt, from, to)
-     CONST struct floatformat *fmt;
-     DOUBLEST *from;
-     char *to;
+floatformat_from_doublest (CONST struct floatformat *fmt, DOUBLEST *from,
+			   char *to)
 {
   DOUBLEST dfrom;
   int exponent;
@@ -2842,7 +2714,7 @@ floatformat_from_doublest (fmt, from, to)
 #define NUMCELLS 16
 #define CELLSIZE 32
 static char *
-get_cell ()
+get_cell (void)
 {
   static char buf[NUMCELLS][CELLSIZE];
   static int cell = 0;
@@ -2976,3 +2848,24 @@ phex_nz (ULONGEST l, int sizeof_l)
     }
   return str;
 }
+
+
+/* Convert to / from the hosts pointer to GDB's internal CORE_ADDR
+   using the target's conversion routines. */
+CORE_ADDR
+host_pointer_to_address (void *ptr)
+{
+  if (sizeof (ptr) != TYPE_LENGTH (builtin_type_ptr))
+    internal_error ("core_addr_to_void_ptr: bad cast");
+  return POINTER_TO_ADDRESS (builtin_type_ptr, &ptr);
+}
+
+void *
+address_to_host_pointer (CORE_ADDR addr)
+{
+  void *ptr;
+  if (sizeof (ptr) != TYPE_LENGTH (builtin_type_ptr))
+    internal_error ("core_addr_to_void_ptr: bad cast");
+  ADDRESS_TO_POINTER (builtin_type_ptr, &ptr, addr);
+  return ptr;
+}