#include "defs.h"
#include "exceptions.h"
-#include <setjmp.h>
#include "breakpoint.h"
#include "target.h"
#include "inferior.h"
#include "ui-out.h"
#include "gdb_assert.h"
#include "gdb_string.h"
+#include "serial.h"
const struct exception exception_none = { 0, NO_ERROR, NULL };
-/* One should use catch_errors rather than manipulating these
- directly. */
-#if defined(HAVE_SIGSETJMP)
-#define SIGJMP_BUF sigjmp_buf
-#define SIGSETJMP(buf) sigsetjmp((buf), 1)
-#define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
-#else
-#define SIGJMP_BUF jmp_buf
-#define SIGSETJMP(buf) setjmp(buf)
-#define SIGLONGJMP(buf,val) longjmp((buf), (val))
-#endif
-
/* Possible catcher states. */
enum catcher_state {
/* Initial state, a new catcher has just been created. */
{
enum catcher_state state;
/* Jump buffer pointing back at the exception handler. */
- SIGJMP_BUF buf;
+ EXCEPTIONS_SIGJMP_BUF buf;
/* Status buffer belonging to the exception handler. */
volatile struct exception *exception;
- /* Should the error / quit message be printed? Old code assumes
- that this file prints the error/quit message when first reported.
- New code instead directly handles the printing of error/quit
- messages. */
- int print_message;
/* Saved/current state. */
int mask;
- char *saved_error_pre_print;
- char *saved_quit_pre_print;
struct ui_out *saved_uiout;
struct cleanup *saved_cleanup_chain;
/* Back link. */
/* Where to go for throw_exception(). */
static struct catcher *current_catcher;
-static SIGJMP_BUF *
-catcher_init (struct ui_out *func_uiout,
- char *errstring,
- volatile struct exception *exception,
- return_mask mask,
- int print_message)
+EXCEPTIONS_SIGJMP_BUF *
+exceptions_state_mc_init (struct ui_out *func_uiout,
+ volatile struct exception *exception,
+ return_mask mask)
{
struct catcher *new_catcher = XZALLOC (struct catcher);
new_catcher->exception = exception;
new_catcher->mask = mask;
- new_catcher->print_message = print_message;
-
- /* Override error/quit messages during FUNC. */
- new_catcher->saved_error_pre_print = error_pre_print;
- new_catcher->saved_quit_pre_print = quit_pre_print;
- if (mask & RETURN_MASK_ERROR)
- error_pre_print = errstring;
- if (mask & RETURN_MASK_QUIT)
- quit_pre_print = errstring;
/* Override the global ``struct ui_out'' builder. */
new_catcher->saved_uiout = uiout;
uiout = old_catcher->saved_uiout;
- quit_pre_print = old_catcher->saved_quit_pre_print;
- error_pre_print = old_catcher->saved_error_pre_print;
-
xfree (old_catcher);
}
/* Catcher state machine. Returns non-zero if the m/c should be run
again, zero if it should abort. */
-int
-catcher_state_machine (enum catcher_action action)
+static int
+exceptions_state_mc (enum catcher_action action)
{
switch (current_catcher->state)
{
current_catcher->state = CATCHER_RUNNING;
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
case CATCHER_RUNNING:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_RUNNING_1:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_ABORTING:
switch (action)
throw_exception (exception);
}
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
+int
+exceptions_state_mc_action_iter (void)
+{
+ return exceptions_state_mc (CATCH_ITER);
+}
+
+int
+exceptions_state_mc_action_iter_1 (void)
+{
+ return exceptions_state_mc (CATCH_ITER_1);
+}
+
/* Return EXCEPTION to the nearest containing catch_errors(). */
NORETURN void
if (sync_execution)
do_exec_error_cleanups (ALL_CLEANUPS);
- if (annotation_level > 1)
- switch (exception.reason)
- {
- case RETURN_QUIT:
- annotate_quit ();
- break;
- case RETURN_ERROR:
- /* Assume that these are all errors. */
- annotate_error ();
- break;
- default:
- internal_error (__FILE__, __LINE__, "Bad switch.");
- }
-
/* Jump to the containing catch_errors() call, communicating REASON
to that call via setjmp's return value. Note that REASON can't
be zero, by definition in defs.h. */
- catcher_state_machine (CATCH_THROWING);
+ exceptions_state_mc (CATCH_THROWING);
*current_catcher->exception = exception;
- SIGLONGJMP (current_catcher->buf, exception.reason);
+ EXCEPTIONS_SIGLONGJMP (current_catcher->buf, exception.reason);
}
static char *last_message;
NORETURN void
-throw_reason (enum return_reason reason)
+deprecated_throw_reason (enum return_reason reason)
{
struct exception exception;
memset (&exception, 0, sizeof exception);
break;
case RETURN_ERROR:
exception.error = GENERIC_ERROR;
- exception.message = last_message;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
throw_exception (exception);
}
static void
-do_write (void *data, const char *buffer, long length_buffer)
+print_flush (void)
{
- ui_file_write (data, buffer, length_buffer);
+ struct serial *gdb_stdout_serial;
+
+ if (deprecated_error_begin_hook)
+ deprecated_error_begin_hook ();
+ target_terminal_ours ();
+
+ /* We want all output to appear now, before we print the error. 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 ("");
+
+ /* 2. The stdio buffer. */
+ gdb_flush (gdb_stdout);
+ gdb_flush (gdb_stderr);
+
+ /* 3. The system-level buffer. */
+ gdb_stdout_serial = serial_fdopen (1);
+ serial_drain_output (gdb_stdout_serial);
+ serial_un_fdopen (gdb_stdout_serial);
+
+ annotate_error_begin ();
}
+static void
+print_exception (struct ui_file *file, struct exception e)
+{
+ /* KLUGE: cagney/2005-01-13: Write the string out one line at a time
+ as that way the MI's behavior is preserved. */
+ const char *start;
+ const char *end;
+ for (start = e.message; start != NULL; start = end)
+ {
+ end = strchr (start, '\n');
+ if (end == NULL)
+ fputs_filtered (start, file);
+ else
+ {
+ end++;
+ ui_file_write (file, start, end - start);
+ }
+ }
+ fprintf_filtered (file, "\n");
+
+ /* Now append the annotation. */
+ switch (e.reason)
+ {
+ case RETURN_QUIT:
+ annotate_quit ();
+ break;
+ case RETURN_ERROR:
+ /* Assume that these are all errors. */
+ annotate_error ();
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("Bad switch."));
+ }
+}
void
-exception_print (struct ui_file *file, const char *pre_print,
- struct exception e)
+exception_print (struct ui_file *file, struct exception e)
{
if (e.reason < 0 && e.message != NULL)
{
- target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
- gdb_flush (file);
- annotate_error_begin ();
- if (pre_print)
- fputs_filtered (pre_print, file);
-
- /* KLUGE: cagney/2005-01-13: Write the string out one line at a
- time as that way the MI's behavior is preserved. */
- {
- const char *start;
- const char *end;
- for (start = e.message; start != NULL; start = end)
- {
- end = strchr (start, '\n');
- if (end == NULL)
- fputs_filtered (start, file);
- else
- {
- end++;
- ui_file_write (file, start, end - start);
- }
- }
- }
- fprintf_filtered (file, "\n");
+ print_flush ();
+ print_exception (file, e);
}
}
-NORETURN static void
-print_and_throw (enum return_reason reason, enum errors error,
- const char *prefix, const char *fmt,
- va_list ap) ATTR_NORETURN;
-NORETURN static void
-print_and_throw (enum return_reason reason, enum errors error,
- const char *prefix, const char *fmt, va_list ap)
+void
+exception_fprintf (struct ui_file *file, struct exception e,
+ const char *prefix, ...)
{
- /* FIXME: cagney/2005-01-13: While xstrvprintf is simpler it alters
- GDB's output. Instead of the message being printed
- line-at-a-time the message comes out all at once. The problem is
- that the MI testsuite is checks for line-at-a-time messages and
- changing this behavior means updating the testsuite. */
+ if (e.reason < 0 && e.message != NULL)
+ {
+ va_list args;
- struct exception e;
- struct ui_file *tmp_stream;
- long len;
+ print_flush ();
- /* Convert the message into a print stream. */
- tmp_stream = mem_fileopen ();
- make_cleanup_ui_file_delete (tmp_stream);
- vfprintf_unfiltered (tmp_stream, fmt, ap);
+ /* Print the prefix. */
+ va_start (args, prefix);
+ vfprintf_filtered (file, prefix, args);
+ va_end (args);
- /* Save the message. */
- xfree (last_message);
- last_message = ui_file_xstrdup (tmp_stream, &len);
+ print_exception (file, e);
+ }
+}
- /* Print the mesage to stderr, but only if the catcher isn't going
- to handle/print it locally. */
- if (current_catcher->print_message)
+void
+print_any_exception (struct ui_file *file, const char *prefix,
+ struct exception e)
+{
+ if (e.reason < 0 && e.message != NULL)
{
- if (deprecated_error_begin_hook)
- deprecated_error_begin_hook ();
-
- /* Write the message plus any pre_print to gdb_stderr. */
target_terminal_ours ();
wrap_here (""); /* Force out any buffered output */
gdb_flush (gdb_stdout);
annotate_error_begin ();
- if (error_pre_print)
- fputs_filtered (error_pre_print, gdb_stderr);
- ui_file_put (tmp_stream, do_write, gdb_stderr);
- fprintf_filtered (gdb_stderr, "\n");
+
+ /* Print the prefix. */
+ if (prefix != NULL && prefix[0] != '\0')
+ fputs_filtered (prefix, file);
+ print_exception (file, e);
}
+}
- /* Throw the exception. */
+NORETURN static void
+throw_it (enum return_reason reason, enum errors error, const char *fmt,
+ va_list ap) ATTR_NORETURN;
+NORETURN static void
+throw_it (enum return_reason reason, enum errors error, const char *fmt,
+ va_list ap)
+{
+ struct exception e;
+ char *new_message;
+
+ /* Save the message. Create the new message before deleting the
+ old, the new message may include the old message text. */
+ new_message = xstrvprintf (fmt, ap);
+ xfree (last_message);
+ last_message = new_message;
+
+ /* Create the exception. */
e.reason = reason;
e.error = error;
e.message = last_message;
+
+ /* Throw the exception. */
throw_exception (e);
}
NORETURN void
throw_verror (enum errors error, const char *fmt, va_list ap)
{
- print_and_throw (RETURN_ERROR, error, error_pre_print, fmt, ap);
+ throw_it (RETURN_ERROR, error, fmt, ap);
}
NORETURN void
throw_vfatal (const char *fmt, va_list ap)
{
- print_and_throw (RETURN_QUIT, NO_ERROR, quit_pre_print, fmt, ap);
+ throw_it (RETURN_QUIT, NO_ERROR, fmt, ap);
}
NORETURN void
{
va_list args;
va_start (args, fmt);
- print_and_throw (RETURN_ERROR, error, error_pre_print, fmt, args);
+ throw_it (RETURN_ERROR, error, fmt, args);
va_end (args);
}
catch_exceptions (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
- char *errstring,
return_mask mask)
{
- return catch_exceptions_with_msg (uiout, func, func_args, errstring,
- NULL, mask);
+ return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask);
}
struct exception
return_mask mask)
{
volatile struct exception exception;
- SIGJMP_BUF *catch;
- catch = catcher_init (uiout, NULL, &exception, mask, 0);
- for (SIGSETJMP ((*catch));
- catcher_state_machine (CATCH_ITER);)
- (*func) (uiout, func_args);
+ TRY_CATCH (exception, mask)
+ {
+ (*func) (uiout, func_args);
+ }
return exception;
}
catch_exceptions_with_msg (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
- char *errstring,
char **gdberrmsg,
return_mask mask)
{
volatile struct exception exception;
volatile int val = 0;
- SIGJMP_BUF *catch = catcher_init (uiout, errstring, &exception, mask, 1);
- for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
- val = (*func) (uiout, func_args);
+ TRY_CATCH (exception, mask)
+ {
+ val = (*func) (uiout, func_args);
+ }
+ print_any_exception (gdb_stderr, NULL, exception);
gdb_assert (val >= 0);
gdb_assert (exception.reason <= 0);
if (exception.reason < 0)
{
volatile int val = 0;
volatile struct exception exception;
- SIGJMP_BUF *catch = catcher_init (uiout, errstring, &exception, mask, 1);
- /* This illustrates how it is possible to nest the mechanism and
- hence catch "break". Of course this doesn't address the need to
- also catch "return". */
- for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
- val = func (func_args);
+ TRY_CATCH (exception, mask)
+ {
+ val = func (func_args);
+ }
+ print_any_exception (gdb_stderr, errstring, exception);
if (exception.reason != 0)
return 0;
return val;
}
-struct captured_command_args
- {
- catch_command_errors_ftype *command;
- char *arg;
- int from_tty;
- };
-
-static int
-do_captured_command (void *data)
-{
- struct captured_command_args *context = data;
- context->command (context->arg, context->from_tty);
- /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
- isn't needed. Instead an assertion check could be made that
- simply confirmed that the called function correctly cleaned up
- after itself. Unfortunately, old code (prior to 1999-11-04) in
- main.c was calling SET_TOP_LEVEL(), calling the command function,
- and then *always* calling do_cleanups(). For the moment we
- remain ``bug compatible'' with that old code.. */
- do_cleanups (ALL_CLEANUPS);
- return 1;
-}
-
int
catch_command_errors (catch_command_errors_ftype * command,
char *arg, int from_tty, return_mask mask)
{
- struct captured_command_args args;
- args.command = command;
- args.arg = arg;
- args.from_tty = from_tty;
- return catch_errors (do_captured_command, &args, "", mask);
+ volatile struct exception e;
+ TRY_CATCH (e, mask)
+ {
+ command (arg, from_tty);
+ }
+ print_any_exception (gdb_stderr, NULL, e);
+ if (e.reason < 0)
+ return 0;
+ return 1;
}
projects / deliverable / binutils-gdb.git / blobdiff