-/* Copyright (C) 1996,1997,2000,2001 Free Software Foundation, Inc.
+/* Copyright (C) 1996,1997,2000,2001, 2004, 2006, 2007, 2008 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
+ */
-/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999,
- gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
#include "libguile/_scm.h"
#include "libguile/print.h"
#include "libguile/eval.h"
#include "libguile/ports.h"
#include "libguile/deprecation.h"
-
-#define INITIAL_FLUIDS 10
+#include "libguile/lang.h"
#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.
+*/
-SCM
-scm_make_initial_fluids ()
-{
- return scm_c_make_vector (INITIAL_FLUIDS, SCM_BOOL_F);
-}
+static scm_i_pthread_mutex_t fluid_admin_mutex = SCM_I_PTHREAD_MUTEX_INITIALIZER;
+
+/* 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))
+
+
+\f
+/* Grow STATE so that it can hold up to ALLOCATED_FLUIDS_NUM fluids. */
static void
-grow_fluids (scm_root_state *root_state, int new_length)
+grow_dynamic_state (SCM state)
{
- SCM old_fluids, new_fluids;
- long old_length, i;
-
- 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)
- {
- SCM_VELTS(new_fluids)[i] = SCM_VELTS(old_fluids)[i];
- i++;
- }
- while (i < new_length)
+ SCM new_fluids;
+ SCM old_fluids = DYNAMIC_STATE_FLUIDS (state);
+ size_t i, new_len, old_len = SCM_SIMPLE_VECTOR_LENGTH (old_fluids);
+
+ retry:
+ new_len = allocated_fluids_num;
+ new_fluids = scm_c_make_vector (new_len, SCM_BOOL_F);
+
+ scm_i_pthread_mutex_lock (&fluid_admin_mutex);
+ if (new_len != allocated_fluids_num)
{
- SCM_VELTS(new_fluids)[i] = SCM_BOOL_F;
- i++;
+ /* We lost the race. */
+ scm_i_pthread_mutex_unlock (&fluid_admin_mutex);
+ goto retry;
}
- root_state->fluids = new_fluids;
-}
+ assert (allocated_fluids_num > old_len);
-void
-scm_copy_fluids (scm_root_state *root_state)
-{
- grow_fluids (root_state, SCM_VECTOR_LENGTH (root_state->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);
+
+ scm_i_pthread_mutex_unlock (&fluid_admin_mutex);
}
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
+ {
+ /* Grow the vector of allocated fluids. */
+ /* FIXME: Since we use `scm_malloc ()', ALLOCATED_FLUIDS is scanned by
+ the GC; therefore, all fluids remain reachable for the entire
+ program lifetime. Hopefully this is not a problem in practice. */
+ char *prev_allocated_fluids;
+ 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;
+
+ prev_allocated_fluids = allocated_fluids;
+
+ /* Update the vector of allocated fluids. Dynamic states will
+ eventually be lazily grown to accomodate the new value of
+ ALLOCATED_FLUIDS_LEN in `fluid-ref' and `fluid-set!'. */
+ allocated_fluids = new_allocated_fluids;
+ allocated_fluids_len += FLUID_GROW;
+
+ if (prev_allocated_fluids != NULL)
+ free (prev_allocated_fluids);
+ }
+
+ 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;
- n = next_fluid_num ();
- SCM_RETURN_NEWSMOB (scm_tc16_fluid, n);
+ SCM_NEWSMOB2 (fluid, tc16_fluid,
+ (scm_t_bits) next_fluid_num (), SCM_UNPACK (SCM_EOL));
+
+ 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);
+}
+
+
+
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
{
- long n;
+ SCM fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
SCM_VALIDATE_FLUID (1, fluid);
- n = SCM_FLUID_NUM (fluid);
+ if (SCM_UNLIKELY (FLUID_NUM (fluid) >= SCM_SIMPLE_VECTOR_LENGTH (fluids)))
+ {
+ /* We should only get there when the current thread's dynamic state
+ turns out to be too small compared to the set of currently allocated
+ fluids. */
+ assert (SCM_SIMPLE_VECTOR_LENGTH (fluids) < allocated_fluids_num);
+
+ /* Lazily grow the current thread's dynamic state. */
+ grow_dynamic_state (SCM_I_CURRENT_THREAD->dynamic_state);
- if (SCM_VECTOR_LENGTH (scm_root->fluids) <= n)
- grow_fluids (scm_root, n+1);
- return SCM_VELTS (scm_root->fluids)[n];
+ fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
+ }
+
+ return SCM_SIMPLE_VECTOR_REF (fluids, FLUID_NUM (fluid));
}
#undef FUNC_NAME
"Set the value associated with @var{fluid} in the current dynamic root.")
#define FUNC_NAME s_scm_fluid_set_x
{
- long 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;
+ if (SCM_UNLIKELY (FLUID_NUM (fluid) >= SCM_SIMPLE_VECTOR_LENGTH (fluids)))
+ {
+ /* We should only get there when the current thread's dynamic state
+ turns out to be too small compared to the set of currently allocated
+ fluids. */
+ assert (SCM_SIMPLE_VECTOR_LENGTH (fluids) < allocated_fluids_num);
+
+ /* Lazily grow the current thread's dynamic state. */
+ grow_dynamic_state (SCM_I_CURRENT_THREAD->dynamic_state);
+
+ fluids = DYNAMIC_STATE_FLUIDS (SCM_I_CURRENT_THREAD->dynamic_state);
+ }
+
+ SCM_SIMPLE_VECTOR_SET (fluids, FLUID_NUM (fluid), value);
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
-void
-scm_swap_fluids (SCM fluids, SCM vals)
+static void
+swap_fluids (SCM data)
{
- while (!SCM_NULLP (fluids))
+ SCM fluids = SCM_CAR (data), vals = SCM_CDR (data);
+
+ while (!SCM_NULL_OR_NIL_P (fluids))
{
SCM fl = SCM_CAR (fluids);
SCM old_val = scm_fluid_ref (fl);
}
/* 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_NULLP (fluids))
+ 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)
{
- return scm_apply (SCM_PACK (thunk), SCM_EOL, SCM_EOL);
+ return scm_call_0 (SCM_PACK (thunk));
}
SCM_DEFINE (scm_with_fluids, "with-fluids*", 3, 0, 0,
"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_LIST1 (fluid), SCM_LIST1 (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
-void
-scm_init_fluids ()
+static void
+swap_fluid (SCM data)
{
- scm_tc16_fluid = scm_make_smob_type ("fluid", 0);
- scm_set_smob_print (scm_tc16_fluid, fluid_print);
-#ifndef SCM_MAGIC_SNARFER
-#include "libguile/fluids.x"
-#endif
+ SCM f = SCM_CAR (data);
+ SCM t = scm_fluid_ref (f);
+ scm_fluid_set_x (f, SCM_CDR (data));
+ SCM_SETCDR (data, t);
}
-#if SCM_DEBUG_DEPRECATED == 0
+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_internal_with_fluids (SCM fluids, SCM values, SCM (*cproc) (), void *cdata)
+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));
+ 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_c_issue_deprecation_warning ("`scm_internal_with_fluids' is deprecated. "
- "Use `scm_c_with_fluids' instead.");
+ SCM fluids, state;
- return scm_c_with_fluids (fluids, values, cproc, cdata);
+ 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));
+
+ return state;
}
+#undef FUNC_NAME
-#endif
+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_print (tc16_fluid, fluid_print);
+
+ tc16_dynamic_state = scm_make_smob_type ("dynamic-state", 0);
+}
+
+void
+scm_init_fluids ()
+{
+#include "libguile/fluids.x"
+}
/*
Local Variables:
HCoop / bpt / guile.git / blobdiff