-/* Copyright (C) 1996,1997,2000,2001 Free Software Foundation, Inc.
+/* Copyright (C) 1996,1997,2000,2001, 2004 Free Software Foundation, Inc.
*
- * 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, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this software; see the file COPYING. If not, write to
- * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307 USA
- *
- * As a special exception, the Free Software Foundation gives permission
- * for additional uses of the text contained in its release of GUILE.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
*
- * The exception is that, if you link the GUILE library with other files
- * to produce an executable, this does not by itself cause the
- * resulting executable to be covered by the GNU General Public License.
- * Your use of that executable is in no way restricted on account of
- * linking the GUILE library code into it.
- *
- * This exception does not however invalidate any other reasons why
- * the executable file might be covered by the GNU General Public License.
- *
- * This exception applies only to the code released by the
- * Free Software Foundation under the name GUILE. If you copy
- * code from other Free Software Foundation releases into a copy of
- * GUILE, as the General Public License permits, the exception does
- * not apply to the code that you add in this way. To avoid misleading
- * anyone as to the status of such modified files, you must delete
- * this exception notice from them.
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * If you write modifications of your own for GUILE, it is your choice
- * whether to permit this exception to apply to your modifications.
- * If you do not wish that, delete this exception notice. */
-
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <stdio.h>
+#include <string.h>
#include "libguile/_scm.h"
#include "libguile/print.h"
#include "libguile/ports.h"
#include "libguile/deprecation.h"
#include "libguile/lang.h"
-
-#define INITIAL_FLUIDS 10
#include "libguile/validate.h"
-static volatile long n_fluids;
-scm_t_bits scm_tc16_fluid;
+#define FLUID_GROW 20
+
+/* A lot of the complexity below stems from the desire to reuse fluid
+ slots. Normally, fluids should be pretty global and long-lived
+ things, so that reusing their slots should not be overly critical,
+ but it is the right thing to do nevertheless. The code therefore
+ puts the burdon on allocating and collection fluids and keeps
+ accessing fluids lock free. This is achieved by manipulating the
+ global state of the fluid machinery mostly in single threaded
+ sections.
+
+ Reusing a fluid slot means that it must be reset to #f in all
+ dynamic states. We do this by maintaining a weak list of all
+ dynamic states, which is used after a GC to do the resetting.
+
+ Also, the fluid vectors in the dynamic states need to grow from
+ time to time when more fluids are created. We do this in a single
+ threaded section so that threads do not need to lock when accessing
+ a fluid in the normal way.
+*/
+
+static scm_i_pthread_mutex_t fluid_admin_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER;
-SCM
-scm_make_initial_fluids ()
+/* Protected by fluid_admin_mutex, but also accessed during GC. See
+ next_fluid_num for a discussion of this.
+ */
+static size_t allocated_fluids_len = 0;
+static size_t allocated_fluids_num = 0;
+static char *allocated_fluids = NULL;
+
+static scm_t_bits tc16_fluid;
+
+#define IS_FLUID(x) SCM_SMOB_PREDICATE(tc16_fluid, (x))
+#define FLUID_NUM(x) ((size_t)SCM_SMOB_DATA(x))
+#define FLUID_NEXT(x) SCM_SMOB_OBJECT_2(x)
+#define FLUID_NEXT_LOC(x) SCM_SMOB_OBJECT_2_LOC(x)
+#define SET_FLUID_NEXT(x,y) SCM_SET_SMOB_OBJECT_2((x), (y))
+
+static scm_t_bits tc16_dynamic_state;
+
+#define IS_DYNAMIC_STATE(x) SCM_SMOB_PREDICATE(tc16_dynamic_state, (x))
+#define DYNAMIC_STATE_FLUIDS(x) SCM_SMOB_OBJECT(x)
+#define SET_DYNAMIC_STATE_FLUIDS(x, y) SCM_SET_SMOB_OBJECT((x), (y))
+#define DYNAMIC_STATE_NEXT(x) SCM_SMOB_OBJECT_2(x)
+#define DYNAMIC_STATE_NEXT_LOC(x) SCM_SMOB_OBJECT_2_LOC(x)
+#define SET_DYNAMIC_STATE_NEXT(x, y) SCM_SET_SMOB_OBJECT_2((x), (y))
+
+/* Weak lists of all dynamic states and all fluids.
+ */
+static SCM all_dynamic_states = SCM_EOL;
+static SCM all_fluids = SCM_EOL;
+
+/* Make sure that all states have the right size. This must be called
+ while fluid_admin_mutex is held.
+*/
+static void
+resize_all_states ()
{
- return scm_c_make_vector (INITIAL_FLUIDS, SCM_BOOL_F);
+ SCM new_vectors, state;
+
+ /* Replacing the vector of a dynamic state must be done atomically:
+ the old values must be copied into the new vector and the new
+ vector must be installed without someone modifying the old vector
+ concurrently. Since accessing a fluid should be lock-free, we
+ need to put all threads to sleep when replacing a vector.
+ However, when being single threaded, it is best not to do much.
+ Therefore, we allocate the new vectors before going single
+ threaded.
+ */
+
+ new_vectors = SCM_EOL;
+ for (state = all_dynamic_states; !scm_is_null (state);
+ state = DYNAMIC_STATE_NEXT (state))
+ new_vectors = scm_cons (scm_c_make_vector (allocated_fluids_len,
+ SCM_BOOL_F),
+ new_vectors);
+
+ scm_i_thread_put_to_sleep ();
+ for (state = all_dynamic_states; !scm_is_null (state);
+ state = DYNAMIC_STATE_NEXT (state))
+ {
+ SCM old_fluids = DYNAMIC_STATE_FLUIDS (state);
+ SCM new_fluids = SCM_CAR (new_vectors);
+ size_t i, old_len = SCM_SIMPLE_VECTOR_LENGTH (old_fluids);
+
+ for (i = 0; i < old_len; i++)
+ SCM_SIMPLE_VECTOR_SET (new_fluids, i,
+ SCM_SIMPLE_VECTOR_REF (old_fluids, i));
+ SET_DYNAMIC_STATE_FLUIDS (state, new_fluids);
+ new_vectors = SCM_CDR (new_vectors);
+ }
+ scm_i_thread_wake_up ();
}
-static void
-grow_fluids (scm_root_state *root_state, int new_length)
+/* This is called during GC, that is, while being single threaded.
+ See next_fluid_num for a discussion why it is safe to access
+ allocated_fluids here.
+ */
+static void *
+scan_dynamic_states_and_fluids (void *dummy1 SCM_UNUSED,
+ void *dummy2 SCM_UNUSED,
+ void *dummy3 SCM_UNUSED)
{
- SCM old_fluids, new_fluids;
- long old_length, i;
+ SCM *statep, *fluidp;
- old_fluids = root_state->fluids;
- old_length = SCM_VECTOR_LENGTH (old_fluids);
- new_fluids = scm_c_make_vector (new_length, SCM_BOOL_F);
- i = 0;
- while (i < old_length)
+ /* Scan all fluids and deallocate the unmarked ones.
+ */
+ fluidp = &all_fluids;
+ while (!scm_is_null (*fluidp))
{
- SCM_VELTS(new_fluids)[i] = SCM_VELTS(old_fluids)[i];
- i++;
+ if (!SCM_GC_MARK_P (*fluidp))
+ {
+ allocated_fluids_num -= 1;
+ allocated_fluids[FLUID_NUM (*fluidp)] = 0;
+ *fluidp = FLUID_NEXT (*fluidp);
+ }
+ else
+ fluidp = FLUID_NEXT_LOC (*fluidp);
}
- while (i < new_length)
+
+ /* Scan all dynamic states and remove the unmarked ones. The live
+ ones are updated for unallocated fluids.
+ */
+ statep = &all_dynamic_states;
+ while (!scm_is_null (*statep))
{
- SCM_VELTS(new_fluids)[i] = SCM_BOOL_F;
- i++;
+ if (!SCM_GC_MARK_P (*statep))
+ *statep = DYNAMIC_STATE_NEXT (*statep);
+ else
+ {
+ SCM fluids = DYNAMIC_STATE_FLUIDS (*statep);
+ size_t len, i;
+
+ len = SCM_SIMPLE_VECTOR_LENGTH (fluids);
+ for (i = 0; i < len && i < allocated_fluids_len; i++)
+ if (allocated_fluids[i] == 0)
+ SCM_SIMPLE_VECTOR_SET (fluids, i, SCM_BOOL_F);
+
+ statep = DYNAMIC_STATE_NEXT_LOC (*statep);
+ }
}
- root_state->fluids = new_fluids;
+ return NULL;
}
-void
-scm_copy_fluids (scm_root_state *root_state)
+static size_t
+fluid_free (SCM fluid)
{
- grow_fluids (root_state, SCM_VECTOR_LENGTH (root_state->fluids));
+ /* The real work is done in scan_dynamic_states_and_fluids. We can
+ not touch allocated_fluids etc here since a smob free routine can
+ be run at any time, in any thread.
+ */
+ return 0;
}
static int
fluid_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)
{
scm_puts ("#<fluid ", port);
- scm_intprint ((int) SCM_FLUID_NUM (exp), 10, port);
+ scm_intprint ((int) FLUID_NUM (exp), 10, port);
scm_putc ('>', port);
return 1;
}
-static long
+static size_t
next_fluid_num ()
{
- long n;
- SCM_CRITICAL_SECTION_START;
- n = n_fluids++;
- SCM_CRITICAL_SECTION_END;
+ size_t n;
+
+ scm_dynwind_begin (0);
+ scm_i_dynwind_pthread_mutex_lock (&fluid_admin_mutex);
+
+ if ((allocated_fluids_len > 0) &&
+ (allocated_fluids_num == allocated_fluids_len))
+ {
+ /* All fluid numbers are in use. Run a GC to try to free some
+ up.
+ */
+ scm_gc ();
+ }
+
+ if (allocated_fluids_num < allocated_fluids_len)
+ {
+ for (n = 0; n < allocated_fluids_len; n++)
+ if (allocated_fluids[n] == 0)
+ break;
+ }
+ else
+ {
+ /* During the following call, the GC might run and elements of
+ allocated_fluids might bet set to zero. Also,
+ allocated_fluids and allocated_fluids_len are used to scan
+ all dynamic states during GC. Thus we need to make sure that
+ no GC can run while updating these two variables.
+ */
+
+ char *new_allocated_fluids =
+ scm_malloc (allocated_fluids_len + FLUID_GROW);
+
+ /* Copy over old values and initialize rest. GC can not run
+ during these two operations since there is no safe point in
+ them.
+ */
+ memcpy (new_allocated_fluids, allocated_fluids, allocated_fluids_len);
+ memset (new_allocated_fluids + allocated_fluids_len, 0, FLUID_GROW);
+ n = allocated_fluids_len;
+ allocated_fluids = new_allocated_fluids;
+ allocated_fluids_len += FLUID_GROW;
+
+ /* Now allocated_fluids and allocated_fluids_len are valid again
+ and we can allow GCs to occur.
+ */
+ resize_all_states ();
+ }
+
+ allocated_fluids_num += 1;
+ allocated_fluids[n] = 1;
+
+ scm_dynwind_end ();
return n;
}
SCM_DEFINE (scm_make_fluid, "make-fluid", 0, 0, 0,
(),
"Return a newly created fluid.\n"
- "Fluids are objects of a certain type (a smob) that can hold one SCM\n"
- "value per dynamic root. That is, modifications to this value are\n"
- "only visible to code that executes within the same dynamic root as\n"
- "the modifying code. When a new dynamic root is constructed, it\n"
- "inherits the values from its parent. Because each thread executes\n"
- "in its own dynamic root, you can use fluids for thread local storage.")
+ "Fluids are objects that can hold one\n"
+ "value per dynamic state. That is, modifications to this value are\n"
+ "only visible to code that executes with the same dynamic state as\n"
+ "the modifying code. When a new dynamic state is constructed, it\n"
+ "inherits the values from its parent. Because each thread normally executes\n"
+ "with its own dynamic state, you can use fluids for thread local storage.")
#define FUNC_NAME s_scm_make_fluid
{
- long n;
+ SCM fluid;
+
+ SCM_NEWSMOB2 (fluid, tc16_fluid,
+ (scm_t_bits) next_fluid_num (), SCM_UNPACK (SCM_EOL));
+
+ /* The GC must not run until the fluid is properly entered into the
+ list.
+ */
+ scm_i_scm_pthread_mutex_lock (&fluid_admin_mutex);
+ SET_FLUID_NEXT (fluid, all_fluids);
+ all_fluids = fluid;
+ scm_i_pthread_mutex_unlock (&fluid_admin_mutex);
- n = next_fluid_num ();
- SCM_RETURN_NEWSMOB (scm_tc16_fluid, n);
+ return fluid;
}
#undef FUNC_NAME
"@code{#f}.")
#define FUNC_NAME s_scm_fluid_p
{
- return SCM_BOOL(SCM_FLUIDP (obj));
+ return scm_from_bool (IS_FLUID (obj));
}
#undef FUNC_NAME
+int
+scm_is_fluid (SCM obj)
+{
+ return IS_FLUID (obj);
+}
+
+size_t
+scm_i_fluid_num (SCM fluid)
+{
+ return FLUID_NUM (fluid);
+}
+
SCM_DEFINE (scm_fluid_ref, "fluid-ref", 1, 0, 0,
(SCM fluid),
"Return the value associated with @var{fluid} in the current\n"
"@code{#f}.")
#define FUNC_NAME s_scm_fluid_ref
{
- unsigned long int n;
+ SCM fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
SCM_VALIDATE_FLUID (1, fluid);
- n = SCM_FLUID_NUM (fluid);
-
- if (SCM_VECTOR_LENGTH (scm_root->fluids) <= n)
- grow_fluids (scm_root, n+1);
- return SCM_VELTS (scm_root->fluids)[n];
+ return SCM_SIMPLE_VECTOR_REF (fluids, FLUID_NUM (fluid));
}
#undef FUNC_NAME
+SCM
+scm_i_fast_fluid_ref (size_t n)
+{
+ SCM fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
+ return SCM_SIMPLE_VECTOR_REF (fluids, n);
+}
+
SCM_DEFINE (scm_fluid_set_x, "fluid-set!", 2, 0, 0,
(SCM fluid, SCM value),
"Set the value associated with @var{fluid} in the current dynamic root.")
#define FUNC_NAME s_scm_fluid_set_x
{
- unsigned long int n;
+ SCM fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
SCM_VALIDATE_FLUID (1, fluid);
- n = SCM_FLUID_NUM (fluid);
-
- if (SCM_VECTOR_LENGTH (scm_root->fluids) <= n)
- grow_fluids (scm_root, n+1);
- SCM_VELTS (scm_root->fluids)[n] = value;
+ SCM_SIMPLE_VECTOR_SET (fluids, FLUID_NUM (fluid), value);
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
void
-scm_swap_fluids (SCM fluids, SCM vals)
+scm_i_fast_fluid_set_x (size_t n, SCM value)
{
+ SCM fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
+ SCM_SIMPLE_VECTOR_SET (fluids, n, value);
+}
+
+static void
+swap_fluids (SCM data)
+{
+ SCM fluids = SCM_CAR (data), vals = SCM_CDR (data);
+
while (!SCM_NULL_OR_NIL_P (fluids))
{
SCM fl = SCM_CAR (fluids);
}
/* Swap the fluid values in reverse order. This is important when the
-same fluid appears multiple times in the fluids list. */
+ same fluid appears multiple times in the fluids list.
+*/
-void
-scm_swap_fluids_reverse (SCM fluids, SCM vals)
+static void
+swap_fluids_reverse_aux (SCM fluids, SCM vals)
{
if (!SCM_NULL_OR_NIL_P (fluids))
{
SCM fl, old_val;
- scm_swap_fluids_reverse (SCM_CDR (fluids), SCM_CDR (vals));
+ swap_fluids_reverse_aux (SCM_CDR (fluids), SCM_CDR (vals));
fl = SCM_CAR (fluids);
old_val = scm_fluid_ref (fl);
scm_fluid_set_x (fl, SCM_CAR (vals));
}
}
+static void
+swap_fluids_reverse (SCM data)
+{
+ swap_fluids_reverse_aux (SCM_CAR (data), SCM_CDR (data));
+}
static SCM
apply_thunk (void *thunk)
"one after another. @var{thunk} must be a procedure with no argument.")
#define FUNC_NAME s_scm_with_fluids
{
- return scm_c_with_fluids (fluids, values, apply_thunk, (void *) SCM_UNPACK (thunk));
+ return scm_c_with_fluids (fluids, values,
+ apply_thunk, (void *) SCM_UNPACK (thunk));
}
#undef FUNC_NAME
scm_c_with_fluids (SCM fluids, SCM values, SCM (*cproc) (), void *cdata)
#define FUNC_NAME "scm_c_with_fluids"
{
- SCM ans;
+ SCM ans, data;
long flen, vlen;
SCM_VALIDATE_LIST_COPYLEN (1, fluids, flen);
if (flen != vlen)
scm_out_of_range (s_scm_with_fluids, values);
- scm_swap_fluids (fluids, values);
- scm_dynwinds = scm_acons (fluids, values, scm_dynwinds);
+ if (flen == 1)
+ return scm_c_with_fluid (SCM_CAR (fluids), SCM_CAR (values),
+ cproc, cdata);
+
+ data = scm_cons (fluids, values);
+ scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE);
+ scm_dynwind_rewind_handler_with_scm (swap_fluids, data,
+ SCM_F_WIND_EXPLICITLY);
+ scm_dynwind_unwind_handler_with_scm (swap_fluids_reverse, data,
+ SCM_F_WIND_EXPLICITLY);
ans = cproc (cdata);
- scm_dynwinds = SCM_CDR (scm_dynwinds);
- scm_swap_fluids_reverse (fluids, values);
+ scm_dynwind_end ();
return ans;
}
#undef FUNC_NAME
+SCM_DEFINE (scm_with_fluid, "with-fluid*", 3, 0, 0,
+ (SCM fluid, SCM value, SCM thunk),
+ "Set @var{fluid} to @var{value} temporarily, and call @var{thunk}.\n"
+ "@var{thunk} must be a procedure with no argument.")
+#define FUNC_NAME s_scm_with_fluid
+{
+ return scm_c_with_fluid (fluid, value,
+ apply_thunk, (void *) SCM_UNPACK (thunk));
+}
+#undef FUNC_NAME
+
SCM
scm_c_with_fluid (SCM fluid, SCM value, SCM (*cproc) (), void *cdata)
#define FUNC_NAME "scm_c_with_fluid"
{
- return scm_c_with_fluids (scm_list_1 (fluid), scm_list_1 (value),
- cproc, cdata);
+ SCM ans;
+
+ scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE);
+ scm_dynwind_fluid (fluid, value);
+ ans = cproc (cdata);
+ scm_dynwind_end ();
+ return ans;
+}
+#undef FUNC_NAME
+
+static void
+swap_fluid (SCM data)
+{
+ SCM f = SCM_CAR (data);
+ SCM t = scm_fluid_ref (f);
+ scm_fluid_set_x (f, SCM_CDR (data));
+ SCM_SETCDR (data, t);
+}
+
+void
+scm_dynwind_fluid (SCM fluid, SCM value)
+{
+ SCM data = scm_cons (fluid, value);
+ scm_dynwind_rewind_handler_with_scm (swap_fluid, data, SCM_F_WIND_EXPLICITLY);
+ scm_dynwind_unwind_handler_with_scm (swap_fluid, data, SCM_F_WIND_EXPLICITLY);
+}
+
+SCM
+scm_i_make_initial_dynamic_state ()
+{
+ SCM fluids = scm_c_make_vector (allocated_fluids_len, SCM_BOOL_F);
+ SCM state;
+ SCM_NEWSMOB2 (state, tc16_dynamic_state,
+ SCM_UNPACK (fluids), SCM_UNPACK (SCM_EOL));
+ all_dynamic_states = state;
+ return state;
+}
+
+SCM_DEFINE (scm_make_dynamic_state, "make-dynamic-state", 0, 1, 0,
+ (SCM parent),
+ "Return a copy of the dynamic state object @var{parent}\n"
+ "or of the current dynamic state when @var{parent} is omitted.")
+#define FUNC_NAME s_scm_make_dynamic_state
+{
+ SCM fluids, state;
+
+ if (SCM_UNBNDP (parent))
+ parent = scm_current_dynamic_state ();
+
+ scm_assert_smob_type (tc16_dynamic_state, parent);
+ fluids = scm_vector_copy (DYNAMIC_STATE_FLUIDS (parent));
+ SCM_NEWSMOB2 (state, tc16_dynamic_state,
+ SCM_UNPACK (fluids), SCM_UNPACK (SCM_EOL));
+
+ /* The GC must not run until the state is properly entered into the
+ list.
+ */
+ scm_i_scm_pthread_mutex_lock (&fluid_admin_mutex);
+ SET_DYNAMIC_STATE_NEXT (state, all_dynamic_states);
+ all_dynamic_states = state;
+ scm_i_pthread_mutex_unlock (&fluid_admin_mutex);
+
+ return state;
+}
+#undef FUNC_NAME
+
+SCM_DEFINE (scm_dynamic_state_p, "dynamic-state?", 1, 0, 0,
+ (SCM obj),
+ "Return @code{#t} if @var{obj} is a dynamic state object;\n"
+ "return @code{#f} otherwise")
+#define FUNC_NAME s_scm_dynamic_state_p
+{
+ return scm_from_bool (IS_DYNAMIC_STATE (obj));
+}
+#undef FUNC_NAME
+
+int
+scm_is_dynamic_state (SCM obj)
+{
+ return IS_DYNAMIC_STATE (obj);
+}
+
+SCM_DEFINE (scm_current_dynamic_state, "current-dynamic-state", 0, 0, 0,
+ (),
+ "Return the current dynamic state object.")
+#define FUNC_NAME s_scm_current_dynamic_state
+{
+ return SCM_I_CURRENT_THREAD->dynamic_state;
+}
+#undef FUNC_NAME
+
+SCM_DEFINE (scm_set_current_dynamic_state, "set-current-dynamic-state", 1,0,0,
+ (SCM state),
+ "Set the current dynamic state object to @var{state}\n"
+ "and return the previous current dynamic state object.")
+#define FUNC_NAME s_scm_set_current_dynamic_state
+{
+ scm_i_thread *t = SCM_I_CURRENT_THREAD;
+ SCM old = t->dynamic_state;
+ scm_assert_smob_type (tc16_dynamic_state, state);
+ t->dynamic_state = state;
+ return old;
}
#undef FUNC_NAME
+static void
+swap_dynamic_state (SCM loc)
+{
+ SCM_SETCAR (loc, scm_set_current_dynamic_state (SCM_CAR (loc)));
+}
+
+void
+scm_dynwind_current_dynamic_state (SCM state)
+{
+ SCM loc = scm_cons (state, SCM_EOL);
+ scm_assert_smob_type (tc16_dynamic_state, state);
+ scm_dynwind_rewind_handler_with_scm (swap_dynamic_state, loc,
+ SCM_F_WIND_EXPLICITLY);
+ scm_dynwind_unwind_handler_with_scm (swap_dynamic_state, loc,
+ SCM_F_WIND_EXPLICITLY);
+}
+
+void *
+scm_c_with_dynamic_state (SCM state, void *(*func)(void *), void *data)
+{
+ void *result;
+ scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE);
+ scm_dynwind_current_dynamic_state (state);
+ result = func (data);
+ scm_dynwind_end ();
+ return result;
+}
+
+SCM_DEFINE (scm_with_dynamic_state, "with-dynamic-state", 2, 0, 0,
+ (SCM state, SCM proc),
+ "Call @var{proc} while @var{state} is the current dynamic\n"
+ "state object.")
+#define FUNC_NAME s_scm_with_dynamic_state
+{
+ SCM result;
+ scm_dynwind_begin (SCM_F_DYNWIND_REWINDABLE);
+ scm_dynwind_current_dynamic_state (state);
+ result = scm_call_0 (proc);
+ scm_dynwind_end ();
+ return result;
+}
+#undef FUNC_NAME
+
+void
+scm_fluids_prehistory ()
+{
+ tc16_fluid = scm_make_smob_type ("fluid", 0);
+ scm_set_smob_free (tc16_fluid, fluid_free);
+ scm_set_smob_print (tc16_fluid, fluid_print);
+
+ tc16_dynamic_state = scm_make_smob_type ("dynamic-state", 0);
+ scm_set_smob_mark (tc16_dynamic_state, scm_markcdr);
+
+ scm_c_hook_add (&scm_after_sweep_c_hook, scan_dynamic_states_and_fluids,
+ 0, 0);
+}
+
void
scm_init_fluids ()
{
- scm_tc16_fluid = scm_make_smob_type ("fluid", 0);
- scm_set_smob_print (scm_tc16_fluid, fluid_print);
#include "libguile/fluids.x"
}
HCoop / bpt / guile.git / blobdiff