/* Exception (throw catch) mechanism, for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
- Software Foundation, Inc.
+ Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GDB.
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 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#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
+const struct gdb_exception exception_none = { 0, GDB_NO_ERROR, NULL };
/* Possible catcher states. */
enum catcher_state {
{
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;
+ volatile struct gdb_exception *exception;
/* Saved/current state. */
int mask;
struct ui_out *saved_uiout;
/* Where to go for throw_exception(). */
static struct catcher *current_catcher;
-static SIGJMP_BUF *
-catcher_init (struct ui_out *func_uiout,
- volatile struct exception *exception,
- return_mask mask)
+EXCEPTIONS_SIGJMP_BUF *
+exceptions_state_mc_init (struct ui_out *func_uiout,
+ volatile struct gdb_exception *exception,
+ return_mask mask)
{
struct catcher *new_catcher = XZALLOC (struct catcher);
/* Start with no exception, save it's address. */
exception->reason = 0;
- exception->error = NO_ERROR;
+ exception->error = GDB_NO_ERROR;
exception->message = NULL;
new_catcher->exception = exception;
/* 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)
{
case CATCH_ITER:
{
- struct exception exception = *current_catcher->exception;
+ struct gdb_exception exception = *current_catcher->exception;
if (current_catcher->mask & RETURN_MASK (exception.reason))
{
/* Exit normally if this catcher can handle this
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
-throw_exception (struct exception exception)
+throw_exception (struct gdb_exception exception)
{
quit_flag = 0;
immediate_quit = 0;
/* 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;
+ struct gdb_exception exception;
memset (&exception, 0, sizeof exception);
exception.reason = reason;
exception.error = GENERIC_ERROR;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
throw_exception (exception);
static void
print_flush (void)
{
+ struct serial *gdb_stdout_serial;
+
if (deprecated_error_begin_hook)
deprecated_error_begin_hook ();
target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
+
+ /* 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);
+ if (gdb_stdout_serial)
+ {
+ 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)
+print_exception (struct ui_file *file, struct gdb_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. */
}
void
-exception_print (struct ui_file *file, struct exception e)
+exception_print (struct ui_file *file, struct gdb_exception e)
{
if (e.reason < 0 && e.message != NULL)
{
}
void
-exception_fprintf (struct ui_file *file, struct exception e,
+exception_fprintf (struct ui_file *file, struct gdb_exception e,
const char *prefix, ...)
{
if (e.reason < 0 && e.message != NULL)
void
print_any_exception (struct ui_file *file, const char *prefix,
- struct exception e)
+ struct gdb_exception e)
{
if (e.reason < 0 && e.message != NULL)
{
}
}
-NORETURN static void
-throw_it (enum return_reason reason, enum errors error, const char *fmt,
- va_list ap) ATTR_NORETURN;
-NORETURN static void
+NORETURN static void ATTR_NORETURN ATTR_FORMAT (printf, 3, 0)
throw_it (enum return_reason reason, enum errors error, const char *fmt,
va_list ap)
{
- struct exception e;
+ struct gdb_exception e;
+ char *new_message;
- /* Save the 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 = xstrvprintf (fmt, ap);
+ last_message = new_message;
/* Create the exception. */
e.reason = reason;
NORETURN void
throw_vfatal (const char *fmt, va_list ap)
{
- throw_it (RETURN_QUIT, NO_ERROR, fmt, ap);
+ throw_it (RETURN_QUIT, GDB_NO_ERROR, fmt, ap);
}
NORETURN void
return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask);
}
-struct exception
+struct gdb_exception
catch_exception (struct ui_out *uiout,
catch_exception_ftype *func,
void *func_args,
return_mask mask)
{
- volatile struct exception exception;
- SIGJMP_BUF *catch;
- catch = catcher_init (uiout, &exception, mask);
- for (SIGSETJMP ((*catch));
- catcher_state_machine (CATCH_ITER);)
- (*func) (uiout, func_args);
+ volatile struct gdb_exception exception;
+ TRY_CATCH (exception, mask)
+ {
+ (*func) (uiout, func_args);
+ }
return exception;
}
char **gdberrmsg,
return_mask mask)
{
- volatile struct exception exception;
+ volatile struct gdb_exception exception;
volatile int val = 0;
- SIGJMP_BUF *catch = catcher_init (uiout, &exception, mask);
- 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);
return_mask mask)
{
volatile int val = 0;
- volatile struct exception exception;
- SIGJMP_BUF *catch = catcher_init (uiout, &exception, mask);
- /* 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);
+ volatile struct gdb_exception exception;
+ TRY_CATCH (exception, mask)
+ {
+ val = func (func_args);
+ }
print_any_exception (gdb_stderr, errstring, exception);
if (exception.reason != 0)
return 0;
catch_command_errors (catch_command_errors_ftype * command,
char *arg, int from_tty, return_mask mask)
{
- volatile struct exception e;
- SIGJMP_BUF *catch = catcher_init (uiout, &e, mask);
- for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
- command (arg, from_tty);
+ volatile struct gdb_exception e;
+ TRY_CATCH (e, mask)
+ {
+ command (arg, from_tty);
+ }
print_any_exception (gdb_stderr, NULL, e);
if (e.reason < 0)
return 0;