/* General utility routines for GDB, the GNU debugger.
- Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
+ Copyright 1986, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
This file is part of GDB.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
+#include "defs.h"
+#if !defined(__GO32__)
#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
#include <varargs.h>
#include <ctype.h>
#include <string.h>
+
+#include "signals.h"
+#include "gdbcmd.h"
+#include "terminal.h"
#include "bfd.h"
#include "target.h"
+#include "demangle.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();
+/* Prototypes for local functions */
-/* 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
+#if !defined (NO_MALLOC_CHECK)
-#ifdef MISSING_VPRINTF
-#ifdef __GNU_LIBRARY
-#undef MISSING_VPRINTF
-#else /* !__GNU_LIBRARY */
+static void
+malloc_botch PARAMS ((void));
-#ifndef vfprintf
-#define vfprintf(file, format, ap) _doprnt (format, ap, file)
-#endif /* vfprintf */
+#endif /* NO_MALLOC_CHECK */
-#ifndef vprintf
-/* Can't #define it since printcmd.c needs it */
-void
-vprintf (format, ap)
- char *format;
- va_list ap;
-{
- vfprintf (stdout, format, ap);
-}
-#endif /* vprintf */
+static void
+fatal_dump_core (); /* Can't prototype with <varargs.h> usage... */
+
+static void
+prompt_for_continue PARAMS ((void));
+
+static void
+set_width_command PARAMS ((char *, int, struct cmd_list_element *));
-#endif /* GNU_LIBRARY */
-#endif /* MISSING_VPRINTF */
+static void
+vfprintf_filtered PARAMS ((FILE *, char *, va_list));
-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. */
/* String to be printed before error messages, if any. */
char *error_pre_print;
+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));
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
+/* Provide a hook for modules wishing to print their own warning messages
+ to set up the terminal state in a compatible way, without them having
+ to import all the target_<...> macros. */
+
+void
+warning_setup ()
+{
+ target_terminal_ours ();
+ wrap_here(""); /* Force out any buffered output */
+ fflush (stdout);
+}
+
+/* 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
+warning (va_alist)
+ va_dcl
+{
+ va_list args;
+ char *string;
+
+ va_start (args);
+ target_terminal_ours ();
+ wrap_here(""); /* Force out any buffered output */
+ fflush (stdout);
+ if (warning_pre_print)
+ fprintf (stderr, warning_pre_print);
+ string = va_arg (args, char *);
+ vfprintf (stderr, string, args);
+ fprintf (stderr, "\n");
+ va_end (args);
+}
+
/* 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. */
/* VARARGS */
-void
+NORETURN void
error (va_alist)
va_dcl
{
va_start (args);
target_terminal_ours ();
+ wrap_here(""); /* Force out any buffered output */
fflush (stdout);
if (error_pre_print)
- fprintf (stderr, error_pre_print);
+ fprintf_filtered (stderr, error_pre_print);
string = va_arg (args, char *);
- vfprintf (stderr, string, args);
- fprintf (stderr, "\n");
+ vfprintf_filtered (stderr, string, args);
+ fprintf_filtered (stderr, "\n");
va_end (args);
return_to_top_level ();
}
/* 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
fatal (va_alist)
va_dcl
{
va_start (args);
string = va_arg (args, char *);
- fprintf (stderr, "gdb: ");
+ fprintf (stderr, "\ngdb: ");
vfprintf (stderr, string, args);
fprintf (stderr, "\n");
va_end (args);
/* Print an error message and exit, dumping core.
The arguments are printed a la printf (). */
+
/* VARARGS */
-void
+static void
fatal_dump_core (va_alist)
va_dcl
{
string = va_arg (args, char *);
/* "internal error" is always correct, since GDB should never dump
core, no matter what the input. */
- fprintf (stderr, "gdb internal error: ");
+ fprintf (stderr, "\ngdb internal error: ");
vfprintf (stderr, string, args);
fprintf (stderr, "\n");
va_end (args);
/* 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");
-}
+/* The strerror() function can return NULL for errno values that are
+ out of range. Provide a "safe" version that always returns a
+ printable string. */
-void
-init_malloc ()
-{
- mcheck (malloc_botch);
- mtrace ();
-}
-#endif /* Have mcheck(). */
-
-/* Like malloc but get error if no storage available. */
-
-#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, ": ");
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);
+ fprintf (stderr, "%s.\n", combined);
}
/* Control C eventually causes this to be called, at a convenient time. */
{
target_terminal_ours ();
wrap_here ((char *)0); /* Force out any pending output */
+#if !defined(__GO32__)
#ifdef HAVE_TERMIO
ioctl (fileno (stdout), TCFLSH, 1);
#else /* not HAVE_TERMIO */
#else
error ("Quit (expect signal %d when inferior is resumed)", SIGINT);
#endif /* TIOCGPGRP */
+#endif
}
/* Control C comes here */
void
-request_quit ()
+request_quit (signo)
+ int signo;
{
quit_flag = 1;
#ifdef USG
/* Restore the signal handler. */
- signal (SIGINT, request_quit);
+ signal (signo, request_quit);
#endif
if (immediate_quit)
quit ();
}
+
+\f
+/* Memory management stuff (malloc friends). */
+
+#if defined (NO_MMALLOC)
+
+PTR
+mmalloc (md, size)
+ PTR md;
+ long size;
+{
+ return (malloc (size));
+}
+
+PTR
+mrealloc (md, ptr, size)
+ PTR md;
+ PTR ptr;
+ long size;
+{
+ if (ptr == 0) /* Guard against old realloc's */
+ return malloc (size);
+ else
+ return realloc (ptr, size);
+}
+
+void
+mfree (md, ptr)
+ PTR md;
+ PTR ptr;
+{
+ free (ptr);
+}
+
+#endif /* NO_MMALLOC */
+
+#if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
+
+void
+init_malloc (md)
+ PTR md;
+{
+}
+
+#else /* have mmalloc and want corruption checking */
+
+static void
+malloc_botch ()
+{
+ fatal_dump_core ("Memory corruption");
+}
+
+/* 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.
+
+ 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 ((void *) NULL, size));
+}
+
+/* Like mrealloc but get error if no storage available. */
+
+PTR
+xrealloc (ptr, size)
+ PTR ptr;
+ long size;
+{
+ return (xmrealloc ((void *) NULL, ptr, size));
+}
+
\f
/* My replacement for the read system call.
Used like `read' but keeps going if `read' returns too soon. */
char *
savestring (ptr, size)
- char *ptr;
+ const char *ptr;
int size;
{
register char *p = (char *) xmalloc (size + 1);
- bcopy (ptr, p, size);
+ memcpy (p, ptr, size);
+ p[size] = 0;
+ return p;
+}
+
+char *
+msavestring (md, ptr, size)
+ void *md;
+ const char *ptr;
+ int size;
+{
+ register char *p = (char *) xmmalloc (md, size + 1);
+ memcpy (p, ptr, size);
p[size] = 0;
return p;
}
}
char *
-concat (s1, s2, s3)
- char *s1, *s2, *s3;
+mstrsave (md, ptr)
+ void *md;
+ const char *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;
+ return (msavestring (md, ptr, strlen (ptr)));
}
void
while (1)
{
+ wrap_here (""); /* Flush any buffered output */
+ fflush (stdout);
va_start (args);
ctlstr = va_arg (args, char *);
- vfprintf (stdout, ctlstr, args);
+ vfprintf_filtered (stdout, ctlstr, args);
va_end (args);
- printf ("(y or n) ");
+ printf_filtered ("(y or n) ");
fflush (stdout);
answer = fgetc (stdin);
clearerr (stdin); /* in case of C-d */
return 1;
if (answer == 'N')
return 0;
- printf ("Please answer y or n.\n");
+ printf_filtered ("Please answer y or n.\n");
}
}
+
\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
+/* Print the character C on STREAM as part of the contents
of a literal string whose delimiter is QUOTER. */
void
-printchar (ch, stream, quoter)
- unsigned char ch;
+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. */
static char *wrap_buffer, *wrap_pointer, *wrap_indent;
static int wrap_column;
-/* 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;
-}
-
/* ARGSUSED */
static void
set_width_command (args, from_tty, c)
If the line is already overfull, we immediately print a newline and
the indentation, and disable further wrapping.
+ 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. */
}
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);
void
fputs_filtered (linebuffer, stream)
- char *linebuffer;
+ const char *linebuffer;
FILE *stream;
{
- char *lineptr;
+ const char *lineptr;
if (linebuffer == 0)
return;
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 */
+# define DMSLOP 5 /* How much room to leave in buf */
char *p;
if (linebuffer == NULL)
int i = 0;
/* collect non-interesting characters into buf */
- while ( *p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-SLOP ) {
+ while (*p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-DMSLOP ) {
buf[i++] = *p;
p++;
}
while (i < SYMBOL_MAX
&& *p != (char) 0
&& SYMBOL_CHAR(*p)
- && i < (int)sizeof(buf) - SLOP) {
+ && i < (int)sizeof(buf) - DMSLOP) {
buf[i++] = *p;
p++;
}
(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 */
-void
+static 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;
+ va_list args;
{
static char *linebuffer = (char *) 0;
static int line_size;
/* This won't blow up if the restrictions described above are
followed. */
-#if !defined(MISSING_VPRINTF) || defined (vsprintf)
- (void) vsprintf (linebuffer, format, args);
-#else
- (void) sprintf (linebuffer, format, arg1, arg2, arg3, arg4, arg5, arg6);
-#endif
+ vsprintf (linebuffer, format, args);
fputs_filtered (linebuffer, stream);
}
-#if !defined(MISSING_VPRINTF) || defined (vsprintf)
/* VARARGS */
void
fprintf_filtered (va_alist)
/* 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);
+}
+
+/* Like fprintf_filtered, but prints it's result indent.
+ Called as fprintfi_filtered (spaces, format, arg1, arg2, ...); */
+
+/* VARARGS */
+void
+fprintfi_filtered (va_alist)
+ va_dcl
+{
+ va_list args;
+ int spaces;
+ FILE *stream;
+ char *format;
+
+ va_start (args);
+ spaces = va_arg (args, int);
+ stream = va_arg (args, FILE *);
+ format = va_arg (args, char *);
+ print_spaces_filtered (spaces, stream);
+
+ /* This won't blow up if the restrictions described above are
+ followed. */
+ vfprintf_filtered (stream, format, args);
va_end (args);
}
va_start (args);
format = va_arg (args, char *);
- (void) vfprintf_filtered (stdout, format, args);
+ vfprintf_filtered (stdout, format, args);
va_end (args);
}
-#else
+
+/* Like printf_filtered, but prints it's result indented.
+ Called as printfi_filtered (spaces, format, arg1, arg2, ...); */
+
+/* VARARGS */
void
-printf_filtered (format, arg1, arg2, arg3, arg4, arg5, arg6)
- char *format;
- int arg1, arg2, arg3, arg4, arg5, arg6;
+printfi_filtered (va_alist)
+ va_dcl
{
- fprintf_filtered (stdout, format, arg1, arg2, arg3, arg4, arg5, arg6);
+ va_list args;
+ int spaces;
+ char *format;
+
+ va_start (args);
+ spaces = va_arg (args, int);
+ format = va_arg (args, char *);
+ print_spaces_filtered (spaces, stdout);
+ vfprintf_filtered (stdout, format, args);
+ va_end (args);
}
-#endif
/* Easy */
{
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 ();
+
+/* Make a copy of a symbol, applying C++ demangling if demangling is enabled
+ and a demangled version exists. Note that the value returned from
+ cplus_demangle is already allocated in malloc'd memory. */
+
+char *
+strdup_demangled (name)
+ const char *name;
+{
+ char *demangled = NULL;
+
+ if (demangle)
+ {
+ demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI);
+ }
+ return ((demangled != NULL) ? demangled : strdup (name));
+}
+
/* Print NAME on STREAM, demangling if necessary. */
void
char *name;
{
char *demangled;
- if ((!demangle) || NULL == (demangled = cplus_demangle (name, 1)))
+ if ((!demangle)
+ || NULL == (demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI)))
fputs_filtered (name, stream);
else
{
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)
+/* 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 for demangle_and_match(), which is used
+ when searching for matching C++ function names (such as if the
+ user types 'break FOO', where FOO is a mangled C++ function). */
+
+static int
+strcmp_iw (string1, string2)
+ const char *string1;
+ const char *string2;
{
- return (memcmp (to, from, count));
+ 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');
}
-bzero (to, count)
-char *to;
-{
- while (count--)
- *to++ = 0;
-}
+/* Demangle NAME and compare the result with LOOKFOR, ignoring any differences
+ in whitespace.
+
+ If a match is found, returns a pointer to the demangled version of NAME
+ in malloc'd memory, which needs to be freed by the caller after use.
+ If a match is not found, returns NULL.
-getwd (buf)
-char *buf;
-{
- getcwd (buf, MAXPATHLEN);
-}
+ OPTIONS is a flags word that controls the demangling process and is just
+ passed on to the demangler.
-char *
-index (s, c)
- char *s;
-{
- char *strchr ();
- return strchr (s, c);
-}
+ When the caller sees a non-NULL result, it knows that NAME is the mangled
+ equivalent of LOOKFOR, and it can use either NAME, the "official demangled"
+ version of NAME (the return value) or the "unofficial demangled" version
+ of NAME (LOOKFOR, which it already knows). */
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 */
-
-struct queue {
- struct queue *forw;
- struct queue *back;
-};
-
-insque (item, after)
-struct queue *item;
-struct queue *after;
+demangle_and_match (name, lookfor, options)
+ const char *name;
+ const char *lookfor;
+ int options;
{
- item->forw = after->forw;
- after->forw->back = item;
+ char *demangled;
- item->back = after;
- after->forw = item;
+ if ((demangled = cplus_demangle (name, options)) != NULL)
+ {
+ if (strcmp_iw (demangled, lookfor) != 0)
+ {
+ free (demangled);
+ demangled = NULL;
+ }
+ }
+ return (demangled);
}
-remque (item)
-struct queue *item;
-{
- item->forw->back = item->back;
- item->back->forw = item->forw;
-}
-#endif /* QUEUE_MISSING */
-\f
-#ifndef HAVE_STRSTR
-/* Simple implementation of strstr, since some implementations lack it. */
-const 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 p;
- }
- return 0;
-}
-#endif /* do not HAVE_STRSTR */
\f
void
_initialize_utils ()
"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__)
+ lines_per_page = ScreenRows();
+ chars_per_line = ScreenCols();
+#else
lines_per_page = 24;
chars_per_line = 80;
/* Initialize the screen height and width from termcap. */
}
}
+#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 (stdout))
+ lines_per_page = UINT_MAX;
+
set_width_command ((char *)NULL, 0, c);
add_show_from_set
&setprintlist),
&showprintlist);
}
+
+/* Machine specific function to handle SIGWINCH signal. */
+
+#ifdef SIGWINCH_HANDLER_BODY
+ SIGWINCH_HANDLER_BODY
+#endif
projects / deliverable / binutils-gdb.git / blobdiff