1 /* Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2, or (at your option)
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this software; see the file COPYING. If not, write to
15 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
16 * Boston, MA 02111-1307 USA
18 * As a special exception, the Free Software Foundation gives permission
19 * for additional uses of the text contained in its release of GUILE.
21 * The exception is that, if you link the GUILE library with other files
22 * to produce an executable, this does not by itself cause the
23 * resulting executable to be covered by the GNU General Public License.
24 * Your use of that executable is in no way restricted on account of
25 * linking the GUILE library code into it.
27 * This exception does not however invalidate any other reasons why
28 * the executable file might be covered by the GNU General Public License.
30 * This exception applies only to the code released by the
31 * Free Software Foundation under the name GUILE. If you copy
32 * code from other Free Software Foundation releases into a copy of
33 * GUILE, as the General Public License permits, the exception does
34 * not apply to the code that you add in this way. To avoid misleading
35 * anyone as to the status of such modified files, you must delete
36 * this exception notice from them.
38 * If you write modifications of your own for GUILE, it is your choice
39 * whether to permit this exception to apply to your modifications.
40 * If you do not wish that, delete this exception notice. */
42 /* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
43 gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
48 #include "libguile/_scm.h"
49 #include "libguile/smob.h"
50 #include "libguile/alist.h"
51 #include "libguile/eval.h"
52 #include "libguile/eq.h"
53 #include "libguile/dynwind.h"
54 #include "libguile/backtrace.h"
55 #ifdef DEBUG_EXTENSIONS
56 #include "libguile/debug.h"
58 #include "libguile/continuations.h"
59 #include "libguile/stackchk.h"
60 #include "libguile/stacks.h"
61 #include "libguile/fluids.h"
62 #include "libguile/ports.h"
64 #include "libguile/validate.h"
65 #include "libguile/throw.h"
68 /* the jump buffer data structure */
69 static int scm_tc16_jmpbuffer
;
71 #define SCM_JMPBUFP(OBJ) (SCM_NIMP(OBJ) && (SCM_TYP16(OBJ) == scm_tc16_jmpbuffer))
73 #define JBACTIVE(OBJ) (SCM_CELL_WORD_0 (OBJ) & (1L << 16L))
74 #define ACTIVATEJB(OBJ) (SCM_SETOR_CAR (OBJ, (1L << 16L)))
75 #define DEACTIVATEJB(OBJ) (SCM_SETAND_CAR (OBJ, ~(1L << 16L)))
77 #define JBJMPBUF(OBJ) ((jmp_buf *) SCM_CELL_WORD_1 (OBJ))
78 #define SETJBJMPBUF(x,v) (SCM_SET_CELL_WORD_1 ((x), (v)))
79 #ifdef DEBUG_EXTENSIONS
80 #define SCM_JBDFRAME(x) ((scm_debug_frame *) SCM_CELL_WORD_2 (x))
81 #define SCM_SETJBDFRAME(x,v) (SCM_SET_CELL_WORD_2 ((x), (v)))
85 printjb (SCM exp
, SCM port
, scm_print_state
*pstate
)
87 scm_puts ("#<jmpbuffer ", port
);
88 scm_puts (JBACTIVE(exp
) ? "(active) " : "(inactive) ", port
);
89 scm_intprint((long) JBJMPBUF (exp
), 16, port
);
102 #ifdef DEBUG_EXTENSIONS
103 SCM_NEWSMOB2 (answer
, scm_tc16_jmpbuffer
, 0, 0);
105 SCM_NEWSMOB (answer
, scm_tc16_jmpbuffer
, 0);
107 SETJBJMPBUF(answer
, (jmp_buf *)0);
108 DEACTIVATEJB(answer
);
115 /* scm_internal_catch (the guts of catch) */
117 struct jmp_buf_and_retval
/* use only on the stack, in scm_catch */
119 jmp_buf buf
; /* must be first */
125 /* scm_internal_catch is the guts of catch. It handles all the
126 mechanics of setting up a catch target, invoking the catch body,
127 and perhaps invoking the handler if the body does a throw.
129 The function is designed to be usable from C code, but is general
130 enough to implement all the semantics Guile Scheme expects from
133 TAG is the catch tag. Typically, this is a symbol, but this
134 function doesn't actually care about that.
136 BODY is a pointer to a C function which runs the body of the catch;
137 this is the code you can throw from. We call it like this:
140 BODY_DATA is just the BODY_DATA argument we received; we pass it
141 through to BODY as its first argument. The caller can make
142 BODY_DATA point to anything useful that BODY might need.
144 HANDLER is a pointer to a C function to deal with a throw to TAG,
145 should one occur. We call it like this:
146 HANDLER (HANDLER_DATA, THROWN_TAG, THROW_ARGS)
148 HANDLER_DATA is the HANDLER_DATA argument we recevied; it's the
149 same idea as BODY_DATA above.
150 THROWN_TAG is the tag that the user threw to; usually this is
151 TAG, but it could be something else if TAG was #t (i.e., a
152 catch-all), or the user threw to a jmpbuf.
153 THROW_ARGS is the list of arguments the user passed to the THROW
154 function, after the tag.
156 BODY_DATA is just a pointer we pass through to BODY. HANDLER_DATA
157 is just a pointer we pass through to HANDLER. We don't actually
158 use either of those pointers otherwise ourselves. The idea is
159 that, if our caller wants to communicate something to BODY or
160 HANDLER, it can pass a pointer to it as MUMBLE_DATA, which BODY and
161 HANDLER can then use. Think of it as a way to make BODY and
162 HANDLER closures, not just functions; MUMBLE_DATA points to the
165 Of course, it's up to the caller to make sure that any data a
166 MUMBLE_DATA needs is protected from GC. A common way to do this is
167 to make MUMBLE_DATA a pointer to data stored in an automatic
168 structure variable; since the collector must scan the stack for
169 references anyway, this assures that any references in MUMBLE_DATA
173 scm_internal_catch (SCM tag
, scm_catch_body_t body
, void *body_data
, scm_catch_handler_t handler
, void *handler_data
)
175 struct jmp_buf_and_retval jbr
;
179 jmpbuf
= make_jmpbuf ();
181 scm_dynwinds
= scm_acons (tag
, jmpbuf
, scm_dynwinds
);
182 SETJBJMPBUF(jmpbuf
, &jbr
.buf
);
183 #ifdef DEBUG_EXTENSIONS
184 SCM_SETJBDFRAME(jmpbuf
, scm_last_debug_frame
);
186 if (setjmp (jbr
.buf
))
191 #ifdef STACK_CHECKING
192 scm_stack_checking_enabled_p
= SCM_STACK_CHECKING_P
;
195 DEACTIVATEJB (jmpbuf
);
196 scm_dynwinds
= SCM_CDR (scm_dynwinds
);
198 throw_args
= jbr
.retval
;
199 throw_tag
= jbr
.throw_tag
;
200 jbr
.throw_tag
= SCM_EOL
;
201 jbr
.retval
= SCM_EOL
;
202 answer
= handler (handler_data
, throw_tag
, throw_args
);
207 answer
= body (body_data
);
209 DEACTIVATEJB (jmpbuf
);
210 scm_dynwinds
= SCM_CDR (scm_dynwinds
);
218 /* scm_internal_lazy_catch (the guts of lazy catching) */
220 /* The smob tag for lazy_catch smobs. */
221 static long tc16_lazy_catch
;
223 /* This is the structure we put on the wind list for a lazy catch. It
224 stores the handler function to call, and the data pointer to pass
225 through to it. It's not a Scheme closure, but it is a function
226 with data, so the term "closure" is appropriate in its broader
229 (We don't need anything like this in the "eager" catch code,
230 because the same C frame runs both the body and the handler.) */
232 scm_catch_handler_t handler
;
236 /* Strictly speaking, we could just pass a zero for our print
237 function, because we don't need to print them. They should never
238 appear in normal data structures, only in the wind list. However,
239 it might be nice for debugging someday... */
241 print_lazy_catch (SCM closure
, SCM port
, scm_print_state
*pstate
)
243 struct lazy_catch
*c
= (struct lazy_catch
*) SCM_CELL_WORD_1 (closure
);
246 sprintf (buf
, "#<lazy-catch 0x%lx 0x%lx>",
247 (long) c
->handler
, (long) c
->handler_data
);
248 scm_puts (buf
, port
);
254 /* Given a pointer to a lazy catch structure, return a smob for it,
255 suitable for inclusion in the wind list. ("Ah yes, a Château
256 Gollombiere '72, non?"). */
258 make_lazy_catch (struct lazy_catch
*c
)
260 SCM_RETURN_NEWSMOB (tc16_lazy_catch
, c
);
263 #define SCM_LAZY_CATCH_P(obj) (SCM_SMOB_PREDICATE (tc16_lazy_catch, obj))
266 /* Exactly like scm_internal_catch, except:
267 - It does not unwind the stack (this is the major difference).
268 - If handler returns, its value is returned from the throw. */
270 scm_internal_lazy_catch (SCM tag
, scm_catch_body_t body
, void *body_data
, scm_catch_handler_t handler
, void *handler_data
)
272 SCM lazy_catch
, answer
;
276 c
.handler_data
= handler_data
;
277 lazy_catch
= make_lazy_catch (&c
);
280 scm_dynwinds
= scm_acons (tag
, lazy_catch
, scm_dynwinds
);
283 answer
= (*body
) (body_data
);
286 scm_dynwinds
= SCM_CDR (scm_dynwinds
);
293 /* scm_internal_stack_catch
294 Use this one if you want debugging information to be stored in
295 scm_the_last_stack_fluid on error. */
298 ss_handler (void *data
, SCM tag
, SCM throw_args
)
301 scm_fluid_set_x (SCM_CDR (scm_the_last_stack_fluid
),
302 scm_make_stack (SCM_BOOL_T
, SCM_EOL
));
303 /* Throw the error */
304 return scm_throw (tag
, throw_args
);
310 scm_catch_body_t body
;
315 cwss_body (void *data
)
317 struct cwss_data
*d
= data
;
318 return scm_internal_lazy_catch (d
->tag
, d
->body
, d
->data
, ss_handler
, NULL
);
322 scm_internal_stack_catch (SCM tag
,
323 scm_catch_body_t body
,
325 scm_catch_handler_t handler
,
332 return scm_internal_catch (tag
, cwss_body
, &d
, handler
, handler_data
);
337 /* body and handler functions for use with any of the above catch variants */
339 /* This is a body function you can pass to scm_internal_catch if you
340 want the body to be like Scheme's `catch' --- a thunk.
342 BODY_DATA is a pointer to a scm_body_thunk_data structure, which
343 contains the Scheme procedure to invoke as the body, and the tag
347 scm_body_thunk (void *body_data
)
349 struct scm_body_thunk_data
*c
= (struct scm_body_thunk_data
*) body_data
;
351 return scm_apply (c
->body_proc
, SCM_EOL
, SCM_EOL
);
355 /* This is a handler function you can pass to scm_internal_catch if
356 you want the handler to act like Scheme's catch: (throw TAG ARGS ...)
357 applies a handler procedure to (TAG ARGS ...).
359 If the user does a throw to this catch, this function runs a
360 handler procedure written in Scheme. HANDLER_DATA is a pointer to
361 an SCM variable holding the Scheme procedure object to invoke. It
362 ought to be a pointer to an automatic variable (i.e., one living on
363 the stack), or the procedure object should be otherwise protected
366 scm_handle_by_proc (void *handler_data
, SCM tag
, SCM throw_args
)
368 SCM
*handler_proc_p
= (SCM
*) handler_data
;
370 return scm_apply (*handler_proc_p
, scm_cons (tag
, throw_args
), SCM_EOL
);
373 /* SCM_HANDLE_BY_PROC_CATCHING_ALL is like SCM_HANDLE_BY_PROC but
374 catches all throws that the handler might emit itself. The handler
375 used for these `secondary' throws is SCM_HANDLE_BY_MESSAGE_NO_EXIT. */
383 hbpca_body (void *body_data
)
385 struct hbpca_data
*data
= (struct hbpca_data
*)body_data
;
386 return scm_apply (data
->proc
, data
->args
, SCM_EOL
);
390 scm_handle_by_proc_catching_all (void *handler_data
, SCM tag
, SCM throw_args
)
392 SCM
*handler_proc_p
= (SCM
*) handler_data
;
393 struct hbpca_data data
;
394 data
.proc
= *handler_proc_p
;
395 data
.args
= scm_cons (tag
, throw_args
);
397 return scm_internal_catch (SCM_BOOL_T
,
399 scm_handle_by_message_noexit
, NULL
);
402 /* Derive the an exit status from the arguments to (quit ...). */
404 scm_exit_status (SCM args
)
406 if (SCM_NNULLP (args
))
408 SCM cqa
= SCM_CAR (args
);
411 return (SCM_INUM (cqa
));
412 else if (SCM_FALSEP (cqa
))
420 handler_message (void *handler_data
, SCM tag
, SCM args
)
422 char *prog_name
= (char *) handler_data
;
423 SCM p
= scm_cur_errp
;
425 if (scm_ilength (args
) >= 3)
427 SCM stack
= scm_make_stack (SCM_BOOL_T
, SCM_EOL
);
428 SCM subr
= SCM_CAR (args
);
429 SCM message
= SCM_CADR (args
);
430 SCM parts
= SCM_CADDR (args
);
431 SCM rest
= SCM_CDDDR (args
);
433 if (SCM_BACKTRACE_P
&& SCM_NFALSEP (stack
))
435 scm_puts ("Backtrace:\n", p
);
436 scm_display_backtrace (stack
, p
, SCM_UNDEFINED
, SCM_UNDEFINED
);
439 scm_display_error (stack
, p
, subr
, message
, parts
, rest
);
446 scm_puts (prog_name
, p
);
449 scm_puts ("uncaught throw to ", p
);
450 scm_prin1 (tag
, p
, 0);
452 scm_prin1 (args
, p
, 1);
458 /* This is a handler function to use if you want scheme to print a
459 message and die. Useful for dealing with throws to uncaught keys
462 At boot time, we establish a catch-all that uses this as its handler.
463 1) If the user wants something different, they can use (catch #t
464 ...) to do what they like.
465 2) Outside the context of a read-eval-print loop, there isn't
466 anything else good to do; libguile should not assume the existence
467 of a read-eval-print loop.
468 3) Given that we shouldn't do anything complex, it's much more
469 robust to do it in C code.
471 HANDLER_DATA, if non-zero, is assumed to be a char * pointing to a
472 message header to print; if zero, we use "guile" instead. That
473 text is followed by a colon, then the message described by ARGS. */
476 scm_handle_by_message (void *handler_data
, SCM tag
, SCM args
)
478 if (SCM_NFALSEP (scm_eq_p (tag
, SCM_CAR (scm_intern0 ("quit")))))
480 exit (scm_exit_status (args
));
483 handler_message (handler_data
, tag
, args
);
484 /* try to flush the error message first before the rest of the
485 ports: if any throw error, it currently causes a bus
491 /* This is just like scm_handle_by_message, but it doesn't exit; it
492 just returns #f. It's useful in cases where you don't really know
493 enough about the body to handle things in a better way, but don't
494 want to let throws fall off the bottom of the wind list. */
496 scm_handle_by_message_noexit (void *handler_data
, SCM tag
, SCM args
)
498 handler_message (handler_data
, tag
, args
);
505 scm_handle_by_throw (void *handler_data
, SCM tag
, SCM args
)
507 scm_ithrow (tag
, args
, 1);
508 return SCM_UNSPECIFIED
; /* never returns */
513 /* the Scheme-visible CATCH and LAZY-CATCH functions */
515 SCM_DEFINE (scm_catch
, "catch", 3, 0, 0,
516 (SCM tag
, SCM thunk
, SCM handler
),
517 "Invoke @var{thunk} in the dynamic context of @var{handler} for\n"
518 "exceptions matching @var{key}. If thunk throws to the symbol @var{key},\n"
519 "then @var{handler} is invoked this way:\n\n"
521 "(handler key args ...)\n"
523 "@var{key} is a symbol or #t.\n\n"
524 "@var{thunk} takes no arguments. If @var{thunk} returns normally, that\n"
525 "is the return value of @code{catch}.\n\n"
526 "Handler is invoked outside the scope of its own @code{catch}. If\n"
527 "@var{handler} again throws to the same key, a new handler from further\n"
528 "up the call chain is invoked.\n\n"
529 "If the key is @code{#t}, then a throw to @emph{any} symbol will match\n"
530 "this call to @code{catch}.")
531 #define FUNC_NAME s_scm_catch
533 struct scm_body_thunk_data c
;
535 SCM_ASSERT (SCM_SYMBOLP (tag
) || SCM_EQ_P (tag
, SCM_BOOL_T
),
536 tag
, SCM_ARG1
, FUNC_NAME
);
541 /* scm_internal_catch takes care of all the mechanics of setting up
542 a catch tag; we tell it to call scm_body_thunk to run the body,
543 and scm_handle_by_proc to deal with any throws to this catch.
544 The former receives a pointer to c, telling it how to behave.
545 The latter receives a pointer to HANDLER, so it knows who to call. */
546 return scm_internal_catch (tag
,
548 scm_handle_by_proc
, &handler
);
553 SCM_DEFINE (scm_lazy_catch
, "lazy-catch", 3, 0, 0,
554 (SCM tag
, SCM thunk
, SCM handler
),
556 #define FUNC_NAME s_scm_lazy_catch
558 struct scm_body_thunk_data c
;
560 SCM_ASSERT (SCM_SYMBOLP (tag
) || SCM_EQ_P (tag
, SCM_BOOL_T
),
561 tag
, SCM_ARG1
, FUNC_NAME
);
566 /* scm_internal_lazy_catch takes care of all the mechanics of
567 setting up a lazy catch tag; we tell it to call scm_body_thunk to
568 run the body, and scm_handle_by_proc to deal with any throws to
569 this catch. The former receives a pointer to c, telling it how
570 to behave. The latter receives a pointer to HANDLER, so it knows
572 return scm_internal_lazy_catch (tag
,
574 scm_handle_by_proc
, &handler
);
582 SCM_DEFINE (scm_throw
, "throw", 1, 0, 1,
584 "Invoke the catch form matching @var{key}, passing @var{args} to the\n"
585 "@var{handler}. \n\n"
586 "@var{key} is a symbol. It will match catches of the same symbol or of\n"
588 "If there is no handler at all, an error is signaled.")
589 #define FUNC_NAME s_scm_throw
591 SCM_VALIDATE_SYMBOL (1,key
);
592 /* May return if handled by lazy catch. */
593 return scm_ithrow (key
, args
, 1);
598 scm_ithrow (SCM key
, SCM args
, int noreturn
)
600 SCM jmpbuf
= SCM_UNDEFINED
;
603 SCM dynpair
= SCM_UNDEFINED
;
606 /* Search the wind list for an appropriate catch.
607 "Waiter, please bring us the wind list." */
608 for (winds
= scm_dynwinds
; SCM_NIMP (winds
); winds
= SCM_CDR (winds
))
610 if (! SCM_CONSP (winds
))
613 dynpair
= SCM_CAR (winds
);
614 if (SCM_CONSP (dynpair
))
616 SCM this_key
= SCM_CAR (dynpair
);
618 if (SCM_EQ_P (this_key
, SCM_BOOL_T
) || SCM_EQ_P (this_key
, key
))
623 /* If we didn't find anything, abort. scm_boot_guile should
624 have established a catch-all, but obviously things are
625 thoroughly screwed up. */
626 if (SCM_NULLP (winds
))
629 /* If the wind list is malformed, bail. */
630 if (SCM_IMP (winds
) || SCM_NCONSP (winds
))
633 if (!SCM_FALSEP (dynpair
))
634 jmpbuf
= SCM_CDR (dynpair
);
638 return SCM_UNSPECIFIED
;
641 scm_exitval
= scm_cons (key
, args
);
642 scm_dowinds (SCM_EOL
, scm_ilength (scm_dynwinds
));
643 #ifdef DEBUG_EXTENSIONS
644 scm_last_debug_frame
= SCM_DFRAME (scm_rootcont
);
646 longjmp (SCM_JMPBUF (scm_rootcont
), 1);
650 for (wind_goal
= scm_dynwinds
;
651 !SCM_EQ_P (SCM_CDAR (wind_goal
), jmpbuf
);
652 wind_goal
= SCM_CDR (wind_goal
))
655 /* Is a lazy catch? In wind list entries for lazy catches, the key
656 is bound to a lazy_catch smob, not a jmpbuf. */
657 if (SCM_LAZY_CATCH_P (jmpbuf
))
659 struct lazy_catch
*c
= (struct lazy_catch
*) SCM_CELL_WORD_1 (jmpbuf
);
660 SCM oldwinds
= scm_dynwinds
;
662 scm_dowinds (wind_goal
, (scm_ilength (scm_dynwinds
)
663 - scm_ilength (wind_goal
)));
665 handle
= scm_dynwinds
;
666 scm_dynwinds
= SCM_CDR (scm_dynwinds
);
668 answer
= (c
->handler
) (c
->handler_data
, key
, args
);
670 SCM_SETCDR (handle
, scm_dynwinds
);
671 scm_dynwinds
= handle
;
673 scm_dowinds (oldwinds
, (scm_ilength (scm_dynwinds
)
674 - scm_ilength (oldwinds
)));
678 /* Otherwise, it's a normal catch. */
679 else if (SCM_JMPBUFP (jmpbuf
))
681 struct jmp_buf_and_retval
* jbr
;
682 scm_dowinds (wind_goal
, (scm_ilength (scm_dynwinds
)
683 - scm_ilength (wind_goal
)));
684 jbr
= (struct jmp_buf_and_retval
*)JBJMPBUF (jmpbuf
);
685 jbr
->throw_tag
= key
;
689 /* Otherwise, it's some random piece of junk. */
693 #ifdef DEBUG_EXTENSIONS
694 scm_last_debug_frame
= SCM_JBDFRAME (jmpbuf
);
696 longjmp (*JBJMPBUF (jmpbuf
), 1);
703 scm_tc16_jmpbuffer
= scm_make_smob_type_mfpe ("jmpbuffer",
710 tc16_lazy_catch
= scm_make_smob_type_mfpe ("lazy-catch", 0,
715 #include "libguile/throw.x"