/* General utility routines for GDB, the GNU debugger.
- Copyright 1986, 89, 90, 91, 92, 95, 96, 1998 Free Software Foundation, Inc.
+ Copyright 1986, 1989, 1990-1992, 1995, 1996, 1998, 2000
+ Free Software Foundation, Inc.
This file is part of GDB.
#include <term.h>
#endif
+#ifdef __GO32__
+#include <pc.h>
+#endif
+
/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
#ifdef reg
#undef reg
/* Holds the last error message issued by gdb */
-static GDB_FILE *gdb_lasterr;
+static struct ui_file *gdb_lasterr;
/* Prototypes for local functions */
-static void vfprintf_maybe_filtered PARAMS ((GDB_FILE *, const char *,
- va_list, int));
+static void vfprintf_maybe_filtered (struct ui_file *, const char *,
+ va_list, int);
-static void fputs_maybe_filtered PARAMS ((const char *, GDB_FILE *, int));
+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
set_width PARAMS ((void));
-#ifndef GDB_FILE_ISATTY
-#define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR))
-#endif
-
/* Chain of cleanup actions established with make_cleanup,
to be executed if an error happens. */
Args are FUNCTION to clean up with, and ARG to pass to it. */
struct cleanup *
-make_cleanup (function, arg)
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&cleanup_chain, function, arg);
}
struct cleanup *
-make_final_cleanup (function, arg)
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_final_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&final_cleanup_chain, function, arg);
}
struct cleanup *
-make_run_cleanup (function, arg)
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_run_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&run_cleanup_chain, function, arg);
}
struct cleanup *
-make_exec_cleanup (function, arg)
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_exec_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&exec_cleanup_chain, function, arg);
}
struct cleanup *
-make_exec_error_cleanup (function, arg)
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
}
}
static void
-do_gdb_file_delete (void *arg)
+do_bfd_close_cleanup (void *arg)
{
- gdb_file_delete (arg);
+ bfd_close (arg);
}
struct cleanup *
-make_cleanup_gdb_file_delete (struct gdb_file *arg)
+make_cleanup_bfd_close (bfd *abfd)
+{
+ return make_cleanup (do_bfd_close_cleanup, abfd);
+}
+
+static void
+do_ui_file_delete (void *arg)
{
- return make_my_cleanup (&cleanup_chain, do_gdb_file_delete, arg);
+ ui_file_delete (arg);
}
struct cleanup *
-make_my_cleanup (pmy_chain, function, arg)
- struct cleanup **pmy_chain;
- void (*function) PARAMS ((PTR));
- PTR arg;
+make_cleanup_ui_file_delete (struct ui_file *arg)
+{
+ return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
+}
+
+struct cleanup *
+make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
+ void *arg)
{
register struct cleanup *new
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
while ((ptr = *pmy_chain) != old_chain)
{
*pmy_chain = ptr->next;
- free ((PTR) ptr);
+ free (ptr);
}
}
to arrange to free the object thus allocated. */
void
-free_current_contents (location)
- char **location;
+free_current_contents (void *ptr)
{
- free (*location);
+ void **location = ptr;
+ if (location == NULL)
+ internal_error ("free_current_contents: NULL pointer");
+ if (*location != NULL)
+ {
+ free (*location);
+ *location = NULL;
+ }
}
/* Provide a known function that does nothing, to use as a base for
/* ARGSUSED */
void
-null_cleanup (arg)
- PTR arg;
+null_cleanup (void *arg)
{
}
}
}
-/* Add a continuation to the continuation list, the gloabl list
+/* Add a continuation to the continuation list, the global list
intermediate_continuation. The new continuation will be added at the front.*/
void
add_intermediate_continuation (continuation_hook, arg_list)
va_list twice which works on some platforms and fails miserably on
others. */
/* Save it as the last error */
- gdb_file_rewind (gdb_lasterr);
+ ui_file_rewind (gdb_lasterr);
vfprintf_filtered (gdb_lasterr, string, args);
/* Retrieve the last error and print it to gdb_stderr */
err_string = error_last_message ();
}
NORETURN void
-error_stream (GDB_FILE *stream)
+error_stream (struct ui_file *stream)
{
long size;
- char *msg = gdb_file_xstrdup (stream, &size);
+ char *msg = ui_file_xstrdup (stream, &size);
make_cleanup (free, msg);
error ("%s", msg);
}
error_last_message (void)
{
long len;
- return gdb_file_xstrdup (gdb_lasterr, &len);
+ return ui_file_xstrdup (gdb_lasterr, &len);
}
/* This is to be called by main() at the very beginning */
}
/* Try to get the message out */
+ target_terminal_ours ();
fputs_unfiltered ("gdb-internal-error: ", gdb_stderr);
vfprintf_unfiltered (gdb_stderr, fmt, ap);
fputs_unfiltered ("\n", gdb_stderr);
{
va_list ap;
va_start (ap, string);
+
internal_verror (string, ap);
va_end (ap);
}
#if !defined (USE_MMALLOC)
-void *
-mcalloc (void *md, size_t number, size_t size)
+PTR
+mcalloc (PTR md, size_t number, size_t size)
{
return calloc (number, size);
}
#if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
void
-init_malloc (md)
- PTR md;
+init_malloc (void *md)
{
}
#endif
void
-init_malloc (md)
- PTR md;
+init_malloc (void *md)
{
if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE))
{
}
char *
-msavestring (md, ptr, size)
- PTR md;
- const char *ptr;
- int size;
+msavestring (void *md, const char *ptr, int size)
{
register char *p = (char *) xmmalloc (md, size + 1);
memcpy (p, ptr, size);
}
char *
-mstrsave (md, ptr)
- PTR md;
- const char *ptr;
+mstrsave (void *md, const char *ptr)
{
return (msavestring (md, ptr, strlen (ptr)));
}
void
print_spaces (n, file)
register int n;
- register GDB_FILE *file;
+ register struct ui_file *file;
{
fputs_unfiltered (n_spaces (n), file);
}
/* Print a host address. */
void
-gdb_print_host_address (void *addr, struct gdb_file *stream)
+gdb_print_host_address (void *addr, struct ui_file *stream)
{
/* We could use the %p conversion specifier to fprintf if we had any
be call for printing things which are independent of the language
of the program being debugged. */
-static void printchar PARAMS ((int c, void (*do_fputs) (const char *, GDB_FILE*), void (*do_fprintf) (GDB_FILE*, const char *, ...), GDB_FILE *stream, int quoter));
+static void printchar (int c, void (*do_fputs) (const char *, struct ui_file*), void (*do_fprintf) (struct ui_file*, const char *, ...), struct ui_file *stream, int quoter);
static void
printchar (c, do_fputs, do_fprintf, stream, quoter)
int c;
- void (*do_fputs) PARAMS ((const char *, GDB_FILE*));
- void (*do_fprintf) PARAMS ((GDB_FILE*, const char *, ...));
- GDB_FILE *stream;
+ void (*do_fputs) PARAMS ((const char *, struct ui_file*));
+ void (*do_fprintf) PARAMS ((struct ui_file*, const char *, ...));
+ struct ui_file *stream;
int quoter;
{
fputstr_filtered (str, quoter, stream)
const char *str;
int quoter;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
while (*str)
printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
fputstr_unfiltered (str, quoter, stream)
const char *str;
int quoter;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
while (*str)
printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
const char *str;
int n;
int quoter;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
int i;
for (i = 0; i < n; i++)
#endif
#endif
/* If the output is not a terminal, don't paginate it. */
- if (!GDB_FILE_ISATTY (gdb_stdout))
+ if (!ui_file_isatty (gdb_stdout))
lines_per_page = UINT_MAX;
} /* the command_line_version */
set_width ();
}
-/* ``struct gdb_file'' implementation that maps directly onto
- <stdio.h>'s FILE. */
-
-static gdb_file_write_ftype stdio_file_write;
-static gdb_file_fputs_ftype stdio_file_fputs;
-static gdb_file_isatty_ftype stdio_file_isatty;
-static gdb_file_delete_ftype stdio_file_delete;
-static struct gdb_file *stdio_file_new PARAMS ((FILE * file, int close_p));
-static gdb_file_flush_ftype stdio_file_flush;
-
-static int stdio_file_magic;
-
-struct stdio_file
- {
- int *magic;
- FILE *file;
- int close_p;
- };
-
-static struct gdb_file *
-stdio_file_new (file, close_p)
- FILE *file;
- int close_p;
-{
- struct gdb_file *gdb_file = gdb_file_new ();
- struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));
- stdio->magic = &stdio_file_magic;
- stdio->file = file;
- stdio->close_p = close_p;
- set_gdb_file_data (gdb_file, stdio, stdio_file_delete);
- set_gdb_file_flush (gdb_file, stdio_file_flush);
- set_gdb_file_write (gdb_file, stdio_file_write);
- set_gdb_file_fputs (gdb_file, stdio_file_fputs);
- set_gdb_file_isatty (gdb_file, stdio_file_isatty);
- return gdb_file;
-}
-
-static void
-stdio_file_delete (file)
- struct gdb_file *file;
-{
- struct stdio_file *stdio = gdb_file_data (file);
- if (stdio->magic != &stdio_file_magic)
- internal_error ("stdio_file_delete: bad magic number");
- if (stdio->close_p)
- {
- fclose (stdio->file);
- }
- free (stdio);
-}
-
-static void
-stdio_file_flush (file)
- struct gdb_file *file;
-{
- struct stdio_file *stdio = gdb_file_data (file);
- if (stdio->magic != &stdio_file_magic)
- internal_error ("stdio_file_flush: bad magic number");
- fflush (stdio->file);
-}
-
-static void
-stdio_file_write (struct gdb_file *file, const char *buf, long length_buf)
-{
- struct stdio_file *stdio = gdb_file_data (file);
- if (stdio->magic != &stdio_file_magic)
- internal_error ("stdio_file_write: bad magic number");
- fwrite (buf, length_buf, 1, stdio->file);
-}
-
-static void
-stdio_file_fputs (linebuffer, file)
- const char *linebuffer;
- struct gdb_file *file;
-{
- struct stdio_file *stdio = gdb_file_data (file);
- if (stdio->magic != &stdio_file_magic)
- internal_error ("stdio_file_fputs: bad magic number");
- fputs (linebuffer, stdio->file);
-}
-
-static int
-stdio_file_isatty (file)
- struct gdb_file *file;
-{
- struct stdio_file *stdio = gdb_file_data (file);
- if (stdio->magic != &stdio_file_magic)
- internal_error ("stdio_file_isatty: bad magic number");
- return (isatty (fileno (stdio->file)));
-}
-
-/* Like fdopen(). Create a gdb_file from a previously opened FILE. */
-
-struct gdb_file *
-stdio_fileopen (file)
- FILE *file;
-{
- return stdio_file_new (file, 0);
-}
-
-
-/* A pure memory based ``struct gdb_file'' that can be used an output
- buffer. The buffers accumulated contents are available via
- gdb_file_put(). */
-
-struct mem_file
- {
- int *magic;
- char *buffer;
- int sizeof_buffer;
- int length_buffer;
- };
-
-static gdb_file_rewind_ftype mem_file_rewind;
-static gdb_file_put_ftype mem_file_put;
-static gdb_file_write_ftype mem_file_write;
-static gdb_file_delete_ftype mem_file_delete;
-static struct gdb_file *mem_file_new PARAMS ((void));
-static int mem_file_magic;
-
-static struct gdb_file *
-mem_file_new (void)
-{
- struct mem_file *stream = XMALLOC (struct mem_file);
- struct gdb_file *file = gdb_file_new ();
- set_gdb_file_data (file, stream, mem_file_delete);
- set_gdb_file_rewind (file, mem_file_rewind);
- set_gdb_file_put (file, mem_file_put);
- set_gdb_file_write (file, mem_file_write);
- stream->magic = &mem_file_magic;
- stream->buffer = NULL;
- stream->sizeof_buffer = 0;
- stream->length_buffer = 0;
- return file;
-}
-
-static void
-mem_file_delete (struct gdb_file *file)
-{
- struct mem_file *stream = gdb_file_data (file);
- if (stream->magic != &mem_file_magic)
- internal_error ("mem_file_delete: bad magic number");
- if (stream->buffer != NULL)
- free (stream->buffer);
- free (stream);
-}
-
-struct gdb_file *
-mem_fileopen (void)
-{
- return mem_file_new ();
-}
-
-static void
-mem_file_rewind (struct gdb_file *file)
-{
- struct mem_file *stream = gdb_file_data (file);
- if (stream->magic != &mem_file_magic)
- internal_error ("mem_file_rewind: bad magic number");
- stream->length_buffer = 0;
-}
-
-static void
-mem_file_put (struct gdb_file *file,
- gdb_file_put_method_ftype *write,
- void *dest)
-{
- struct mem_file *stream = gdb_file_data (file);
- if (stream->magic != &mem_file_magic)
- internal_error ("mem_file_put: bad magic number");
- if (stream->length_buffer > 0)
- write (dest, stream->buffer, stream->length_buffer);
-}
-
-void
-mem_file_write (struct gdb_file *file,
- const char *buffer,
- long length_buffer)
-{
- struct mem_file *stream = gdb_file_data (file);
- if (stream->magic != &mem_file_magic)
- internal_error ("mem_file_write: bad magic number");
- if (stream->buffer == NULL)
- {
- stream->length_buffer = length_buffer;
- stream->sizeof_buffer = length_buffer;
- stream->buffer = xmalloc (stream->sizeof_buffer);
- memcpy (stream->buffer, buffer, length_buffer);
- }
- else
- {
- int new_length = stream->length_buffer + length_buffer;
- if (new_length >= stream->sizeof_buffer)
- {
- stream->sizeof_buffer = new_length;
- stream->buffer = xrealloc (stream->buffer, stream->sizeof_buffer);
- }
- memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
- stream->length_buffer = new_length;
- }
-}
-
-/* A ``struct gdb_file'' that is compatible with all the legacy
- code. */
-
-/* new */
-enum streamtype
-{
- afile,
- astring
-};
-
-/* new */
-struct tui_stream
-{
- int *ts_magic;
- enum streamtype ts_streamtype;
- FILE *ts_filestream;
- char *ts_strbuf;
- int ts_buflen;
-};
-
-static gdb_file_flush_ftype tui_file_flush;
-extern gdb_file_fputs_ftype tui_file_fputs;
-static gdb_file_isatty_ftype tui_file_isatty;
-static gdb_file_rewind_ftype tui_file_rewind;
-static gdb_file_put_ftype tui_file_put;
-static gdb_file_delete_ftype tui_file_delete;
-static struct gdb_file *tui_file_new PARAMS ((void));
-static int tui_file_magic;
-
-static struct gdb_file *
-tui_file_new ()
-{
- struct tui_stream *tui = xmalloc (sizeof (struct tui_stream));
- struct gdb_file *file = gdb_file_new ();
- set_gdb_file_data (file, tui, tui_file_delete);
- set_gdb_file_flush (file, tui_file_flush);
- set_gdb_file_fputs (file, tui_file_fputs);
- set_gdb_file_isatty (file, tui_file_isatty);
- set_gdb_file_rewind (file, tui_file_rewind);
- set_gdb_file_put (file, tui_file_put);
- tui->ts_magic = &tui_file_magic;
- return file;
-}
-
-static void
-tui_file_delete (file)
- struct gdb_file *file;
-{
- struct tui_stream *tmpstream = gdb_file_data (file);
- if (tmpstream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_delete: bad magic number");
- if ((tmpstream->ts_streamtype == astring) &&
- (tmpstream->ts_strbuf != NULL))
- {
- free (tmpstream->ts_strbuf);
- }
- free (tmpstream);
-}
-
-struct gdb_file *
-tui_fileopen (stream)
- FILE *stream;
-{
- struct gdb_file *file = tui_file_new ();
- struct tui_stream *tmpstream = gdb_file_data (file);
- tmpstream->ts_streamtype = afile;
- tmpstream->ts_filestream = stream;
- tmpstream->ts_strbuf = NULL;
- tmpstream->ts_buflen = 0;
- return file;
-}
-
-struct gdb_file *
-tui_sfileopen (n)
- int n;
-{
- struct gdb_file *file = tui_file_new ();
- struct tui_stream *tmpstream = gdb_file_data (file);
- tmpstream->ts_streamtype = astring;
- tmpstream->ts_filestream = NULL;
- if (n > 0)
- {
- tmpstream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
- tmpstream->ts_strbuf[0] = '\0';
- }
- else
- /* Do not allocate the buffer now. The first time something is printed
- one will be allocated by tui_file_adjust_strbuf() */
- tmpstream->ts_strbuf = NULL;
- tmpstream->ts_buflen = n;
- return file;
-}
-
-static int
-tui_file_isatty (file)
- struct gdb_file *file;
-{
- struct tui_stream *stream = gdb_file_data (file);
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_isatty: bad magic number");
- if (stream->ts_streamtype == afile)
- return (isatty (fileno (stream->ts_filestream)));
- else
- return 0;
-}
-
-static void
-tui_file_rewind (file)
- struct gdb_file *file;
-{
- struct tui_stream *stream = gdb_file_data (file);
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_rewind: bad magic number");
- stream->ts_strbuf[0] = '\0';
-}
-
-static void
-tui_file_put (struct gdb_file *file,
- gdb_file_put_method_ftype *write,
- void *dest)
-{
- struct tui_stream *stream = gdb_file_data (file);
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_put: bad magic number");
- if (stream->ts_streamtype == astring)
- write (dest, stream->ts_strbuf, strlen (stream->ts_strbuf));
-}
-
-/* All TUI I/O sent to the *_filtered and *_unfiltered functions
- eventually ends up here. The fputs_unfiltered_hook is primarily
- used by GUIs to collect all output and send it to the GUI, instead
- of the controlling terminal. Only output to gdb_stdout and
- gdb_stderr are sent to the hook. Everything else is sent on to
- fputs to allow file I/O to be handled appropriately. */
-
-/* FIXME: Should be broken up and moved to a TUI specific file. */
-
-void
-tui_file_fputs (linebuffer, file)
- const char *linebuffer;
- GDB_FILE *file;
-{
- struct tui_stream *stream = gdb_file_data (file);
-#if defined(TUI)
- extern int tui_owns_terminal;
-#endif
- /* NOTE: cagney/1999-10-13: The use of fputs_unfiltered_hook is
- seriously discouraged. Those wanting to hook output should
- instead implement their own gdb_file object and install that. See
- also tui_file_flush(). */
- if (fputs_unfiltered_hook
- && (file == gdb_stdout
- || file == gdb_stderr))
- fputs_unfiltered_hook (linebuffer, file);
- else
- {
-#if defined(TUI)
- if (tui_version && tui_owns_terminal)
- {
- /* If we get here somehow while updating the TUI (from
- * within a tuiDo(), then we need to temporarily
- * set up the terminal for GDB output. This probably just
- * happens on error output.
- */
-
- if (stream->ts_streamtype == astring)
- {
- tui_file_adjust_strbuf (strlen (linebuffer), stream);
- strcat (stream->ts_strbuf, linebuffer);
- }
- else
- {
- tuiTermUnsetup (0, (tui_version) ? cmdWin->detail.commandInfo.curch : 0);
- fputs (linebuffer, stream->ts_filestream);
- tuiTermSetup (0);
- if (linebuffer[strlen (linebuffer) - 1] == '\n')
- tuiClearCommandCharCount ();
- else
- tuiIncrCommandCharCountBy (strlen (linebuffer));
- }
- }
- else
- {
- /* The normal case - just do a fputs() */
- if (stream->ts_streamtype == astring)
- {
- tui_file_adjust_strbuf (strlen (linebuffer), stream);
- strcat (stream->ts_strbuf, linebuffer);
- }
- else
- fputs (linebuffer, stream->ts_filestream);
- }
-
-
-#else
- if (stream->ts_streamtype == astring)
- {
- tui_file_adjust_strbuf (strlen (linebuffer), file);
- strcat (stream->ts_strbuf, linebuffer);
- }
- else
- fputs (linebuffer, stream->ts_filestream);
-#endif
- }
-}
-
-char *
-tui_file_get_strbuf (struct gdb_file *file)
-{
- struct tui_stream *stream = gdb_file_data (file);
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_get_strbuf: bad magic number");
- return (stream->ts_strbuf);
-}
-
-/* adjust the length of the buffer by the amount necessary
- to accomodate appending a string of length N to the buffer contents */
-void
-tui_file_adjust_strbuf (int n, struct gdb_file *file)
-{
- struct tui_stream *stream = gdb_file_data (file);
- int non_null_chars;
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_adjust_strbuf: bad magic number");
-
- if (stream->ts_streamtype != astring)
- return;
-
- if (stream->ts_strbuf)
- {
- /* There is already a buffer allocated */
- non_null_chars = strlen (stream->ts_strbuf);
-
- if (n > (stream->ts_buflen - non_null_chars - 1))
- {
- stream->ts_buflen = n + non_null_chars + 1;
- stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen);
- }
- }
- else
- /* No buffer yet, so allocate one of the desired size */
- stream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
-}
-
-GDB_FILE *
-gdb_fopen (name, mode)
- char *name;
- char *mode;
-{
- FILE *f = fopen (name, mode);
- if (f == NULL)
- return NULL;
- return stdio_file_new (f, 1);
-}
-
-static void
-tui_file_flush (file)
- GDB_FILE *file;
-{
- struct tui_stream *stream = gdb_file_data (file);
- if (stream->ts_magic != &tui_file_magic)
- internal_error ("tui_file_flush: bad magic number");
-
- /* NOTE: cagney/1999-10-12: If we've been linked with code that uses
- fputs_unfiltered_hook then we assume that it doesn't need to know
- about flushes. Code that does need to know about flushes can
- implement a proper gdb_file object. */
- if (fputs_unfiltered_hook)
- return;
-
- switch (stream->ts_streamtype)
- {
- case astring:
- break;
- case afile:
- fflush (stream->ts_filestream);
- break;
- }
-}
-
-/* Implement the ``struct gdb_file'' object. */
-
-static gdb_file_isatty_ftype null_file_isatty;
-static gdb_file_write_ftype null_file_write;
-static gdb_file_fputs_ftype null_file_fputs;
-static gdb_file_flush_ftype null_file_flush;
-static gdb_file_delete_ftype null_file_delete;
-static gdb_file_rewind_ftype null_file_rewind;
-static gdb_file_put_ftype null_file_put;
-
-struct gdb_file
- {
- int *magic;
- gdb_file_flush_ftype *to_flush;
- gdb_file_write_ftype *to_write;
- gdb_file_fputs_ftype *to_fputs;
- gdb_file_delete_ftype *to_delete;
- gdb_file_isatty_ftype *to_isatty;
- gdb_file_rewind_ftype *to_rewind;
- gdb_file_put_ftype *to_put;
- void *to_data;
- };
-int gdb_file_magic;
-
-struct gdb_file *
-gdb_file_new ()
-{
- struct gdb_file *file = xmalloc (sizeof (struct gdb_file));
- file->magic = &gdb_file_magic;
- set_gdb_file_data (file, NULL, null_file_delete);
- set_gdb_file_flush (file, null_file_flush);
- set_gdb_file_write (file, null_file_write);
- set_gdb_file_fputs (file, null_file_fputs);
- set_gdb_file_isatty (file, null_file_isatty);
- set_gdb_file_rewind (file, null_file_rewind);
- set_gdb_file_put (file, null_file_put);
- return file;
-}
-
-void
-gdb_file_delete (file)
- struct gdb_file *file;
-{
- file->to_delete (file);
- free (file);
-}
-
-static int
-null_file_isatty (file)
- struct gdb_file *file;
-{
- return 0;
-}
-
-static void
-null_file_rewind (file)
- struct gdb_file *file;
-{
- return;
-}
-
-static void
-null_file_put (struct gdb_file *file,
- gdb_file_put_method_ftype *write,
- void *dest)
-{
- return;
-}
-
-static void
-null_file_flush (file)
- struct gdb_file *file;
-{
- return;
-}
-
-static void
-null_file_write (struct gdb_file *file,
- const char *buf,
- long sizeof_buf)
-{
- if (file->to_fputs == null_file_fputs)
- /* Both the write and fputs methods are null. Discard the
- request. */
- return;
- else
- {
- /* The fputs method isn't null, slowly pass the write request
- onto that. FYI, this isn't as bad as it may look - the
- current (as of 1999-11-07) printf_* function calls fputc and
- fputc does exactly the below. By having a write function it
- is possible to clean up that code. */
- int i;
- char b[2];
- b[1] = '\0';
- for (i = 0; i < sizeof_buf; i++)
- {
- b[0] = buf[i];
- file->to_fputs (b, file);
- }
- return;
- }
-}
-
-static void
-null_file_fputs (buf, file)
- const char *buf;
- struct gdb_file *file;
-{
- if (file->to_write == null_file_write)
- /* Both the write and fputs methods are null. Discard the
- request. */
- return;
- else
- {
- /* The write method was implemented, use that. */
- file->to_write (file, buf, strlen (buf));
- }
-}
-
-static void
-null_file_delete (file)
- struct gdb_file *file;
-{
- return;
-}
-
-void *
-gdb_file_data (file)
- struct gdb_file *file;
-{
- if (file->magic != &gdb_file_magic)
- internal_error ("gdb_file_data: bad magic number");
- return file->to_data;
-}
-
-void
-gdb_flush (file)
- struct gdb_file *file;
-{
- file->to_flush (file);
-}
-
-int
-gdb_file_isatty (file)
- struct gdb_file *file;
-{
- return file->to_isatty (file);
-}
-
-void
-gdb_file_rewind (file)
- struct gdb_file *file;
-{
- file->to_rewind (file);
-}
-
-void
-gdb_file_put (struct gdb_file *file,
- gdb_file_put_method_ftype *write,
- void *dest)
-{
- file->to_put (file, write, dest);
-}
-
-void
-gdb_file_write (struct gdb_file *file,
- const char *buf,
- long length_buf)
-{
- file->to_write (file, buf, length_buf);
-}
-
-void
-fputs_unfiltered (buf, file)
- const char *buf;
- struct gdb_file *file;
-{
- file->to_fputs (buf, file);
-}
-
-void
-set_gdb_file_flush (file, flush)
- struct gdb_file *file;
- gdb_file_flush_ftype *flush;
-{
- file->to_flush = flush;
-}
-
-void
-set_gdb_file_isatty (file, isatty)
- struct gdb_file *file;
- gdb_file_isatty_ftype *isatty;
-{
- file->to_isatty = isatty;
-}
-
-void
-set_gdb_file_rewind (file, rewind)
- struct gdb_file *file;
- gdb_file_rewind_ftype *rewind;
-{
- file->to_rewind = rewind;
-}
-
-void
-set_gdb_file_put (file, put)
- struct gdb_file *file;
- gdb_file_put_ftype *put;
-{
- file->to_put = put;
-}
-
-void
-set_gdb_file_write (struct gdb_file *file,
- gdb_file_write_ftype *write)
-{
- file->to_write = write;
-}
-
-void
-set_gdb_file_fputs (file, fputs)
- struct gdb_file *file;
- gdb_file_fputs_ftype *fputs;
-{
- file->to_fputs = fputs;
-}
-
-void
-set_gdb_file_data (file, data, delete)
- struct gdb_file *file;
- void *data;
- gdb_file_delete_ftype *delete;
-{
- file->to_data = data;
- file->to_delete = delete;
-}
-
-/* gdb_file utility function for converting a ``struct gdb_file'' into
- a memory buffer''. */
-
-struct accumulated_gdb_file
-{
- char *buffer;
- long length;
-};
-
-static void
-do_gdb_file_xstrdup (void *context, const char *buffer, long length)
-{
- struct accumulated_gdb_file *acc = context;
- if (acc->buffer == NULL)
- acc->buffer = xmalloc (length + 1);
- else
- acc->buffer = xrealloc (acc->buffer, acc->length + length + 1);
- memcpy (acc->buffer + acc->length, buffer, length);
- acc->length += length;
- acc->buffer[acc->length] = '\0';
-}
-
-char *
-gdb_file_xstrdup (struct gdb_file *file,
- long *length)
-{
- struct accumulated_gdb_file acc;
- acc.buffer = NULL;
- acc.length = 0;
- gdb_file_put (file, do_gdb_file_xstrdup, &acc);
- if (acc.buffer == NULL)
- acc.buffer = xstrdup ("");
- *length = acc.length;
- return acc.buffer;
-}
-
-
/* Like fputs but if FILTER is true, pause after every screenful.
Regardless of FILTER can wrap at points other than the final
static void
fputs_maybe_filtered (linebuffer, stream, filter)
const char *linebuffer;
- GDB_FILE *stream;
+ struct ui_file *stream;
int filter;
{
const char *lineptr;
void
fputs_filtered (linebuffer, stream)
const char *linebuffer;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
fputs_maybe_filtered (linebuffer, stream, 1);
}
int c;
{
char buf = c;
- gdb_file_write (gdb_stdout, &buf, 1);
+ ui_file_write (gdb_stdout, &buf, 1);
return c;
}
int
fputc_unfiltered (c, stream)
int c;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
char buf = c;
- gdb_file_write (stream, &buf, 1);
+ ui_file_write (stream, &buf, 1);
return c;
}
int
fputc_filtered (c, stream)
int c;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
char buf[2];
static void
vfprintf_maybe_filtered (stream, format, args, filter)
- GDB_FILE *stream;
+ struct ui_file *stream;
const char *format;
va_list args;
int filter;
void
vfprintf_filtered (stream, format, args)
- GDB_FILE *stream;
+ struct ui_file *stream;
const char *format;
va_list args;
{
void
vfprintf_unfiltered (stream, format, args)
- GDB_FILE *stream;
+ struct ui_file *stream;
const char *format;
va_list args;
{
}
void
-fprintf_filtered (GDB_FILE * stream, const char *format,...)
+fprintf_filtered (struct ui_file * stream, const char *format,...)
{
va_list args;
va_start (args, format);
}
void
-fprintf_unfiltered (GDB_FILE * stream, const char *format,...)
+fprintf_unfiltered (struct ui_file * stream, const char *format,...)
{
va_list args;
va_start (args, format);
Called as fprintfi_filtered (spaces, stream, format, ...); */
void
-fprintfi_filtered (int spaces, GDB_FILE * stream, const char *format,...)
+fprintfi_filtered (int spaces, struct ui_file * stream, const char *format,...)
{
va_list args;
va_start (args, format);
void
print_spaces_filtered (n, stream)
int n;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
fputs_filtered (n_spaces (n), stream);
}
void
fprintf_symbol_filtered (stream, name, lang, arg_mode)
- GDB_FILE *stream;
+ struct ui_file *stream;
char *name;
enum language lang;
int arg_mode;
init_page_info ();
/* If the output is not a terminal, don't paginate it. */
- if (!GDB_FILE_ISATTY (gdb_stdout))
+ if (!ui_file_isatty (gdb_stdout))
lines_per_page = UINT_MAX;
set_width_command ((char *) NULL, 0, c);
var_boolean, (char *) &pagination_enabled,
"Set state of pagination.", &setlist),
&showlist);
+
if (xdb_commands)
{
add_com ("am", class_support, pagination_on_command,
unsigned char *uto = (unsigned char *) to;
memcpy (&dfrom, from, sizeof (dfrom));
- memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
+ memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
+ / FLOATFORMAT_CHAR_BIT);
if (dfrom == 0)
return; /* Result is zero */
if (dfrom != dfrom) /* Result is NaN */
mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
mant *= 4294967296.0;
- mant_long = (unsigned long) mant;
+ mant_long = ((unsigned long) mant) & 0xffffffffL;
mant -= mant_long;
/* If the integer bit is implicit, then we need to discard it.
&& fmt->intbit == floatformat_intbit_no)
{
mant_long <<= 1;
+ mant_long &= 0xffffffffL;
mant_bits -= 1;
}
}
return preg_str;
}
-
-/* Helper functions for INNER_THAN */
-int
-core_addr_lessthan (lhs, rhs)
- CORE_ADDR lhs;
- CORE_ADDR rhs;
-{
- return (lhs < rhs);
-}
-
-int
-core_addr_greaterthan (lhs, rhs)
- CORE_ADDR lhs;
- CORE_ADDR rhs;
-{
- return (lhs > rhs);
-}