Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
-
+#if !defined(__GO32__)
#include <sys/ioctl.h>
#include <sys/param.h>
#include <pwd.h>
+#endif
#include <varargs.h>
#include <ctype.h>
#include <string.h>
#include "terminal.h"
#include "bfd.h"
#include "target.h"
+#include "demangle.h"
+#include "expression.h"
+#include "language.h"
/* Prototypes for local functions */
-#if !defined (NO_MALLOC_CHECK)
+#if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
+#else
static void
malloc_botch PARAMS ((void));
-#endif /* NO_MALLOC_CHECK */
+#endif /* NO_MMALLOC, etc */
static void
fatal_dump_core (); /* Can't prototype with <varargs.h> usage... */
static void
set_width_command PARAMS ((char *, int, struct cmd_list_element *));
-static void
-vfprintf_filtered PARAMS ((FILE *, char *, va_list));
-
/* If this definition isn't overridden by the header files, assume
that isatty and fileno exist on this system. */
#ifndef ISATTY
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 ();
}
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 */
+#else
+ error ("Quit");
+#endif
+}
+
+
+#ifdef __GO32__
+
+/* In the absence of signals, poll keyboard for a quit.
+ Called from #define QUIT pollquit() in xm-go32.h. */
+
+void
+pollquit()
+{
+ if (kbhit ())
+ {
+ int k = getkey ();
+ if (k == 1)
+ quit_flag = 1;
+ else if (k == 2)
+ immediate_quit = 1;
+ quit ();
+ }
}
+#endif
+
/* Control C comes here */
void
warning ("internal error: failed to install memory consistency checks");
}
- (void) mmtrace ();
+ mmtrace ();
}
#endif /* Have mmalloc and want corruption checking */
int size;
{
register char *p = (char *) xmalloc (size + 1);
- bcopy (ptr, p, size);
+ memcpy (p, ptr, size);
p[size] = 0;
return p;
}
int size;
{
register char *p = (char *) xmmalloc (md, size + 1);
- bcopy (ptr, p, size);
+ memcpy (p, ptr, size);
p[size] = 0;
return p;
}
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
-/* Print the character C 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 (c, stream, quoter)
+gdb_printchar (c, stream, quoter)
register int c;
FILE *stream;
int quoter;
{
- 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':
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;
+ /* 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++;
ignore = gdb_readline ("---Type <return> to continue---");
if (ignore)
free (ignore);
- chars_printed = lines_printed = 0;
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. */
}
}
}
+/* 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");
+ }
+}
+
/* 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.
}
}
-
-/* fputs_demangled is a variant of fputs_filtered that
- demangles g++ names.*/
-
-void
-fputs_demangled (linebuffer, stream, arg_mode)
- char *linebuffer;
- FILE *stream;
- int arg_mode;
-{
-#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);
- return;
- }
-
- p = linebuffer;
-
- while ( *p != (char) 0 ) {
- int i = 0;
-
- /* 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 */
- }
-
- /* 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);
- }
- }
- }
-}
-
/* 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,
+ to REINITIALIZE_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.
(since prompt_for_continue may do so) so this routine should not be
called when cleanups are not in place. */
-static void
+#define MIN_LINEBUF 255
+
+void
vfprintf_filtered (stream, format, args)
FILE *stream;
char *format;
va_list args;
{
- static char *linebuffer = (char *) 0;
- static int line_size;
+ char line_buf[MIN_LINEBUF+10];
+ char *linebuffer = line_buf;
int format_length;
format_length = strlen (format);
- /* Allocated linebuffer for the first time. */
- if (!linebuffer)
- {
- linebuffer = (char *) xmalloc (255);
- line_size = 255;
- }
-
/* Reallocate buffer to a larger size if this is necessary. */
- if (format_length * 2 > line_size)
+ if (format_length * 2 > MIN_LINEBUF)
{
- line_size = format_length * 2;
-
- /* You don't have to copy. */
- free (linebuffer);
- linebuffer = (char *) xmalloc (line_size);
+ linebuffer = alloca (10 + format_length * 2);
}
-
/* This won't blow up if the restrictions described above are
followed. */
- (void) vsprintf (linebuffer, format, args);
+ vsprintf (linebuffer, format, args);
fputs_filtered (linebuffer, stream);
}
+void
+vprintf_filtered (format, args)
+ char *format;
+ va_list args;
+{
+ vfprintf_filtered (stdout, format, args);
+}
+
/* VARARGS */
void
fprintf_filtered (va_alist)
va_dcl
{
+ va_list args;
FILE *stream;
char *format;
+
+ va_start (args);
+ stream = va_arg (args, FILE *);
+ format = va_arg (args, char *);
+
+ /* This won't blow up if the restrictions described above are
+ followed. */
+ 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. */
va_end (args);
}
-/* Easy */
+/* Like printf_filtered, but prints it's result indented.
+ Called as printfi_filtered (spaces, format, arg1, arg2, ...); */
+
+/* VARARGS */
+void
+printfi_filtered (va_alist)
+ va_dcl
+{
+ 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);
+}
+
+/* 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)
\f
/* C++ demangler stuff. */
-/* 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);
+ }
+ }
}
}
+
+/* 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). */
+
+int
+strcmp_iw (string1, string2)
+ const char *string1;
+ const char *string2;
+{
+ 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');
+}
+
\f
void
_initialize_utils ()
/* 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 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;
#ifdef SIGWINCH_HANDLER_BODY
SIGWINCH_HANDLER_BODY
#endif
+