1 /* Copyright (C) 1995,1996,1997,1998,1999,2000, 2001, 2002, 2006, 2008, 2009, 2012 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public License
5 * as published by the Free Software Foundation; either version 3 of
6 * the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
28 #include "libguile/_scm.h"
29 #include "libguile/stackchk.h"
30 #include "libguile/dynwind.h"
31 #include "libguile/eval.h"
32 #include "libguile/smob.h"
33 #include "libguile/pairs.h"
34 #include "libguile/throw.h"
35 #include "libguile/fluids.h"
36 #include "libguile/ports.h"
38 #include "libguile/root.h"
41 /* {call-with-dynamic-root}
43 * Suspending the current thread to evaluate a thunk on the
44 * same C stack but under a new root.
46 * Calls to call-with-dynamic-root return exactly once (unless
47 * the process is somehow exitted). */
49 /* cwdr fills out both of these structures, and then passes a pointer
50 to them through scm_internal_catch to the cwdr_body and
51 cwdr_handler functions, to tell them how to behave and to get
52 information back from them.
54 A cwdr is a lot like a catch, except there is no tag (all
55 exceptions are caught), and the body procedure takes the arguments
56 passed to cwdr as A1 and ARGS. The handler is also special since
57 it is not directly run from scm_internal_catch. It is executed
58 outside the new dynamic root. */
60 struct cwdr_body_data
{
61 /* Arguments to pass to the cwdr body function. */
64 /* Scheme procedure to use as body of cwdr. */
68 struct cwdr_handler_data
{
69 /* Do we need to run the handler? */
72 /* The tag and args to pass it. */
77 /* Invoke the body of a cwdr, assuming that the throw handler has
78 already been set up. DATA points to a struct set up by cwdr that
79 says what proc to call, and what args to apply it to.
81 With a little thought, we could replace this with scm_body_thunk,
82 but I don't want to mess with that at the moment. */
84 cwdr_body (void *data
)
86 struct cwdr_body_data
*c
= (struct cwdr_body_data
*) data
;
88 return scm_apply (c
->body_proc
, c
->a1
, c
->args
);
91 /* Record the fact that the body of the cwdr has thrown. Record
92 enough information to invoke the handler later when the dynamic
93 root has been deestablished. */
96 cwdr_handler (void *data
, SCM tag
, SCM args
)
98 struct cwdr_handler_data
*c
= (struct cwdr_handler_data
*) data
;
103 return SCM_UNSPECIFIED
;
107 scm_internal_cwdr (scm_t_catch_body body
, void *body_data
,
108 scm_t_catch_handler handler
, void *handler_data
,
109 SCM_STACKITEM
*stack_start
)
111 struct cwdr_handler_data my_handler_data
;
112 scm_t_dynstack
*dynstack
= &SCM_I_CURRENT_THREAD
->dynstack
;
114 scm_t_dynstack
*old_dynstack
;
116 /* Exit caller's dynamic state.
118 old_dynstack
= scm_dynstack_capture_all (dynstack
);
119 scm_dynstack_unwind (dynstack
, SCM_DYNSTACK_FIRST (dynstack
));
121 scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE
);
122 scm_dynwind_current_dynamic_state (scm_make_dynamic_state (SCM_UNDEFINED
));
124 my_handler_data
.run_handler
= 0;
125 answer
= scm_i_with_continuation_barrier (body
, body_data
,
126 cwdr_handler
, &my_handler_data
,
131 /* Enter caller's dynamic state.
133 scm_dynstack_wind (dynstack
, SCM_DYNSTACK_FIRST (old_dynstack
));
135 /* Now run the real handler iff the body did a throw. */
136 if (my_handler_data
.run_handler
)
137 return handler (handler_data
, my_handler_data
.tag
, my_handler_data
.args
);
142 /* The original CWDR for invoking Scheme code with a Scheme handler. */
145 cwdr (SCM proc
, SCM a1
, SCM args
, SCM handler
, SCM_STACKITEM
*stack_start
)
147 struct cwdr_body_data c
;
153 return scm_internal_cwdr (cwdr_body
, &c
,
154 scm_handle_by_proc
, &handler
,
158 SCM_DEFINE (scm_call_with_dynamic_root
, "call-with-dynamic-root", 2, 0, 0,
159 (SCM thunk
, SCM handler
),
160 "Call @var{thunk} with a new dynamic state and within\n"
161 "a continuation barrier. The @var{handler} catches all\n"
162 "otherwise uncaught throws and executes within the same\n"
163 "dynamic context as @var{thunk}.")
164 #define FUNC_NAME s_scm_call_with_dynamic_root
166 SCM_STACKITEM stack_place
;
167 return cwdr (thunk
, SCM_EOL
, SCM_EOL
, handler
, &stack_place
);
171 SCM_DEFINE (scm_dynamic_root
, "dynamic-root", 0, 0, 0,
173 "Return an object representing the current dynamic root.\n\n"
174 "These objects are only useful for comparison using @code{eq?}.\n")
175 #define FUNC_NAME s_scm_dynamic_root
177 return SCM_I_CURRENT_THREAD
->continuation_root
;
182 scm_apply_with_dynamic_root (SCM proc
, SCM a1
, SCM args
, SCM handler
)
184 SCM_STACKITEM stack_place
;
185 return cwdr (proc
, a1
, args
, handler
, &stack_place
);
193 #include "libguile/root.x"