/* General utility routines for GDB, the GNU debugger.
- Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
+ Copyright 1986, 1989, 1990, 1991, 1992, 1995 Free Software Foundation, Inc.
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-#include <stdio.h>
+#include "defs.h"
+#if !defined(__GO32__) && !defined(__WIN32__) && !defined(MPW)
#include <sys/ioctl.h>
#include <sys/param.h>
#include <pwd.h>
-#include "defs.h"
-#include "param.h"
-#include "signals.h"
-#include "gdbcmd.h"
-#include "terminal.h"
+#endif
+#ifdef ANSI_PROTOTYPES
+#include <stdarg.h>
+#else
#include <varargs.h>
+#endif
#include <ctype.h>
-#include <string.h>
+#include "gdb_string.h"
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "signals.h"
+#include "gdbcmd.h"
+#include "serial.h"
#include "bfd.h"
#include "target.h"
+#include "demangle.h"
+#include "expression.h"
+#include "language.h"
+#include "annotate.h"
-extern volatile void return_to_top_level ();
-extern volatile void exit ();
-extern char *gdb_readline ();
-extern char *getenv();
-extern char *malloc();
-extern char *realloc();
+#include "readline.h"
-/* If this definition isn't overridden by the header files, assume
- that isatty and fileno exist on this system. */
-#ifndef ISATTY
-#define ISATTY(FP) (isatty (fileno (FP)))
-#endif
+/* readline defines this. */
+#undef savestring
-#ifdef MISSING_VPRINTF
-#ifdef __GNU_LIBRARY
-#undef MISSING_VPRINTF
-#else /* !__GNU_LIBRARY */
+/* Prototypes for local functions */
-#ifndef vfprintf
-#define vfprintf(file, format, ap) _doprnt (format, ap, file)
-#endif /* vfprintf */
+#if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
+#else
-#ifndef vprintf
-/* Can't #define it since printcmd.c needs it */
-void
-vprintf (format, ap)
- char *format; void *ap;
-{
- vfprintf (stdout, format, ap);
-}
-#endif /* vprintf */
+static void
+malloc_botch PARAMS ((void));
+
+#endif /* NO_MMALLOC, etc */
+
+static void
+fatal_dump_core PARAMS((char *, ...));
-#endif /* GNU_LIBRARY */
-#endif /* MISSING_VPRINTF */
+static void
+prompt_for_continue PARAMS ((void));
+
+static void
+set_width_command PARAMS ((char *, int, struct cmd_list_element *));
-void error ();
-void fatal ();
+/* If this definition isn't overridden by the header files, assume
+ that isatty and fileno exist on this system. */
+#ifndef ISATTY
+#define ISATTY(FP) (isatty (fileno (FP)))
+#endif
/* Chain of cleanup actions established with make_cleanup,
to be executed if an error happens. */
static struct cleanup *cleanup_chain;
+/* Nonzero if we have job control. */
+
+int job_control;
+
/* Nonzero means a quit has been requested. */
int quit_flag;
-/* Nonzero means quit immediately if Control-C is typed now,
- rather than waiting until QUIT is executed. */
+/* Nonzero means quit immediately if Control-C is typed now, rather
+ than waiting until QUIT is executed. Be careful in setting this;
+ code which executes with immediate_quit set has to be very careful
+ about being able to deal with being interrupted at any time. It is
+ almost always better to use QUIT; the only exception I can think of
+ is being able to quit out of a system call (using EINTR loses if
+ the SIGINT happens between the previous QUIT and the system call).
+ To immediately quit in the case in which a SIGINT happens between
+ the previous QUIT and setting immediate_quit (desirable anytime we
+ expect to block), call QUIT after setting immediate_quit. */
int immediate_quit;
international character, and the terminal or window can cope.) */
int sevenbit_strings = 0;
+
+/* String to be printed before error messages, if any. */
+
+char *error_pre_print;
+
+/* String to be printed before quit messages, if any. */
+
+char *quit_pre_print;
+
+/* String to be printed before warning messages, if any. */
+
+char *warning_pre_print = "\nwarning: ";
\f
/* Add a new cleanup to the cleanup_chain,
and return the previous chain pointer
struct cleanup *
make_cleanup (function, arg)
- void (*function) ();
- int arg;
+ void (*function) PARAMS ((PTR));
+ PTR arg;
{
register struct cleanup *new
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
register struct cleanup *ptr;
while ((ptr = cleanup_chain) != old_chain)
{
+ cleanup_chain = ptr->next; /* Do this first incase recursion */
(*ptr->function) (ptr->arg);
- cleanup_chain = ptr->next;
free (ptr);
}
}
while ((ptr = cleanup_chain) != old_chain)
{
cleanup_chain = ptr->next;
- free (ptr);
+ free ((PTR)ptr);
}
}
{
free (*location);
}
+
+/* Provide a known function that does nothing, to use as a base for
+ for a possibly long chain of cleanups. This is useful where we
+ use the cleanup chain for handling normal cleanups as well as dealing
+ with cleanups that need to be done as a result of a call to error().
+ In such cases, we may not be certain where the first cleanup is, unless
+ we have a do-nothing one to always use as the base. */
+
+/* ARGSUSED */
+void
+null_cleanup (arg)
+ char **arg;
+{
+}
+
\f
-/* Print an error message and return to command level.
- The first argument STRING is the error message, used as a fprintf string,
- and the remaining args are passed as arguments to it. */
+/* Print a warning message. Way to use this is to call warning_begin,
+ output the warning message (use unfiltered output to gdb_stderr),
+ ending in a newline. There is not currently a warning_end that you
+ call afterwards, but such a thing might be added if it is useful
+ for a GUI to separate warning messages from other output.
+
+ FIXME: Why do warnings use unfiltered output and errors filtered?
+ Is this anything other than a historical accident? */
+
+void
+warning_begin ()
+{
+ target_terminal_ours ();
+ wrap_here(""); /* Force out any buffered output */
+ gdb_flush (gdb_stdout);
+ if (warning_pre_print)
+ fprintf_unfiltered (gdb_stderr, warning_pre_print);
+}
+
+/* Print a warning message.
+ The first argument STRING is the warning message, used as a fprintf string,
+ and the remaining args are passed as arguments to it.
+ The primary difference between warnings and errors is that a warning
+ does not force the return to command level. */
/* VARARGS */
void
-error (va_alist)
+#ifdef ANSI_PROTOTYPES
+warning (char *string, ...)
+#else
+warning (va_alist)
va_dcl
+#endif
{
va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, string);
+#else
char *string;
va_start (args);
- target_terminal_ours ();
- fflush (stdout);
string = va_arg (args, char *);
- vfprintf (stderr, string, args);
- fprintf (stderr, "\n");
+#endif
+ warning_begin ();
+ vfprintf_unfiltered (gdb_stderr, string, args);
+ fprintf_unfiltered (gdb_stderr, "\n");
va_end (args);
- return_to_top_level ();
}
+/* Start the printing of an error message. Way to use this is to call
+ this, output the error message (use filtered output to gdb_stderr
+ (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
+ in a newline, and then call return_to_top_level (RETURN_ERROR).
+ error() provides a convenient way to do this for the special case
+ that the error message can be formatted with a single printf call,
+ but this is more general. */
+void
+error_begin ()
+{
+ target_terminal_ours ();
+ wrap_here (""); /* Force out any buffered output */
+ gdb_flush (gdb_stdout);
+
+ annotate_error_begin ();
+
+ if (error_pre_print)
+ fprintf_filtered (gdb_stderr, error_pre_print);
+}
+
+/* Print an error message and return to command level.
+ The first argument STRING is the error message, used as a fprintf string,
+ and the remaining args are passed as arguments to it. */
+
+#ifdef ANSI_PROTOTYPES
+NORETURN void
+error (char *string, ...)
+#else
+void
+error (va_alist)
+ va_dcl
+#endif
+{
+ va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, string);
+#else
+ va_start (args);
+#endif
+ if (error_hook)
+ (*error_hook) ();
+ else
+ {
+ error_begin ();
+#ifdef ANSI_PROTOTYPES
+ vfprintf_filtered (gdb_stderr, string, args);
+#else
+ {
+ char *string1;
+
+ string1 = va_arg (args, char *);
+ vfprintf_filtered (gdb_stderr, string1, args);
+ }
+#endif
+ fprintf_filtered (gdb_stderr, "\n");
+ va_end (args);
+ return_to_top_level (RETURN_ERROR);
+ }
+}
+
+
/* Print an error message and exit reporting failure.
This is for a error that we cannot continue from.
- The arguments are printed a la printf. */
+ The arguments are printed a la printf.
+
+ This function cannot be declared volatile (NORETURN) in an
+ ANSI environment because exit() is not declared volatile. */
/* VARARGS */
-void
+NORETURN void
+#ifdef ANSI_PROTOTYPES
+fatal (char *string, ...)
+#else
fatal (va_alist)
va_dcl
+#endif
{
va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, string);
+#else
char *string;
-
va_start (args);
string = va_arg (args, char *);
- fprintf (stderr, "gdb: ");
- vfprintf (stderr, string, args);
- fprintf (stderr, "\n");
+#endif
+ fprintf_unfiltered (gdb_stderr, "\ngdb: ");
+ vfprintf_unfiltered (gdb_stderr, string, args);
+ fprintf_unfiltered (gdb_stderr, "\n");
va_end (args);
exit (1);
}
/* Print an error message and exit, dumping core.
The arguments are printed a la printf (). */
+
/* VARARGS */
-void
+static void
+#ifdef ANSI_PROTOTYPES
+fatal_dump_core (char *string, ...)
+#else
fatal_dump_core (va_alist)
va_dcl
+#endif
{
va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, string);
+#else
char *string;
va_start (args);
string = va_arg (args, char *);
+#endif
/* "internal error" is always correct, since GDB should never dump
core, no matter what the input. */
- fprintf (stderr, "gdb internal error: ");
- vfprintf (stderr, string, args);
- fprintf (stderr, "\n");
+ fprintf_unfiltered (gdb_stderr, "\ngdb internal error: ");
+ vfprintf_unfiltered (gdb_stderr, string, args);
+ fprintf_unfiltered (gdb_stderr, "\n");
va_end (args);
signal (SIGQUIT, SIG_DFL);
/* We should never get here, but just in case... */
exit (1);
}
-\f
-/* Memory management stuff (malloc friends). */
-
-#if defined (NO_MALLOC_CHECK)
-void
-init_malloc ()
-{}
-#else /* Have mcheck(). */
-static void
-malloc_botch ()
-{
- fatal_dump_core ("Memory corruption");
-}
-void
-init_malloc ()
-{
- mcheck (malloc_botch);
- mtrace ();
-}
-#endif /* Have mcheck(). */
-
-/* Like malloc but get error if no storage available. */
+/* The strerror() function can return NULL for errno values that are
+ out of range. Provide a "safe" version that always returns a
+ printable string. */
-#ifdef __STDC__
-void *
-#else
char *
-#endif
-xmalloc (size)
- long size;
+safe_strerror (errnum)
+ int errnum;
{
- register char *val;
+ char *msg;
+ static char buf[32];
- /* At least one place (dbxread.c:condense_misc_bunches where misc_count == 0)
- GDB wants to allocate zero bytes. */
- if (size == 0)
- return NULL;
-
- val = (char *) malloc (size);
- if (!val)
- fatal ("virtual memory exhausted.", 0);
- return val;
+ if ((msg = strerror (errnum)) == NULL)
+ {
+ sprintf (buf, "(undocumented errno %d)", errnum);
+ msg = buf;
+ }
+ return (msg);
}
-/* Like realloc but get error if no storage available. */
+/* The strsignal() function can return NULL for signal values that are
+ out of range. Provide a "safe" version that always returns a
+ printable string. */
-#ifdef __STDC__
-void *
-#else
char *
-#endif
-xrealloc (ptr, size)
- char *ptr;
- long size;
+safe_strsignal (signo)
+ int signo;
{
- register char *val = (char *) realloc (ptr, size);
- if (!val)
- fatal ("virtual memory exhausted.", 0);
- return val;
+ 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. */
perror_with_name (string)
char *string;
{
- extern int sys_nerr;
- extern char *sys_errlist[];
char *err;
char *combined;
- if (errno < sys_nerr)
- err = sys_errlist[errno];
- else
- err = "unknown error";
-
+ err = safe_strerror (errno);
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
strcpy (combined, string);
strcat (combined, ": ");
/* I understand setting these is a matter of taste. Still, some people
may clear errno but not know about bfd_error. Doing this here is not
unreasonable. */
- bfd_error = no_error;
+ bfd_set_error (bfd_error_no_error);
errno = 0;
error ("%s.", combined);
char *string;
int errcode;
{
- extern int sys_nerr;
- extern char *sys_errlist[];
char *err;
char *combined;
- if (errcode < sys_nerr)
- err = sys_errlist[errcode];
- else
- err = "unknown error";
-
+ err = safe_strerror (errcode);
combined = (char *) alloca (strlen (err) + strlen (string) + 3);
strcpy (combined, string);
strcat (combined, ": ");
strcat (combined, err);
- printf ("%s.\n", combined);
+ /* We want anything which was printed on stdout to come out first, before
+ this message. */
+ gdb_flush (gdb_stdout);
+ fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
}
/* Control C eventually causes this to be called, at a convenient time. */
void
quit ()
{
+ serial_t gdb_stdout_serial = serial_fdopen (1);
+
target_terminal_ours ();
-#ifdef HAVE_TERMIO
- ioctl (fileno (stdout), TCFLSH, 1);
-#else /* not HAVE_TERMIO */
- ioctl (fileno (stdout), TIOCFLUSH, 0);
-#endif /* not HAVE_TERMIO */
-#ifdef TIOCGPGRP
- error ("Quit");
-#else
- error ("Quit (expect signal %d when inferior is resumed)", SIGINT);
-#endif /* TIOCGPGRP */
+
+ /* We want all output to appear now, before we print "Quit". We
+ have 3 levels of buffering we have to flush (it's possible that
+ some of these should be changed to flush the lower-level ones
+ too): */
+
+ /* 1. The _filtered buffer. */
+ wrap_here ((char *)0);
+
+ /* 2. The stdio buffer. */
+ gdb_flush (gdb_stdout);
+ gdb_flush (gdb_stderr);
+
+ /* 3. The system-level buffer. */
+ SERIAL_FLUSH_OUTPUT (gdb_stdout_serial);
+ SERIAL_UN_FDOPEN (gdb_stdout_serial);
+
+ annotate_error_begin ();
+
+ /* Don't use *_filtered; we don't want to prompt the user to continue. */
+ if (quit_pre_print)
+ fprintf_unfiltered (gdb_stderr, quit_pre_print);
+
+ if (job_control
+ /* If there is no terminal switching for this target, then we can't
+ possibly get screwed by the lack of job control. */
+ || current_target.to_terminal_ours == NULL)
+ fprintf_unfiltered (gdb_stderr, "Quit\n");
+ else
+ fprintf_unfiltered (gdb_stderr,
+ "Quit (expect signal SIGINT when the program is resumed)\n");
+ return_to_top_level (RETURN_QUIT);
}
-/* Control C comes here */
+
+#if defined(__GO32__)||defined(WINGDB)
+
+/* In the absence of signals, poll keyboard for a quit.
+ Called from #define QUIT pollquit() in xm-go32.h. */
void
-request_quit ()
+pollquit()
{
- quit_flag = 1;
+ if (kbhit ())
+ {
+ int k = getkey ();
+ if (k == 1) {
+ quit_flag = 1;
+ quit();
+ }
+ else if (k == 2) {
+ immediate_quit = 1;
+ quit ();
+ }
+ else
+ {
+ /* We just ignore it */
+ fprintf_unfiltered (gdb_stderr, "CTRL-A to quit, CTRL-B to quit harder\n");
+ }
+ }
+}
+
-#ifdef USG
- /* Restore the signal handler. */
- signal (SIGINT, request_quit);
#endif
+#if defined(__GO32__)||defined(WINGDB)
+void notice_quit()
+{
+ if (kbhit ())
+ {
+ int k = getkey ();
+ if (k == 1) {
+ quit_flag = 1;
+ }
+ else if (k == 2)
+ {
+ immediate_quit = 1;
+ }
+ else
+ {
+ fprintf_unfiltered (gdb_stderr, "CTRL-A to quit, CTRL-B to quit harder\n");
+ }
+ }
+}
+#else
+void notice_quit()
+{
+ /* Done by signals */
+}
+#endif
+/* Control C comes here */
- if (immediate_quit)
+void
+request_quit (signo)
+ int signo;
+{
+ quit_flag = 1;
+ /* Restore the signal handler. Harmless with BSD-style signals, needed
+ for System V-style signals. So just always do it, rather than worrying
+ about USG defines and stuff like that. */
+ signal (signo, request_quit);
+
+/* start-sanitize-gm */
+#ifdef GENERAL_MAGIC
+ target_kill ();
+#endif /* GENERAL_MAGIC */
+/* end-sanitize-gm */
+
+#ifdef REQUEST_QUIT
+ REQUEST_QUIT;
+#else
+ if (immediate_quit)
quit ();
+#endif
}
+
\f
-/* My replacement for the read system call.
- Used like `read' but keeps going if `read' returns too soon. */
+/* Memory management stuff (malloc friends). */
-int
-myread (desc, addr, len)
- int desc;
- char *addr;
- int len;
-{
- register int val;
- int orglen = len;
+#if defined (NO_MMALLOC)
- while (len > 0)
- {
- val = read (desc, addr, len);
- if (val < 0)
- return val;
- if (val == 0)
- return orglen - len;
- len -= val;
- addr += val;
- }
- return orglen;
-}
-\f
-/* Make a copy of the string at PTR with SIZE characters
- (and add a null character at the end in the copy).
- Uses malloc to get the space. Returns the address of the copy. */
+/* Make a substitute size_t for non-ANSI compilers. */
-char *
-savestring (ptr, size)
- char *ptr;
- int size;
+#ifdef _AIX
+#include <stddef.h>
+#else /* Not AIX */
+#ifndef __STDC__
+#ifndef size_t
+#define size_t unsigned int
+#endif
+#endif
+#endif /* Not AIX */
+
+PTR
+mmalloc (md, size)
+ PTR md;
+ size_t size;
{
- register char *p = (char *) xmalloc (size + 1);
- bcopy (ptr, p, size);
- p[size] = 0;
- return p;
+ return malloc (size);
}
-char *
-strsave (ptr)
- char *ptr;
+PTR
+mrealloc (md, ptr, size)
+ PTR md;
+ PTR ptr;
+ size_t size;
{
- return savestring (ptr, strlen (ptr));
+ if (ptr == 0) /* Guard against old realloc's */
+ return malloc (size);
+ else
+ return realloc (ptr, size);
}
-char *
-concat (s1, s2, s3)
- char *s1, *s2, *s3;
+void
+mfree (md, ptr)
+ PTR md;
+ PTR ptr;
{
- register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
- register char *val = (char *) xmalloc (len);
- strcpy (val, s1);
- strcat (val, s2);
- strcat (val, s3);
- return val;
+ free (ptr);
}
+#endif /* NO_MMALLOC */
+
+#if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
+
void
-print_spaces (n, file)
- register int n;
- register FILE *file;
+init_malloc (md)
+ PTR md;
{
- while (n-- > 0)
- fputc (' ', file);
}
-/* Ask user a y-or-n question and return 1 iff answer is yes.
- Takes three args which are given to printf to print the question.
- The first, a control string, should end in "? ".
- It should not say how to answer, because we do that. */
+#else /* have mmalloc and want corruption checking */
-/* VARARGS */
-int
-query (va_alist)
- va_dcl
+static void
+malloc_botch ()
{
- va_list args;
- char *ctlstr;
- register int answer;
- register int ans2;
+ fatal_dump_core ("Memory corruption");
+}
- /* Automatically answer "yes" if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return 1;
+/* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
+ by MD, to detect memory corruption. Note that MD may be NULL to specify
+ the default heap that grows via sbrk.
- while (1)
- {
- va_start (args);
- ctlstr = va_arg (args, char *);
- vfprintf (stdout, ctlstr, args);
- va_end (args);
- printf ("(y or n) ");
- fflush (stdout);
+ Note that for freshly created regions, we must call mmcheck prior to any
+ mallocs in the region. Otherwise, any region which was allocated prior to
+ installing the checking hooks, which is later reallocated or freed, will
+ fail the checks! The mmcheck function only allows initial hooks to be
+ installed before the first mmalloc. However, anytime after we have called
+ mmcheck the first time to install the checking hooks, we can call it again
+ to update the function pointer to the memory corruption handler.
+
+ Returns zero on failure, non-zero on success. */
+
+void
+init_malloc (md)
+ PTR md;
+{
+ if (!mmcheck (md, malloc_botch))
+ {
+ warning ("internal error: failed to install memory consistency checks");
+ }
+
+ mmtrace ();
+}
+
+#endif /* Have mmalloc and want corruption checking */
+
+/* Called when a memory allocation fails, with the number of bytes of
+ memory requested in SIZE. */
+
+NORETURN void
+nomem (size)
+ long size;
+{
+ if (size > 0)
+ {
+ fatal ("virtual memory exhausted: can't allocate %ld bytes.", size);
+ }
+ else
+ {
+ fatal ("virtual memory exhausted.");
+ }
+}
+
+/* Like mmalloc but get error if no storage available, and protect against
+ the caller wanting to allocate zero bytes. Whether to return NULL for
+ a zero byte request, or translate the request into a request for one
+ byte of zero'd storage, is a religious issue. */
+
+PTR
+xmmalloc (md, size)
+ PTR md;
+ long size;
+{
+ register PTR val;
+
+ if (size == 0)
+ {
+ val = NULL;
+ }
+ else if ((val = mmalloc (md, size)) == NULL)
+ {
+ nomem (size);
+ }
+ return (val);
+}
+
+/* Like mrealloc but get error if no storage available. */
+
+PTR
+xmrealloc (md, ptr, size)
+ PTR md;
+ PTR ptr;
+ long size;
+{
+ register PTR val;
+
+ if (ptr != NULL)
+ {
+ val = mrealloc (md, ptr, size);
+ }
+ else
+ {
+ val = mmalloc (md, size);
+ }
+ if (val == NULL)
+ {
+ nomem (size);
+ }
+ return (val);
+}
+
+/* Like malloc but get error if no storage available, and protect against
+ the caller wanting to allocate zero bytes. */
+
+PTR
+xmalloc (size)
+ long size;
+{
+ return (xmmalloc ((PTR) NULL, size));
+}
+
+/* Like mrealloc but get error if no storage available. */
+
+PTR
+xrealloc (ptr, size)
+ PTR ptr;
+ long size;
+{
+ return (xmrealloc ((PTR) NULL, ptr, size));
+}
+
+\f
+/* My replacement for the read system call.
+ Used like `read' but keeps going if `read' returns too soon. */
+
+int
+myread (desc, addr, len)
+ int desc;
+ char *addr;
+ int len;
+{
+ register int val;
+ int orglen = len;
+
+ while (len > 0)
+ {
+ val = read (desc, addr, len);
+ if (val < 0)
+ return val;
+ if (val == 0)
+ return orglen - len;
+ len -= val;
+ addr += val;
+ }
+ return orglen;
+}
+\f
+/* Make a copy of the string at PTR with SIZE characters
+ (and add a null character at the end in the copy).
+ Uses malloc to get the space. Returns the address of the copy. */
+
+char *
+savestring (ptr, size)
+ const char *ptr;
+ int size;
+{
+ register char *p = (char *) xmalloc (size + 1);
+ memcpy (p, ptr, size);
+ p[size] = 0;
+ return p;
+}
+
+char *
+msavestring (md, ptr, size)
+ PTR md;
+ const char *ptr;
+ int size;
+{
+ register char *p = (char *) xmmalloc (md, size + 1);
+ memcpy (p, ptr, size);
+ p[size] = 0;
+ return p;
+}
+
+/* The "const" is so it compiles under DGUX (which prototypes strsave
+ 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;
+{
+ return savestring (ptr, strlen (ptr));
+}
+
+char *
+mstrsave (md, ptr)
+ PTR md;
+ const char *ptr;
+{
+ return (msavestring (md, ptr, strlen (ptr)));
+}
+
+void
+print_spaces (n, file)
+ register int n;
+ register FILE *file;
+{
+ while (n-- > 0)
+ fputc (' ', file);
+}
+
+/* Print a host address. */
+
+void
+gdb_print_address (addr, stream)
+ PTR addr;
+ GDB_FILE *stream;
+{
+
+ /* We could use the %p conversion specifier to fprintf if we had any
+ way of knowing whether this host supports it. But the following
+ should work on the Alpha and on 32 bit machines. */
+
+ fprintf_filtered (stream, "0x%lx", (unsigned long)addr);
+}
+
+/* Ask user a y-or-n question and return 1 iff answer is yes.
+ Takes three args which are given to printf to print the question.
+ The first, a control string, should end in "? ".
+ It should not say how to answer, because we do that. */
+
+/* VARARGS */
+int
+#ifdef ANSI_PROTOTYPES
+query (char *ctlstr, ...)
+#else
+query (va_alist)
+ va_dcl
+#endif
+{
+ va_list args;
+ register int answer;
+ register int ans2;
+ int retval;
+
+#ifdef ANSI_PROTOTYPES
+ va_start (args, ctlstr);
+#else
+ char *ctlstr;
+ va_start (args);
+ ctlstr = va_arg (args, char *);
+#endif
+
+ if (query_hook)
+ {
+ return query_hook (ctlstr, args);
+ }
+
+ /* Automatically answer "yes" if input is not from a terminal. */
+ if (!input_from_terminal_p ())
+ return 1;
+#ifdef MPW
+ /* FIXME Automatically answer "yes" if called from MacGDB. */
+ if (mac_app)
+ return 1;
+#endif /* MPW */
+
+ while (1)
+ {
+ wrap_here (""); /* Flush any buffered output */
+ gdb_flush (gdb_stdout);
+
+ if (annotation_level > 1)
+ printf_filtered ("\n\032\032pre-query\n");
+
+ vfprintf_filtered (gdb_stdout, ctlstr, args);
+ printf_filtered ("(y or n) ");
+
+ if (annotation_level > 1)
+ printf_filtered ("\n\032\032query\n");
+
+#ifdef MPW
+ /* If not in MacGDB, move to a new line so the entered line doesn't
+ have a prompt on the front of it. */
+ if (!mac_app)
+ fputs_unfiltered ("\n", gdb_stdout);
+#endif /* MPW */
+
+ gdb_flush (gdb_stdout);
answer = fgetc (stdin);
clearerr (stdin); /* in case of C-d */
if (answer == EOF) /* C-d */
- return 1;
+ {
+ retval = 1;
+ break;
+ }
if (answer != '\n') /* Eat rest of input line, to EOF or newline */
do
{
if (answer >= 'a')
answer -= 040;
if (answer == 'Y')
- return 1;
+ {
+ retval = 1;
+ break;
+ }
if (answer == 'N')
- return 0;
- printf ("Please answer y or n.\n");
+ {
+ retval = 0;
+ break;
+ }
+ printf_filtered ("Please answer y or n.\n");
}
+
+ if (annotation_level > 1)
+ printf_filtered ("\n\032\032post-query\n");
+ return retval;
}
+
\f
/* Parse a C escape sequence. STRING_PTR points to a variable
containing a pointer to the string to parse. That pointer
switch (c)
{
case 'a':
- return '\a';
+ return 007; /* Bell (alert) char */
case 'b':
return '\b';
- case 'e':
+ case 'e': /* Escape character */
return 033;
case 'f':
return '\f';
}
}
\f
-/* Print the character CH on STREAM as part of the contents
- of a literal string whose delimiter is QUOTER. */
+/* Print the character C on STREAM as part of the contents of a literal
+ string whose delimiter is QUOTER. Note that this routine should only
+ be call for printing things which are independent of the language
+ of the program being debugged. */
void
-printchar (ch, stream, quoter)
- unsigned char ch;
+gdb_printchar (c, stream, quoter)
+ register int c;
FILE *stream;
int quoter;
{
- register int c = ch;
- if (c < 040 || (sevenbit_strings && c >= 0177))
+ c &= 0xFF; /* Avoid sign bit follies */
+
+ if ( c < 0x20 || /* Low control chars */
+ (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
+ (sevenbit_strings && c >= 0x80)) { /* high order bit set */
switch (c)
{
case '\n':
fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
break;
}
- else
- {
- if (c == '\\' || c == quoter)
- fputs_filtered ("\\", stream);
- fprintf_filtered (stream, "%c", c);
- }
+ } else {
+ if (c == '\\' || c == quoter)
+ fputs_filtered ("\\", stream);
+ fprintf_filtered (stream, "%c", c);
+ }
}
\f
/* Number of lines per page or UINT_MAX if paging is disabled. */
spit it out and forget about the wrap_here(). If we see another
wrap_here(), we spit it out and remember the newer one. If we see
the end of the line, we spit out a newline, the indent, and then
- the buffered output.
+ the buffered output. */
- wrap_column is the column number on the screen where wrap_buffer begins.
- When wrap_column is zero, wrapping is not in effect.
- wrap_buffer is malloc'd with chars_per_line+2 bytes.
- When wrap_buffer[0] is null, the buffer is empty.
- wrap_pointer points into it at the next character to fill.
- wrap_indent is the string that should be used as indentation if the
- wrap occurs. */
+/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
+ are waiting to be output (they have already been counted in chars_printed).
+ When wrap_buffer[0] is null, the buffer is empty. */
+static char *wrap_buffer;
-static char *wrap_buffer, *wrap_pointer, *wrap_indent;
-static int wrap_column;
+/* Pointer in wrap_buffer to the next character to fill. */
+static char *wrap_pointer;
-/* Get the number of lines to print with commands like "list".
- This is based on guessing how many long (i.e. more than chars_per_line
- characters) lines there will be. To be completely correct, "list"
- and friends should be rewritten to count characters and see where
- things are wrapping, but that would be a fair amount of work. */
-int
-lines_to_list ()
-{
- /* RMS didn't like the following algorithm. Let's set it back to
- 10 and see if anyone else complains. */
- /* return lines_per_page == UINT_MAX ? 10 : lines_per_page / 2; */
- return 10;
-}
+/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
+ is non-zero. */
+static char *wrap_indent;
+
+/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
+ is not in effect. */
+static int wrap_column;
/* ARGSUSED */
static void
wrap_pointer = wrap_buffer; /* Start it at the beginning */
}
+/* Wait, so the user can read what's on the screen. Prompt the user
+ to continue by pressing RETURN. */
+
static void
prompt_for_continue ()
{
+ char *ignore;
+ char cont_prompt[120];
+
+ if (annotation_level > 1)
+ printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
+
+ strcpy (cont_prompt,
+ "---Type <return> to continue, or q <return> to quit---");
+ if (annotation_level > 1)
+ strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
+
+ /* We must do this *before* we call gdb_readline, else it will eventually
+ call us -- thinking that we're trying to print beyond the end of the
+ screen. */
+ reinitialize_more_filter ();
+
immediate_quit++;
- gdb_readline ("---Type <return> to continue---", 0);
- chars_printed = lines_printed = 0;
+ /* On a real operating system, the user can quit with SIGINT.
+ But not on GO32.
+
+ 'q' is provided on all systems so users don't have to change habits
+ from system to system, and because telling them what to do in
+ the prompt is more user-friendly than expecting them to think of
+ SIGINT. */
+ /* Call readline, not gdb_readline, because GO32 readline handles control-C
+ whereas control-C to gdb_readline will cause the user to get dumped
+ out to DOS. */
+ ignore = readline (cont_prompt);
+
+ if (annotation_level > 1)
+ printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
+
+ if (ignore)
+ {
+ char *p = ignore;
+ while (*p == ' ' || *p == '\t')
+ ++p;
+ if (p[0] == 'q')
+ request_quit (SIGINT);
+ free (ignore);
+ }
immediate_quit--;
+
+ /* Now we have to do this again, so that GDB will know that it doesn't
+ need to save the ---Type <return>--- line at the top of the screen. */
+ reinitialize_more_filter ();
+
+ dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
}
/* Reinitialize filter; ie. tell it to reset to original values. */
/* Indicate that if the next sequence of characters overflows the line,
a newline should be inserted here rather than when it hits the end.
- If INDENT is nonzero, it is a string to be printed to indent the
+ If INDENT is non-null, it is a string to be printed to indent the
wrapped part on the next line. INDENT must remain accessible until
the next call to wrap_here() or until a newline is printed through
fputs_filtered().
If the line is already overfull, we immediately print a newline and
the indentation, and disable further wrapping.
- INDENT should not contain tabs, as that
- will mess up the char count on the next line. FIXME. */
+ If we don't know the width of lines, but we know the page height,
+ we must not wrap words, but should still keep track of newlines
+ that were explicitly printed.
+
+ INDENT should not contain tabs, as that will mess up the char count
+ on the next line. FIXME.
+
+ This routine is guaranteed to force out any output which has been
+ squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
+ used to force out output from the wrap_buffer. */
void
wrap_here(indent)
- char *indent;
+ char *indent;
{
+ /* This should have been allocated, but be paranoid anyway. */
+ if (!wrap_buffer)
+ abort ();
+
if (wrap_buffer[0])
{
*wrap_pointer = '\0';
- fputs (wrap_buffer, stdout);
+ fputs_unfiltered (wrap_buffer, gdb_stdout);
}
wrap_pointer = wrap_buffer;
wrap_buffer[0] = '\0';
- if (chars_printed >= chars_per_line)
+ if (chars_per_line == UINT_MAX) /* No line overflow checking */
+ {
+ wrap_column = 0;
+ }
+ else if (chars_printed >= chars_per_line)
{
puts_filtered ("\n");
- puts_filtered (indent);
+ if (indent != NULL)
+ puts_filtered (indent);
wrap_column = 0;
}
else
{
wrap_column = chars_printed;
- wrap_indent = indent;
+ if (indent == NULL)
+ wrap_indent = "";
+ else
+ wrap_indent = indent;
+ }
+}
+
+/* Ensure that whatever gets printed next, using the filtered output
+ commands, starts at the beginning of the line. I.E. if there is
+ any pending output for the current line, flush it and start a new
+ line. Otherwise do nothing. */
+
+void
+begin_line ()
+{
+ if (chars_printed > 0)
+ {
+ puts_filtered ("\n");
+ }
+}
+
+
+GDB_FILE *
+gdb_fopen (name, mode)
+ char * name;
+ char * mode;
+{
+ return fopen (name, mode);
+}
+
+void
+gdb_flush (stream)
+ FILE *stream;
+{
+ if (flush_hook)
+ {
+ flush_hook (stream);
+ return;
}
+
+ fflush (stream);
}
-/* Like fputs but pause after every screenful, and can wrap at points
- other than the final character of a line.
- Unlike fputs, fputs_filtered does not return a value.
+/* Like fputs but if FILTER is true, pause after every screenful.
+
+ Regardless of FILTER can wrap at points other than the final
+ character of a line.
+
+ Unlike fputs, fputs_maybe_filtered does not return a value.
It is OK for LINEBUFFER to be NULL, in which case just don't print
anything.
- Note that a longjmp to top level may occur in this routine
- (since prompt_for_continue may do so) so this routine should not be
- called when cleanups are not in place. */
+ Note that a longjmp to top level may occur in this routine (only if
+ FILTER is true) (since prompt_for_continue may do so) so this
+ routine should not be called when cleanups are not in place. */
-void
-fputs_filtered (linebuffer, stream)
- char *linebuffer;
+static void
+fputs_maybe_filtered (linebuffer, stream, filter)
+ const char *linebuffer;
FILE *stream;
+ int filter;
{
- char *lineptr;
+ const char *lineptr;
if (linebuffer == 0)
return;
-
+
/* Don't do any filtering if it is disabled. */
- if (stream != stdout
+ if (stream != gdb_stdout
|| (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
{
- fputs (linebuffer, stream);
+ fputs_unfiltered (linebuffer, stream);
return;
}
while (*lineptr)
{
/* Possible new page. */
- if (lines_printed >= lines_per_page - 1)
+ if (filter &&
+ (lines_printed >= lines_per_page - 1))
prompt_for_continue ();
while (*lineptr && *lineptr != '\n')
if (wrap_column)
*wrap_pointer++ = '\t';
else
- putc ('\t', stream);
+ fputc_unfiltered ('\t', stream);
/* Shifting right by 3 produces the number of tab stops
we have already passed, and then adding one and
shifting left 3 advances to the next tab stop. */
if (wrap_column)
*wrap_pointer++ = *lineptr;
else
- putc (*lineptr, stream);
+ fputc_unfiltered (*lineptr, stream);
chars_printed++;
lineptr++;
}
if chars_per_line is right, we probably just overflowed
anyway; if it's wrong, let us keep going. */
if (wrap_column)
- putc ('\n', stream);
+ fputc_unfiltered ('\n', stream);
/* Possible new page. */
if (lines_printed >= lines_per_page - 1)
/* Now output indentation and wrapped string */
if (wrap_column)
{
- if (wrap_indent)
- fputs (wrap_indent, stream);
- *wrap_pointer = '\0'; /* Null-terminate saved stuff */
- fputs (wrap_buffer, stream); /* and eject it */
+ fputs_unfiltered (wrap_indent, stream);
+ *wrap_pointer = '\0'; /* Null-terminate saved stuff */
+ fputs_unfiltered (wrap_buffer, stream); /* and eject it */
/* FIXME, this strlen is what prevents wrap_indent from
containing tabs. However, if we recurse to print it
and count its chars, we risk trouble if wrap_indent is
if (*lineptr == '\n')
{
chars_printed = 0;
- wrap_here (""); /* Spit out chars, cancel further wraps */
+ wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
lines_printed++;
- putc ('\n', stream);
+ fputc_unfiltered ('\n', stream);
lineptr++;
}
}
}
-
-/* fputs_demangled is a variant of fputs_filtered that
- demangles g++ names.*/
-
void
-fputs_demangled (linebuffer, stream, arg_mode)
- char *linebuffer;
+fputs_filtered (linebuffer, stream)
+ const char *linebuffer;
FILE *stream;
- int arg_mode;
{
-#ifdef __STDC__
- extern char *cplus_demangle (const char *, int);
-#else
- extern char *cplus_demangle ();
-#endif
-#define SYMBOL_MAX 1024
-
-#define SYMBOL_CHAR(c) (isascii(c) \
- && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
-
- char buf[SYMBOL_MAX+1];
-# define SLOP 5 /* How much room to leave in buf */
- char *p;
-
- if (linebuffer == NULL)
- return;
-
- /* If user wants to see raw output, no problem. */
- if (!demangle) {
- fputs_filtered (linebuffer, stream);
- }
+ fputs_maybe_filtered (linebuffer, stream, 1);
+}
- p = linebuffer;
+int
+putchar_unfiltered (c)
+ int c;
+{
+ char buf[2];
- while ( *p != (char) 0 ) {
- int i = 0;
+ buf[0] = c;
+ buf[1] = 0;
+ fputs_unfiltered (buf, gdb_stdout);
+ return c;
+}
- /* collect non-interesting characters into buf */
- while ( *p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-SLOP ) {
- buf[i++] = *p;
- p++;
- }
- if (i > 0) {
- /* output the non-interesting characters without demangling */
- buf[i] = (char) 0;
- fputs_filtered(buf, stream);
- i = 0; /* reset buf */
- }
+int
+fputc_unfiltered (c, stream)
+ int c;
+ FILE * stream;
+{
+ char buf[2];
- /* and now the interesting characters */
- while (i < SYMBOL_MAX
- && *p != (char) 0
- && SYMBOL_CHAR(*p)
- && i < (int)sizeof(buf) - SLOP) {
- buf[i++] = *p;
- p++;
- }
- buf[i] = (char) 0;
- if (i > 0) {
- char * result;
-
- if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) {
- fputs_filtered(result, stream);
- free(result);
- }
- else {
- fputs_filtered(buf, stream);
- }
- }
- }
+ buf[0] = c;
+ buf[1] = 0;
+ fputs_unfiltered (buf, stream);
+ return c;
}
+
/* Print a variable number of ARGS using format FORMAT. If this
information is going to put the amount written (since the last call
- to INITIALIZE_MORE_FILTER or the last page break) over the page size,
- print out a pause message and do a gdb_readline to get the users
- permision to continue.
+ to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
+ call prompt_for_continue to get the users permision to continue.
Unlike fprintf, this function does not return a value.
We implement three variants, vfprintf (takes a vararg list and stream),
fprintf (takes a stream to write on), and printf (the usual).
- Note that this routine has a restriction that the length of the
- final output line must be less than 255 characters *or* it must be
- less than twice the size of the format string. This is a very
- arbitrary restriction, but it is an internal restriction, so I'll
- put it in. This means that the %s format specifier is almost
- useless; unless the caller can GUARANTEE that the string is short
- enough, fputs_filtered should be used instead.
-
Note also that a longjmp to top level may occur in this routine
(since prompt_for_continue may do so) so this routine should not be
called when cleanups are not in place. */
-#if !defined(MISSING_VPRINTF) || defined (vsprintf)
-/* VARARGS */
+static void
+vfprintf_maybe_filtered (stream, format, args, filter)
+ FILE *stream;
+ char *format;
+ va_list args;
+ int filter;
+{
+ char *linebuffer;
+ struct cleanup *old_cleanups;
+
+ vasprintf (&linebuffer, format, args);
+ if (linebuffer == NULL)
+ {
+ fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
+ exit (1);
+ }
+ old_cleanups = make_cleanup (free, linebuffer);
+ fputs_maybe_filtered (linebuffer, stream, filter);
+ do_cleanups (old_cleanups);
+}
+
+
void
vfprintf_filtered (stream, format, args)
- va_list args;
-#else
-void fprintf_filtered (stream, format, arg1, arg2, arg3, arg4, arg5, arg6)
-#endif
FILE *stream;
- char *format;
+ const char *format;
+ va_list args;
{
- static char *linebuffer = (char *) 0;
- static int line_size;
- int format_length;
+ vfprintf_maybe_filtered (stream, format, args, 1);
+}
- format_length = strlen (format);
+void
+vfprintf_unfiltered (stream, format, args)
+ FILE *stream;
+ const char *format;
+ va_list args;
+{
+ char *linebuffer;
+ struct cleanup *old_cleanups;
- /* Allocated linebuffer for the first time. */
- if (!linebuffer)
+ vasprintf (&linebuffer, format, args);
+ if (linebuffer == NULL)
{
- linebuffer = (char *) xmalloc (255);
- line_size = 255;
+ fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
+ exit (1);
}
+ old_cleanups = make_cleanup (free, linebuffer);
+ fputs_unfiltered (linebuffer, stream);
+ do_cleanups (old_cleanups);
+}
- /* Reallocate buffer to a larger size if this is necessary. */
- if (format_length * 2 > line_size)
- {
- line_size = format_length * 2;
+void
+vprintf_filtered (format, args)
+ const char *format;
+ va_list args;
+{
+ vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
+}
- /* You don't have to copy. */
- free (linebuffer);
- linebuffer = (char *) xmalloc (line_size);
- }
+void
+vprintf_unfiltered (format, args)
+ const char *format;
+ va_list args;
+{
+ vfprintf_unfiltered (gdb_stdout, format, args);
+}
+/* VARARGS */
+void
+#ifdef ANSI_PROTOTYPES
+fprintf_filtered (FILE *stream, const char *format, ...)
+#else
+fprintf_filtered (va_alist)
+ va_dcl
+#endif
+{
+ va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ FILE *stream;
+ char *format;
- /* This won't blow up if the restrictions described above are
- followed. */
-#if !defined(MISSING_VPRINTF) || defined (vsprintf)
- (void) vsprintf (linebuffer, format, args);
+ va_start (args);
+ stream = va_arg (args, FILE *);
+ format = va_arg (args, char *);
+#endif
+ vfprintf_filtered (stream, format, args);
+ va_end (args);
+}
+
+/* VARARGS */
+void
+#ifdef ANSI_PROTOTYPES
+fprintf_unfiltered (FILE *stream, const char *format, ...)
#else
- (void) sprintf (linebuffer, format, arg1, arg2, arg3, arg4, arg5, arg6);
+fprintf_unfiltered (va_alist)
+ va_dcl
#endif
+{
+ va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ FILE *stream;
+ char *format;
- fputs_filtered (linebuffer, stream);
+ va_start (args);
+ stream = va_arg (args, FILE *);
+ format = va_arg (args, char *);
+#endif
+ vfprintf_unfiltered (stream, format, args);
+ va_end (args);
}
-#if !defined(MISSING_VPRINTF) || defined (vsprintf)
+/* Like fprintf_filtered, but prints its result indented.
+ Called as fprintfi_filtered (spaces, stream, format, ...); */
+
/* VARARGS */
void
-fprintf_filtered (va_alist)
+#ifdef ANSI_PROTOTYPES
+fprintfi_filtered (int spaces, FILE *stream, const char *format, ...)
+#else
+fprintfi_filtered (va_alist)
va_dcl
+#endif
{
va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ int spaces;
FILE *stream;
char *format;
va_start (args);
+ spaces = va_arg (args, int);
stream = va_arg (args, FILE *);
format = va_arg (args, char *);
+#endif
+ print_spaces_filtered (spaces, stream);
- /* This won't blow up if the restrictions described above are
- followed. */
- (void) vfprintf_filtered (stream, format, args);
+ vfprintf_filtered (stream, format, args);
va_end (args);
}
+
/* VARARGS */
void
+#ifdef ANSI_PROTOTYPES
+printf_filtered (const char *format, ...)
+#else
printf_filtered (va_alist)
va_dcl
+#endif
{
va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
char *format;
va_start (args);
format = va_arg (args, char *);
-
- (void) vfprintf_filtered (stdout, format, args);
+#endif
+ vfprintf_filtered (gdb_stdout, format, args);
va_end (args);
}
-#else
+
+
+/* VARARGS */
void
-printf_filtered (format, arg1, arg2, arg3, arg4, arg5, arg6)
- char *format;
- int arg1, arg2, arg3, arg4, arg5, arg6;
+#ifdef ANSI_PROTOTYPES
+printf_unfiltered (const char *format, ...)
+#else
+printf_unfiltered (va_alist)
+ va_dcl
+#endif
{
- fprintf_filtered (stdout, format, arg1, arg2, arg3, arg4, arg5, arg6);
+ va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ char *format;
+
+ va_start (args);
+ format = va_arg (args, char *);
+#endif
+ vfprintf_unfiltered (gdb_stdout, format, args);
+ va_end (args);
}
+
+/* Like printf_filtered, but prints it's result indented.
+ Called as printfi_filtered (spaces, format, ...); */
+
+/* VARARGS */
+void
+#ifdef ANSI_PROTOTYPES
+printfi_filtered (int spaces, const char *format, ...)
+#else
+printfi_filtered (va_alist)
+ va_dcl
#endif
+{
+ va_list args;
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ int spaces;
+ char *format;
-/* Easy */
+ va_start (args);
+ spaces = va_arg (args, int);
+ format = va_arg (args, char *);
+#endif
+ print_spaces_filtered (spaces, gdb_stdout);
+ vfprintf_filtered (gdb_stdout, format, args);
+ va_end (args);
+}
+
+/* Easy -- but watch out!
+
+ This routine is *not* a replacement for puts()! puts() appends a newline.
+ This one doesn't, and had better not! */
void
puts_filtered (string)
- char *string;
+ const char *string;
{
- fputs_filtered (string, stdout);
+ fputs_filtered (string, gdb_stdout);
+}
+
+void
+puts_unfiltered (string)
+ const char *string;
+{
+ fputs_unfiltered (string, gdb_stdout);
}
/* Return a pointer to N spaces and a null. The pointer is good
{
if (spaces)
free (spaces);
- spaces = malloc (n+1);
+ spaces = (char *) xmalloc (n+1);
for (t = spaces+n; t != spaces;)
*--t = ' ';
spaces[n] = '\0';
}
\f
/* C++ demangler stuff. */
-char *cplus_demangle ();
-/* Print NAME on STREAM, demangling if necessary. */
+/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
+ LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
+ If the name is not mangled, or the language for the name is unknown, or
+ demangling is off, the name is printed in its "raw" form. */
+
void
-fprint_symbol (stream, name)
+fprintf_symbol_filtered (stream, name, lang, arg_mode)
FILE *stream;
char *name;
+ enum language lang;
+ int arg_mode;
{
char *demangled;
- if ((!demangle) || NULL == (demangled = cplus_demangle (name, 1)))
- fputs_filtered (name, stream);
- else
+
+ if (name != NULL)
{
- fputs_filtered (demangled, stream);
- free (demangled);
+ /* If user wants to see raw output, no problem. */
+ if (!demangle)
+ {
+ fputs_filtered (name, stream);
+ }
+ else
+ {
+ switch (lang)
+ {
+ case language_cplus:
+ demangled = cplus_demangle (name, arg_mode);
+ break;
+ case language_chill:
+ demangled = chill_demangle (name);
+ break;
+ default:
+ demangled = NULL;
+ break;
+ }
+ fputs_filtered (demangled ? demangled : name, stream);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ }
+ }
}
}
-\f
-#if !defined (USG_UTILS)
-#define USG_UTILS defined (USG)
-#endif
-
-#if USG_UTILS
-bcopy (from, to, count)
-char *from, *to;
-{
- memcpy (to, from, count);
-}
-
-bcmp (from, to, count)
-{
- return (memcmp (to, from, count));
-}
-
-bzero (to, count)
-char *to;
-{
- while (count--)
- *to++ = 0;
-}
-
-getwd (buf)
-char *buf;
-{
- getcwd (buf, MAXPATHLEN);
-}
-
-char *
-index (s, c)
- char *s;
-{
- char *strchr ();
- return strchr (s, c);
-}
-
-char *
-rindex (s, c)
- char *s;
-{
- char *strrchr ();
- return strrchr (s, c);
-}
-#endif /* USG_UTILS. */
-
-#if !defined (QUEUE_MISSING)
-#define QUEUE_MISSING defined (USG)
-#endif
-#if QUEUE_MISSING
-/* Queue routines */
+/* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
+ differences in whitespace. Returns 0 if they match, non-zero if they
+ don't (slightly different than strcmp()'s range of return values).
+
+ As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
+ This "feature" is useful when searching for matching C++ function names
+ (such as if the user types 'break FOO', where FOO is a mangled C++
+ function). */
-struct queue {
- struct queue *forw;
- struct queue *back;
-};
-
-insque (item, after)
-struct queue *item;
-struct queue *after;
+int
+strcmp_iw (string1, string2)
+ const char *string1;
+ const char *string2;
{
- item->forw = after->forw;
- after->forw->back = item;
-
- item->back = after;
- after->forw = item;
+ while ((*string1 != '\0') && (*string2 != '\0'))
+ {
+ while (isspace (*string1))
+ {
+ string1++;
+ }
+ while (isspace (*string2))
+ {
+ string2++;
+ }
+ if (*string1 != *string2)
+ {
+ break;
+ }
+ if (*string1 != '\0')
+ {
+ string1++;
+ string2++;
+ }
+ }
+ return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
}
-remque (item)
-struct queue *item;
-{
- item->forw->back = item->back;
- item->back->forw = item->forw;
-}
-#endif /* QUEUE_MISSING */
-\f
-/* Simple implementation of strstr, since some implementations lack it. */
-char *
-strstr (in, find)
- const char *in, *find;
-{
- register const char *p = in - 1;
-
- while (0 != (p = strchr (p+1, *find))) {
- if (strcmp (p, find))
- return (char *)p;
- }
- return 0;
-}
\f
void
-_initialize_utils ()
+initialize_utils ()
{
struct cmd_list_element *c;
"Set number of characters gdb thinks are in a line.",
&setlist);
add_show_from_set (c, &showlist);
- c->function = set_width_command;
+ c->function.sfunc = set_width_command;
add_show_from_set
(add_set_cmd ("height", class_support,
/* These defaults will be used if we are unable to get the correct
values from termcap. */
+#if defined(__GO32__) || defined(__WIN32__)
+ lines_per_page = ScreenRows();
+ chars_per_line = ScreenCols();
+#else
lines_per_page = 24;
chars_per_line = 80;
+
+#ifndef MPW
+ /* No termcap under MPW, although might be cool to do something
+ by looking at worksheet or console window sizes. */
/* Initialize the screen height and width from termcap. */
{
char *termtype = getenv ("TERM");
}
}
}
+#endif /* MPW */
+
+#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
+
+ /* If there is a better way to determine the window size, use it. */
+ SIGWINCH_HANDLER ();
+#endif
+#endif
+ /* If the output is not a terminal, don't paginate it. */
+ if (!ISATTY (gdb_stdout))
+ lines_per_page = UINT_MAX;
set_width_command ((char *)NULL, 0, c);
&setprintlist),
&showprintlist);
}
+
+/* Machine specific function to handle SIGWINCH signal. */
+
+#ifdef SIGWINCH_HANDLER_BODY
+ SIGWINCH_HANDLER_BODY
+#endif
+\f
+#ifdef HAVE_LONG_DOUBLE
+/* Support for converting target fp numbers into host long double format. */
+
+/* XXX - This code should really be in libiberty/floatformat.c, however
+ configuration issues with libiberty made this very difficult to do in the
+ available time. */
+
+#include "floatformat.h"
+#include <math.h> /* ldexp */
+
+/* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
+ going to bother with trying to muck around with whether it is defined in
+ 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));
+
+/* 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;
+{
+ unsigned long result;
+ unsigned int cur_byte;
+ int cur_bitshift;
+
+ /* Start at the least significant part of the field. */
+ cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
+ cur_bitshift =
+ ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
+ result = *(data + cur_byte) >> (-cur_bitshift);
+ cur_bitshift += FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ ++cur_byte;
+ else
+ --cur_byte;
+
+ /* Move towards the most significant part of the field. */
+ while (cur_bitshift < len)
+ {
+ if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
+ /* This is the last byte; zero out the bits which are not part of
+ this field. */
+ result |=
+ (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
+ << cur_bitshift;
+ else
+ result |= *(data + cur_byte) << cur_bitshift;
+ cur_bitshift += FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ ++cur_byte;
+ else
+ --cur_byte;
+ }
+ return result;
+}
+
+/* Convert from FMT to a long double.
+ FROM is the address of the extended float.
+ Store the long double in *TO. */
+
+void
+floatformat_to_long_double (fmt, from, to)
+ const struct floatformat *fmt;
+ char *from;
+ long double *to;
+{
+ unsigned char *ufrom = (unsigned char *)from;
+ long double dto;
+ long exponent;
+ unsigned long mant;
+ unsigned int mant_bits, mant_off;
+ int mant_bits_left;
+ int special_exponent; /* It's a NaN, denorm or zero */
+
+ exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
+ fmt->exp_start, fmt->exp_len);
+ /* Note that if exponent indicates a NaN, we can't really do anything useful
+ (not knowing if the host has NaN's, or how to build one). So it will
+ end up as an infinity or something close; that is OK. */
+
+ mant_bits_left = fmt->man_len;
+ mant_off = fmt->man_start;
+ dto = 0.0;
+
+ special_exponent = exponent == 0 || exponent == fmt->exp_nan;
+
+/* Don't bias zero's, denorms or NaNs. */
+ if (!special_exponent)
+ exponent -= fmt->exp_bias;
+
+ /* Build the result algebraically. Might go infinite, underflow, etc;
+ who cares. */
+
+/* If this format uses a hidden bit, explicitly add it in now. Otherwise,
+ increment the exponent by one to account for the integer bit. */
+
+ if (!special_exponent)
+ if (fmt->intbit == floatformat_intbit_no)
+ dto = ldexp (1.0, exponent);
+ else
+ exponent++;
+
+ while (mant_bits_left > 0)
+ {
+ mant_bits = min (mant_bits_left, 32);
+
+ mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
+ mant_off, mant_bits);
+
+ dto += ldexp ((double)mant, exponent - mant_bits);
+ exponent -= mant_bits;
+ mant_off += mant_bits;
+ mant_bits_left -= mant_bits;
+ }
+
+ /* Negate it if negative. */
+ if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
+ dto = -dto;
+ *to = dto;
+}
+\f
+static void put_field PARAMS ((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;
+{
+ unsigned int cur_byte;
+ int cur_bitshift;
+
+ /* Start at the least significant part of the field. */
+ cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
+ cur_bitshift =
+ ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
+ *(data + cur_byte) &=
+ ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
+ *(data + cur_byte) |=
+ (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
+ cur_bitshift += FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ ++cur_byte;
+ else
+ --cur_byte;
+
+ /* Move towards the most significant part of the field. */
+ while (cur_bitshift < len)
+ {
+ if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
+ {
+ /* This is the last byte. */
+ *(data + cur_byte) &=
+ ~((1 << (len - cur_bitshift)) - 1);
+ *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
+ }
+ else
+ *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
+ & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
+ cur_bitshift += FLOATFORMAT_CHAR_BIT;
+ if (order == floatformat_little)
+ ++cur_byte;
+ else
+ --cur_byte;
+ }
+}
+
+/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
+ 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 (value, eptr)
+ long double value;
+ int *eptr;
+{
+ long double tmp;
+ int exp;
+
+ /* Unfortunately, there are no portable functions for extracting the exponent
+ of a long double, so we have to do it iteratively by multiplying or dividing
+ by two until the fraction is between 0.5 and 1.0. */
+
+ if (value < 0.0l)
+ value = -value;
+
+ tmp = 1.0l;
+ exp = 0;
+
+ if (value >= tmp) /* Value >= 1.0 */
+ while (value >= tmp)
+ {
+ tmp *= 2.0l;
+ exp++;
+ }
+ else if (value != 0.0l) /* Value < 1.0 and > 0.0 */
+ {
+ while (value < tmp)
+ {
+ tmp /= 2.0l;
+ exp--;
+ }
+ tmp *= 2.0l;
+ exp++;
+ }
+
+ *eptr = exp;
+ return value/tmp;
+}
+
+/* The converse: convert the long double *FROM to an extended float
+ and store where TO points. Neither FROM nor TO have any alignment
+ restrictions. */
+
+void
+floatformat_from_long_double (fmt, from, to)
+ CONST struct floatformat *fmt;
+ long double *from;
+ char *to;
+{
+ long double dfrom;
+ int exponent;
+ long double mant;
+ unsigned int mant_bits, mant_off;
+ int mant_bits_left;
+ unsigned char *uto = (unsigned char *)to;
+
+ memcpy (&dfrom, from, sizeof (dfrom));
+ memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
+ if (dfrom == 0)
+ return; /* Result is zero */
+ if (dfrom != dfrom)
+ {
+ /* From is NaN */
+ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+ fmt->exp_len, fmt->exp_nan);
+ /* Be sure it's not infinity, but NaN value is irrel */
+ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
+ 32, 1);
+ return;
+ }
+
+ /* If negative, set the sign bit. */
+ if (dfrom < 0)
+ {
+ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
+ dfrom = -dfrom;
+ }
+
+ /* How to tell an infinity from an ordinary number? FIXME-someday */
+
+ mant = ldfrexp (dfrom, &exponent);
+ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
+ exponent + fmt->exp_bias - 1);
+
+ mant_bits_left = fmt->man_len;
+ mant_off = fmt->man_start;
+ while (mant_bits_left > 0)
+ {
+ unsigned long mant_long;
+ mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
+
+ mant *= 4294967296.0;
+ mant_long = (unsigned long)mant;
+ mant -= mant_long;
+
+ /* If the integer bit is implicit, then we need to discard it.
+ If we are discarding a zero, we should be (but are not) creating
+ a denormalized number which means adjusting the exponent
+ (I think). */
+ if (mant_bits_left == fmt->man_len
+ && fmt->intbit == floatformat_intbit_no)
+ {
+ mant_long &= 0x7fffffff;
+ mant_bits -= 1;
+ }
+ else if (mant_bits < 32)
+ {
+ /* The bits we want are in the most significant MANT_BITS bits of
+ mant_long. Move them to the least significant. */
+ mant_long >>= 32 - mant_bits;
+ }
+
+ put_field (uto, fmt->byteorder, fmt->totalsize,
+ mant_off, mant_bits, mant_long);
+ mant_off += mant_bits;
+ mant_bits_left -= mant_bits;
+ }
+}
+
+#endif /* HAVE_LONG_DOUBLE */
projects / deliverable / binutils-gdb.git / blobdiff