#include "signals.h"
#include "gdbcmd.h"
+#include "serial.h"
+#if 0
+/* No longer needed, I suspect. */
#include "terminal.h"
+#endif
#include "bfd.h"
#include "target.h"
#include "demangle.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... */
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;
vfprintf_filtered (stderr, string, args);
fprintf_filtered (stderr, "\n");
va_end (args);
- return_to_top_level ();
+ return_to_top_level (RETURN_ERROR);
}
/* Print an error message and exit reporting failure.
void
quit ()
{
+ serial_t stdout_serial = serial_fdopen (1);
+
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 */
- 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 */
-#else
- error ("Quit");
-#endif
+
+ SERIAL_FLUSH_OUTPUT (stdout_serial);
+
+ SERIAL_UN_FDOPEN (stdout_serial);
+
+ /* Don't use *_filtered; we don't want to prompt the user to continue. */
+ if (error_pre_print)
+ fprintf (stderr, error_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 (stderr, "Quit\n");
+ else
+ fprintf (stderr,
+ "Quit (expect signal SIGINT when the program is resumed)\n");
+ return_to_top_level (RETURN_QUIT);
}
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. */
+
+/* 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;
- 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. */
+/* Pointer in wrap_buffer to the next character to fill. */
+static char *wrap_pointer;
-static char *wrap_buffer, *wrap_pointer, *wrap_indent;
+/* 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 */
reinitialize_more_filter ();
immediate_quit++;
- ignore = gdb_readline ("---Type <return> to continue---");
+ /* 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. */
+ ignore =
+ gdb_readline ("---Type <return> to continue, or q <return> to quit---");
if (ignore)
- free (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
/* 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().
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. */
+ 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;
{
if (wrap_buffer[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;
}
}
/* Now output indentation and wrapped string */
if (wrap_column)
{
- if (wrap_indent)
- fputs (wrap_indent, stream);
+ fputs (wrap_indent, stream);
*wrap_pointer = '\0'; /* Null-terminate saved stuff */
fputs (wrap_buffer, stream); /* and eject it */
/* FIXME, this strlen is what prevents wrap_indent from
}
}
-
-/* fputs_demangled 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
-fputs_demangled (name, stream, arg_mode, lang)
- char *name;
- FILE *stream;
- int arg_mode;
- enum language lang;
-{
- char *demangled;
-
- if (name != NULL)
- {
- /* 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;
- /* start-sanitize-chill */
- case language_chill:
- demangled = chill_demangle (name);
- break;
- /* end-sanitize-chill */
- default:
- demangled = NULL;
- break;
- }
- fputs_filtered (demangled ? demangled : name, stream);
- if (demangled != NULL)
- {
- free (demangled);
- }
- }
- }
-}
-
/* Print a variable number of ARGS using format FORMAT. If this
information is going to put the amount written (since the last call
to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
\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 = NULL;
+ char *demangled;
- if (demangle)
+ if (name != NULL)
{
- /* Lacking a better method of knowing what demangler to use, pick
- one appropriate for whatever the current language is. (FIXME) */
- switch (current_language -> la_language)
+ /* If user wants to see raw output, no problem. */
+ if (!demangle)
{
- case language_cplus:
- demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI);
- break;
- /* start-sanitize-chill */
- case language_chill:
- demangled = chill_demangle (name);
- break;
- /* end-sanitize-chill */
+ 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);
+ }
}
- }
- if (demangled == NULL)
- {
- fputs_filtered (name, stream);
- }
- else
- {
- fputs_filtered (demangled, stream);
- free (demangled);
}
}