X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexceptions.c;h=98e6f25829a7c5cac53d35af36d983b7693aa02e;hb=e2e0b3e57f11bb2539724fc955af7e22380613c1;hp=aed10a8e5fec845b8fd71eec381ac02ca94e6f3e;hpb=05ff989b0b012d3c83f5908dd9750e01a74cc3de;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/exceptions.c b/gdb/exceptions.c index aed10a8e5f..98e6f25829 100644 --- a/gdb/exceptions.c +++ b/gdb/exceptions.c @@ -23,7 +23,6 @@ #include "defs.h" #include "exceptions.h" -#include #include "breakpoint.h" #include "target.h" #include "inferior.h" @@ -31,21 +30,10 @@ #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. */ @@ -68,18 +56,11 @@ struct catcher { 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. */ @@ -89,12 +70,10 @@ struct catcher /* 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); @@ -105,15 +84,6 @@ catcher_init (struct ui_out *func_uiout, 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; @@ -144,17 +114,14 @@ catcher_pop (void) 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) { @@ -166,7 +133,7 @@ catcher_state_machine (enum catcher_action action) 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) @@ -183,7 +150,7 @@ catcher_state_machine (enum catcher_action 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) @@ -200,7 +167,7 @@ catcher_state_machine (enum catcher_action 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) @@ -223,13 +190,25 @@ catcher_state_machine (enum catcher_action 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 @@ -249,32 +228,18 @@ throw_exception (struct exception exception) 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); @@ -286,118 +251,160 @@ throw_reason (enum return_reason reason) 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 @@ -405,7 +412,7 @@ throw_error (enum errors error, const char *fmt, ...) { 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); } @@ -445,11 +452,9 @@ int 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 @@ -459,11 +464,10 @@ catch_exception (struct ui_out *uiout, 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; } @@ -471,15 +475,16 @@ int 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) @@ -505,47 +510,27 @@ catch_errors (catch_errors_ftype *func, void *func_args, char *errstring, { 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; }