\facons
+@c snarfed from alist.c:35
@deffn {Scheme Procedure} acons key value alist
@deffnx {C Function} scm_acons (key, value, alist)
Add a new key-value pair to @var{alist}. A new pair is
@end deffn
\fsloppy-assq
+@c snarfed from alist.c:49
@deffn {Scheme Procedure} sloppy-assq key alist
@deffnx {C Function} scm_sloppy_assq (key, alist)
Behaves like @code{assq} but does not do any error checking.
@end deffn
\fsloppy-assv
+@c snarfed from alist.c:67
@deffn {Scheme Procedure} sloppy-assv key alist
@deffnx {C Function} scm_sloppy_assv (key, alist)
Behaves like @code{assv} but does not do any error checking.
@end deffn
\fsloppy-assoc
+@c snarfed from alist.c:85
@deffn {Scheme Procedure} sloppy-assoc key alist
@deffnx {C Function} scm_sloppy_assoc (key, alist)
Behaves like @code{assoc} but does not do any error checking.
@end deffn
\fassq
+@c snarfed from alist.c:112
@deffn {Scheme Procedure} assq key alist
@deffnx {Scheme Procedure} assv key alist
@deffnx {Scheme Procedure} assoc key alist
@end deffn
\fassv
+@c snarfed from alist.c:133
@deffn {Scheme Procedure} assv key alist
@deffnx {C Function} scm_assv (key, alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
@end deffn
\fassoc
+@c snarfed from alist.c:154
@deffn {Scheme Procedure} assoc key alist
@deffnx {C Function} scm_assoc (key, alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
@end deffn
\fassq-ref
+@c snarfed from alist.c:198
@deffn {Scheme Procedure} assq-ref alist key
@deffnx {Scheme Procedure} assv-ref alist key
@deffnx {Scheme Procedure} assoc-ref alist key
@end deffn
\fassv-ref
+@c snarfed from alist.c:215
@deffn {Scheme Procedure} assv-ref alist key
@deffnx {C Function} scm_assv_ref (alist, key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
@end deffn
\fassoc-ref
+@c snarfed from alist.c:232
@deffn {Scheme Procedure} assoc-ref alist key
@deffnx {C Function} scm_assoc_ref (alist, key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
@end deffn
\fassq-set!
+@c snarfed from alist.c:261
@deffn {Scheme Procedure} assq-set! alist key val
@deffnx {Scheme Procedure} assv-set! alist key value
@deffnx {Scheme Procedure} assoc-set! alist key value
@end deffn
\fassv-set!
+@c snarfed from alist.c:279
@deffn {Scheme Procedure} assv-set! alist key val
@deffnx {C Function} scm_assv_set_x (alist, key, val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
@end deffn
\fassoc-set!
+@c snarfed from alist.c:297
@deffn {Scheme Procedure} assoc-set! alist key val
@deffnx {C Function} scm_assoc_set_x (alist, key, val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
@end deffn
\fassq-remove!
+@c snarfed from alist.c:321
@deffn {Scheme Procedure} assq-remove! alist key
@deffnx {Scheme Procedure} assv-remove! alist key
@deffnx {Scheme Procedure} assoc-remove! alist key
@end deffn
\fassv-remove!
+@c snarfed from alist.c:337
@deffn {Scheme Procedure} assv-remove! alist key
@deffnx {C Function} scm_assv_remove_x (alist, key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
@end deffn
\fassoc-remove!
+@c snarfed from alist.c:353
@deffn {Scheme Procedure} assoc-remove! alist key
@deffnx {C Function} scm_assoc_remove_x (alist, key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
@end deffn
\fmake-arbiter
+@c snarfed from arbiters.c:99
@deffn {Scheme Procedure} make-arbiter name
@deffnx {C Function} scm_make_arbiter (name)
-Return an object of type arbiter and name @var{name}. Its
-state is initially unlocked. Arbiters are a way to achieve
-process synchronization.
+Return an arbiter object, initially unlocked. Currently
+@var{name} is only used for diagnostic output.
@end deffn
\ftry-arbiter
+@c snarfed from arbiters.c:116
@deffn {Scheme Procedure} try-arbiter arb
@deffnx {C Function} scm_try_arbiter (arb)
-Return @code{#t} and lock the arbiter @var{arb} if the arbiter
-was unlocked. Otherwise, return @code{#f}.
+If @var{arb} is unlocked, then lock it and return @code{#t}.
+If @var{arb} is already locked, then do nothing and return
+@code{#f}.
@end deffn
\frelease-arbiter
+@c snarfed from arbiters.c:142
@deffn {Scheme Procedure} release-arbiter arb
@deffnx {C Function} scm_release_arbiter (arb)
-Return @code{#t} and unlock the arbiter @var{arb} if the
-arbiter was locked. Otherwise, return @code{#f}.
+If @var{arb} is locked, then unlock it and return @code{#t}.
+If @var{arb} is already unlocked, then do nothing and return
+@code{#f}.
+
+Typical usage is for the thread which locked an arbiter to
+later release it, but that's not required, any thread can
+release it.
@end deffn
\fasync
+@c snarfed from async.c:97
@deffn {Scheme Procedure} async thunk
@deffnx {C Function} scm_async (thunk)
Create a new async for the procedure @var{thunk}.
@end deffn
\fasync-mark
+@c snarfed from async.c:106
@deffn {Scheme Procedure} async-mark a
@deffnx {C Function} scm_async_mark (a)
Mark the async @var{a} for future execution.
@end deffn
\frun-asyncs
+@c snarfed from async.c:117
@deffn {Scheme Procedure} run-asyncs list_of_a
@deffnx {C Function} scm_run_asyncs (list_of_a)
Execute all thunks from the asyncs of the list @var{list_of_a}.
@end deffn
-\fsystem-async
-@deffn {Scheme Procedure} system-async thunk
-@deffnx {C Function} scm_system_async (thunk)
-This function is deprecated. You can use @var{thunk} directly
-instead of explicitely creating an async object.
-
-@end deffn
-
\fsystem-async-mark
+@c snarfed from async.c:222
@deffn {Scheme Procedure} system-async-mark proc [thread]
@deffnx {C Function} scm_system_async_mark_for_thread (proc, thread)
-Register the procedure @var{proc} for future execution
-in @var{thread}. When @var{thread} is not specified,
-use the current thread.
+Mark @var{proc} (a procedure with zero arguments) for future execution
+in @var{thread}. If @var{proc} has already been marked for
+@var{thread} but has not been executed yet, this call has no effect.
+If @var{thread} is omitted, the thread that called
+@code{system-async-mark} is used.
+
+This procedure is not safe to be called from C signal handlers. Use
+@code{scm_sigaction} or @code{scm_sigaction_for_thread} to install
+signal handlers.
@end deffn
\fnoop
+@c snarfed from async.c:253
@deffn {Scheme Procedure} noop . args
@deffnx {C Function} scm_noop (args)
Do nothing. When called without arguments, return @code{#f},
otherwise return the first argument.
@end deffn
-\funmask-signals
-@deffn {Scheme Procedure} unmask-signals
-@deffnx {C Function} scm_unmask_signals ()
-Unmask signals. The returned value is not specified.
-@end deffn
-
-\fmask-signals
-@deffn {Scheme Procedure} mask-signals
-@deffnx {C Function} scm_mask_signals ()
-Mask signals. The returned value is not specified.
-@end deffn
-
\fcall-with-blocked-asyncs
+@c snarfed from async.c:319
@deffn {Scheme Procedure} call-with-blocked-asyncs proc
@deffnx {C Function} scm_call_with_blocked_asyncs (proc)
Call @var{proc} with no arguments and block the execution
@end deffn
\fcall-with-unblocked-asyncs
+@c snarfed from async.c:343
@deffn {Scheme Procedure} call-with-unblocked-asyncs proc
@deffnx {C Function} scm_call_with_unblocked_asyncs (proc)
Call @var{proc} with no arguments and unblock the execution
@end deffn
\fdisplay-error
+@c snarfed from backtrace.c:303
@deffn {Scheme Procedure} display-error stack port subr message args rest
@deffnx {C Function} scm_display_error (stack, port, subr, message, args, rest)
Display an error message to the output port @var{port}.
@end deffn
\fdisplay-application
+@c snarfed from backtrace.c:446
@deffn {Scheme Procedure} display-application frame [port [indent]]
@deffnx {C Function} scm_display_application (frame, port, indent)
Display a procedure application @var{frame} to the output port
@end deffn
\fdisplay-backtrace
+@c snarfed from backtrace.c:756
@deffn {Scheme Procedure} display-backtrace stack port [first [depth]]
@deffnx {C Function} scm_display_backtrace (stack, port, first, depth)
Display a backtrace to the output port @var{port}. @var{stack}
@end deffn
\fbacktrace
+@c snarfed from backtrace.c:779
@deffn {Scheme Procedure} backtrace
@deffnx {C Function} scm_backtrace ()
Display a backtrace of the stack saved by the last error
@end deffn
\fnot
+@c snarfed from boolean.c:33
@deffn {Scheme Procedure} not x
@deffnx {C Function} scm_not (x)
Return @code{#t} iff @var{x} is @code{#f}, else return @code{#f}.
@end deffn
\fboolean?
+@c snarfed from boolean.c:43
@deffn {Scheme Procedure} boolean? obj
@deffnx {C Function} scm_boolean_p (obj)
Return @code{#t} iff @var{obj} is either @code{#t} or @code{#f}.
@end deffn
\fchar?
+@c snarfed from chars.c:31
@deffn {Scheme Procedure} char? x
@deffnx {C Function} scm_char_p (x)
Return @code{#t} iff @var{x} is a character, else @code{#f}.
@end deffn
\fchar=?
+@c snarfed from chars.c:40
@deffn {Scheme Procedure} char=? x y
Return @code{#t} iff @var{x} is the same character as @var{y}, else @code{#f}.
@end deffn
\fchar<?
+@c snarfed from chars.c:53
@deffn {Scheme Procedure} char<? x y
Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence,
else @code{#f}.
@end deffn
\fchar<=?
+@c snarfed from chars.c:65
@deffn {Scheme Procedure} char<=? x y
Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
ASCII sequence, else @code{#f}.
@end deffn
\fchar>?
+@c snarfed from chars.c:77
@deffn {Scheme Procedure} char>? x y
Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
sequence, else @code{#f}.
@end deffn
\fchar>=?
+@c snarfed from chars.c:89
@deffn {Scheme Procedure} char>=? x y
Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
ASCII sequence, else @code{#f}.
@end deffn
\fchar-ci=?
+@c snarfed from chars.c:101
@deffn {Scheme Procedure} char-ci=? x y
Return @code{#t} iff @var{x} is the same character as @var{y} ignoring
case, else @code{#f}.
@end deffn
\fchar-ci<?
+@c snarfed from chars.c:113
@deffn {Scheme Procedure} char-ci<? x y
Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence
ignoring case, else @code{#f}.
@end deffn
\fchar-ci<=?
+@c snarfed from chars.c:125
@deffn {Scheme Procedure} char-ci<=? x y
Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
ASCII sequence ignoring case, else @code{#f}.
@end deffn
\fchar-ci>?
+@c snarfed from chars.c:137
@deffn {Scheme Procedure} char-ci>? x y
Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
sequence ignoring case, else @code{#f}.
@end deffn
\fchar-ci>=?
+@c snarfed from chars.c:149
@deffn {Scheme Procedure} char-ci>=? x y
Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
ASCII sequence ignoring case, else @code{#f}.
@end deffn
\fchar-alphabetic?
+@c snarfed from chars.c:162
@deffn {Scheme Procedure} char-alphabetic? chr
@deffnx {C Function} scm_char_alphabetic_p (chr)
Return @code{#t} iff @var{chr} is alphabetic, else @code{#f}.
@end deffn
\fchar-numeric?
+@c snarfed from chars.c:173
@deffn {Scheme Procedure} char-numeric? chr
@deffnx {C Function} scm_char_numeric_p (chr)
Return @code{#t} iff @var{chr} is numeric, else @code{#f}.
@end deffn
\fchar-whitespace?
+@c snarfed from chars.c:184
@deffn {Scheme Procedure} char-whitespace? chr
@deffnx {C Function} scm_char_whitespace_p (chr)
Return @code{#t} iff @var{chr} is whitespace, else @code{#f}.
@end deffn
\fchar-upper-case?
+@c snarfed from chars.c:197
@deffn {Scheme Procedure} char-upper-case? chr
@deffnx {C Function} scm_char_upper_case_p (chr)
Return @code{#t} iff @var{chr} is uppercase, else @code{#f}.
@end deffn
\fchar-lower-case?
+@c snarfed from chars.c:209
@deffn {Scheme Procedure} char-lower-case? chr
@deffnx {C Function} scm_char_lower_case_p (chr)
Return @code{#t} iff @var{chr} is lowercase, else @code{#f}.
@end deffn
\fchar-is-both?
+@c snarfed from chars.c:223
@deffn {Scheme Procedure} char-is-both? chr
@deffnx {C Function} scm_char_is_both_p (chr)
Return @code{#t} iff @var{chr} is either uppercase or lowercase, else @code{#f}.
@end deffn
\fchar->integer
+@c snarfed from chars.c:237
@deffn {Scheme Procedure} char->integer chr
@deffnx {C Function} scm_char_to_integer (chr)
Return the number corresponding to ordinal position of @var{chr} in the
@end deffn
\finteger->char
+@c snarfed from chars.c:249
@deffn {Scheme Procedure} integer->char n
@deffnx {C Function} scm_integer_to_char (n)
Return the character at position @var{n} in the ASCII sequence.
@end deffn
\fchar-upcase
+@c snarfed from chars.c:259
@deffn {Scheme Procedure} char-upcase chr
@deffnx {C Function} scm_char_upcase (chr)
Return the uppercase character version of @var{chr}.
@end deffn
\fchar-downcase
+@c snarfed from chars.c:270
@deffn {Scheme Procedure} char-downcase chr
@deffnx {C Function} scm_char_downcase (chr)
Return the lowercase character version of @var{chr}.
@end deffn
\fdebug-options-interface
+@c snarfed from debug.c:53
@deffn {Scheme Procedure} debug-options-interface [setting]
@deffnx {C Function} scm_debug_options (setting)
Option interface for the debug options. Instead of using
@end deffn
\fwith-traps
+@c snarfed from debug.c:96
@deffn {Scheme Procedure} with-traps thunk
@deffnx {C Function} scm_with_traps (thunk)
Call @var{thunk} with traps enabled.
@end deffn
\fmemoized?
+@c snarfed from debug.c:134
@deffn {Scheme Procedure} memoized? obj
@deffnx {C Function} scm_memoized_p (obj)
Return @code{#t} if @var{obj} is memoized.
@end deffn
-\funmemoize
-@deffn {Scheme Procedure} unmemoize m
-@deffnx {C Function} scm_unmemoize (m)
+\funmemoize-expr
+@c snarfed from debug.c:271
+@deffn {Scheme Procedure} unmemoize-expr m
+@deffnx {C Function} scm_i_unmemoize_expr (m)
Unmemoize the memoized expression @var{m},
@end deffn
\fmemoized-environment
+@c snarfed from debug.c:281
@deffn {Scheme Procedure} memoized-environment m
@deffnx {C Function} scm_memoized_environment (m)
Return the environment of the memoized expression @var{m}.
@end deffn
\fprocedure-name
+@c snarfed from debug.c:291
@deffn {Scheme Procedure} procedure-name proc
@deffnx {C Function} scm_procedure_name (proc)
Return the name of the procedure @var{proc}
@end deffn
\fprocedure-source
+@c snarfed from debug.c:317
@deffn {Scheme Procedure} procedure-source proc
@deffnx {C Function} scm_procedure_source (proc)
Return the source of the procedure @var{proc}.
@end deffn
\fprocedure-environment
+@c snarfed from debug.c:374
@deffn {Scheme Procedure} procedure-environment proc
@deffnx {C Function} scm_procedure_environment (proc)
Return the environment of the procedure @var{proc}.
@end deffn
\flocal-eval
+@c snarfed from debug.c:406
@deffn {Scheme Procedure} local-eval exp [env]
@deffnx {C Function} scm_local_eval (exp, env)
Evaluate @var{exp} in its environment. If @var{env} is supplied,
@end deffn
\fdebug-object?
+@c snarfed from debug.c:493
@deffn {Scheme Procedure} debug-object? obj
@deffnx {C Function} scm_debug_object_p (obj)
Return @code{#t} if @var{obj} is a debug object.
@end deffn
+\finclude-deprecated-features
+@c snarfed from deprecation.c:144
+@deffn {Scheme Procedure} include-deprecated-features
+@deffnx {C Function} scm_include_deprecated_features ()
+Return @code{#t} iff deprecated features should be included in public interfaces.
+@end deffn
+
\fdynamic-link
+@c snarfed from dynl.c:149
@deffn {Scheme Procedure} dynamic-link filename
@deffnx {C Function} scm_dynamic_link (filename)
Find the shared object (shared library) denoted by
@end deffn
\fdynamic-object?
+@c snarfed from dynl.c:168
@deffn {Scheme Procedure} dynamic-object? obj
@deffnx {C Function} scm_dynamic_object_p (obj)
Return @code{#t} if @var{obj} is a dynamic object handle,
@end deffn
\fdynamic-unlink
+@c snarfed from dynl.c:182
@deffn {Scheme Procedure} dynamic-unlink dobj
@deffnx {C Function} scm_dynamic_unlink (dobj)
Unlink a dynamic object from the application, if possible. The
@end deffn
\fdynamic-func
+@c snarfed from dynl.c:207
@deffn {Scheme Procedure} dynamic-func name dobj
@deffnx {C Function} scm_dynamic_func (name, dobj)
Return a ``handle'' for the function @var{name} in the
@end deffn
\fdynamic-call
+@c snarfed from dynl.c:253
@deffn {Scheme Procedure} dynamic-call func dobj
@deffnx {C Function} scm_dynamic_call (func, dobj)
Call a C function in a dynamic object. Two styles of
@end deffn
\fdynamic-args-call
+@c snarfed from dynl.c:285
@deffn {Scheme Procedure} dynamic-args-call func dobj args
@deffnx {C Function} scm_dynamic_args_call (func, dobj, args)
Call the C function indicated by @var{func} and @var{dobj},
@end deffn
\fdynamic-wind
+@c snarfed from dynwind.c:97
@deffn {Scheme Procedure} dynamic-wind in_guard thunk out_guard
@deffnx {C Function} scm_dynamic_wind (in_guard, thunk, out_guard)
All three arguments must be 0-argument procedures.
@end deffn
\fenvironment?
+@c snarfed from environments.c:106
@deffn {Scheme Procedure} environment? obj
@deffnx {C Function} scm_environment_p (obj)
Return @code{#t} if @var{obj} is an environment, or @code{#f}
@end deffn
\fenvironment-bound?
+@c snarfed from environments.c:117
@deffn {Scheme Procedure} environment-bound? env sym
@deffnx {C Function} scm_environment_bound_p (env, sym)
Return @code{#t} if @var{sym} is bound in @var{env}, or
@end deffn
\fenvironment-ref
+@c snarfed from environments.c:132
@deffn {Scheme Procedure} environment-ref env sym
@deffnx {C Function} scm_environment_ref (env, sym)
Return the value of the location bound to @var{sym} in
@end deffn
\fenvironment-fold
+@c snarfed from environments.c:202
@deffn {Scheme Procedure} environment-fold env proc init
@deffnx {C Function} scm_environment_fold (env, proc, init)
Iterate over all the bindings in @var{env}, accumulating some
@end deffn
\fenvironment-define
+@c snarfed from environments.c:237
@deffn {Scheme Procedure} environment-define env sym val
@deffnx {C Function} scm_environment_define (env, sym, val)
Bind @var{sym} to a new location containing @var{val} in
@end deffn
\fenvironment-undefine
+@c snarfed from environments.c:263
@deffn {Scheme Procedure} environment-undefine env sym
@deffnx {C Function} scm_environment_undefine (env, sym)
Remove any binding for @var{sym} from @var{env}. If @var{sym}
@end deffn
\fenvironment-set!
+@c snarfed from environments.c:291
@deffn {Scheme Procedure} environment-set! env sym val
@deffnx {C Function} scm_environment_set_x (env, sym, val)
If @var{env} binds @var{sym} to some location, change that
@end deffn
\fenvironment-cell
+@c snarfed from environments.c:326
@deffn {Scheme Procedure} environment-cell env sym for_write
@deffnx {C Function} scm_environment_cell (env, sym, for_write)
Return the value cell which @var{env} binds to @var{sym}, or
@end deffn
\fenvironment-observe
+@c snarfed from environments.c:378
@deffn {Scheme Procedure} environment-observe env proc
@deffnx {C Function} scm_environment_observe (env, proc)
Whenever @var{env}'s bindings change, apply @var{proc} to
@end deffn
\fenvironment-observe-weak
+@c snarfed from environments.c:395
@deffn {Scheme Procedure} environment-observe-weak env proc
@deffnx {C Function} scm_environment_observe_weak (env, proc)
This function is the same as environment-observe, except that
@end deffn
\fenvironment-unobserve
+@c snarfed from environments.c:431
@deffn {Scheme Procedure} environment-unobserve token
@deffnx {C Function} scm_environment_unobserve (token)
Cancel the observation request which returned the value
@end deffn
\fmake-leaf-environment
+@c snarfed from environments.c:1015
@deffn {Scheme Procedure} make-leaf-environment
@deffnx {C Function} scm_make_leaf_environment ()
Create a new leaf environment, containing no bindings.
@end deffn
\fleaf-environment?
+@c snarfed from environments.c:1038
@deffn {Scheme Procedure} leaf-environment? object
@deffnx {C Function} scm_leaf_environment_p (object)
Return @code{#t} if object is a leaf environment, or @code{#f}
@end deffn
\fmake-eval-environment
+@c snarfed from environments.c:1403
@deffn {Scheme Procedure} make-eval-environment local imported
@deffnx {C Function} scm_make_eval_environment (local, imported)
Return a new environment object eval whose bindings are the
@end deffn
\feval-environment?
+@c snarfed from environments.c:1440
@deffn {Scheme Procedure} eval-environment? object
@deffnx {C Function} scm_eval_environment_p (object)
Return @code{#t} if object is an eval environment, or @code{#f}
@end deffn
\feval-environment-local
+@c snarfed from environments.c:1450
@deffn {Scheme Procedure} eval-environment-local env
@deffnx {C Function} scm_eval_environment_local (env)
Return the local environment of eval environment @var{env}.
@end deffn
\feval-environment-set-local!
+@c snarfed from environments.c:1462
@deffn {Scheme Procedure} eval-environment-set-local! env local
@deffnx {C Function} scm_eval_environment_set_local_x (env, local)
Change @var{env}'s local environment to @var{local}.
@end deffn
\feval-environment-imported
+@c snarfed from environments.c:1488
@deffn {Scheme Procedure} eval-environment-imported env
@deffnx {C Function} scm_eval_environment_imported (env)
Return the imported environment of eval environment @var{env}.
@end deffn
\feval-environment-set-imported!
+@c snarfed from environments.c:1500
@deffn {Scheme Procedure} eval-environment-set-imported! env imported
@deffnx {C Function} scm_eval_environment_set_imported_x (env, imported)
Change @var{env}'s imported environment to @var{imported}.
@end deffn
\fmake-import-environment
+@c snarfed from environments.c:1823
@deffn {Scheme Procedure} make-import-environment imports conflict_proc
@deffnx {C Function} scm_make_import_environment (imports, conflict_proc)
Return a new environment @var{imp} whose bindings are the union
@end deffn
\fimport-environment?
+@c snarfed from environments.c:1852
@deffn {Scheme Procedure} import-environment? object
@deffnx {C Function} scm_import_environment_p (object)
Return @code{#t} if object is an import environment, or
@end deffn
\fimport-environment-imports
+@c snarfed from environments.c:1863
@deffn {Scheme Procedure} import-environment-imports env
@deffnx {C Function} scm_import_environment_imports (env)
Return the list of environments imported by the import
@end deffn
\fimport-environment-set-imports!
+@c snarfed from environments.c:1876
@deffn {Scheme Procedure} import-environment-set-imports! env imports
@deffnx {C Function} scm_import_environment_set_imports_x (env, imports)
Change @var{env}'s list of imported environments to
@end deffn
\fmake-export-environment
+@c snarfed from environments.c:2143
@deffn {Scheme Procedure} make-export-environment private signature
@deffnx {C Function} scm_make_export_environment (private, signature)
Return a new environment @var{exp} containing only those
@end deffn
\fexport-environment?
+@c snarfed from environments.c:2178
@deffn {Scheme Procedure} export-environment? object
@deffnx {C Function} scm_export_environment_p (object)
Return @code{#t} if object is an export environment, or
@end deffn
\fexport-environment-private
+@c snarfed from environments.c:2188
@deffn {Scheme Procedure} export-environment-private env
@deffnx {C Function} scm_export_environment_private (env)
Return the private environment of export environment @var{env}.
@end deffn
\fexport-environment-set-private!
+@c snarfed from environments.c:2200
@deffn {Scheme Procedure} export-environment-set-private! env private
@deffnx {C Function} scm_export_environment_set_private_x (env, private)
Change the private environment of export environment @var{env}.
@end deffn
\fexport-environment-signature
+@c snarfed from environments.c:2222
@deffn {Scheme Procedure} export-environment-signature env
@deffnx {C Function} scm_export_environment_signature (env)
Return the signature of export environment @var{env}.
@end deffn
\fexport-environment-set-signature!
+@c snarfed from environments.c:2296
@deffn {Scheme Procedure} export-environment-set-signature! env signature
@deffnx {C Function} scm_export_environment_set_signature_x (env, signature)
Change the signature of export environment @var{env}.
@end deffn
\feq?
+@c snarfed from eq.c:47
@deffn {Scheme Procedure} eq? x y
Return @code{#t} iff @var{x} references the same object as @var{y}.
@code{eq?} is similar to @code{eqv?} except that in some cases it is
@end deffn
\feqv?
+@c snarfed from eq.c:71
@deffn {Scheme Procedure} eqv? x y
The @code{eqv?} procedure defines a useful equivalence relation on objects.
Briefly, it returns @code{#t} if @var{x} and @var{y} should normally be
@end deffn
\fequal?
+@c snarfed from eq.c:138
@deffn {Scheme Procedure} equal? x y
Return @code{#t} iff @var{x} and @var{y} are recursively @code{eqv?} equivalent.
@code{equal?} recursively compares the contents of pairs,
@end deffn
\fscm-error
+@c snarfed from error.c:81
@deffn {Scheme Procedure} scm-error key subr message args data
@deffnx {C Function} scm_error_scm (key, subr, message, args, data)
Raise an error with key @var{key}. @var{subr} can be a string
@end deffn
\fstrerror
+@c snarfed from error.c:128
@deffn {Scheme Procedure} strerror err
@deffnx {C Function} scm_strerror (err)
Return the Unix error message corresponding to @var{err}, which
@end deffn
\fapply:nconc2last
+@c snarfed from eval.c:4697
@deffn {Scheme Procedure} apply:nconc2last lst
@deffnx {C Function} scm_nconc2last (lst)
Given a list (@var{arg1} @dots{} @var{args}), this function
@end deffn
\fforce
-@deffn {Scheme Procedure} force x
-@deffnx {C Function} scm_force (x)
+@c snarfed from eval.c:5625
+@deffn {Scheme Procedure} force promise
+@deffnx {C Function} scm_force (promise)
If the promise @var{x} has not been computed yet, compute and
return @var{x}, otherwise just return the previously computed
value.
@end deffn
\fpromise?
+@c snarfed from eval.c:5648
@deffn {Scheme Procedure} promise? obj
@deffnx {C Function} scm_promise_p (obj)
Return true if @var{obj} is a promise, i.e. a delayed computation
@end deffn
\fcons-source
+@c snarfed from eval.c:5660
@deffn {Scheme Procedure} cons-source xorig x y
@deffnx {C Function} scm_cons_source (xorig, x, y)
Create and return a new pair whose car and cdr are @var{x} and @var{y}.
@end deffn
\fcopy-tree
+@c snarfed from eval.c:5817
@deffn {Scheme Procedure} copy-tree obj
@deffnx {C Function} scm_copy_tree (obj)
Recursively copy the data tree that is bound to @var{obj}, and return a
-pointer to the new data structure. @code{copy-tree} recurses down the
+the new data structure. @code{copy-tree} recurses down the
contents of both pairs and vectors (since both cons cells and vector
cells may point to arbitrary objects), and stops recursing when it hits
any other object.
@end deffn
\fprimitive-eval
+@c snarfed from eval.c:5903
@deffn {Scheme Procedure} primitive-eval exp
@deffnx {C Function} scm_primitive_eval (exp)
Evaluate @var{exp} in the top-level environment specified by
@end deffn
\feval
+@c snarfed from eval.c:5972
@deffn {Scheme Procedure} eval exp module
@deffnx {C Function} scm_eval (exp, module)
Evaluate @var{exp}, a list representing a Scheme expression,
@end deffn
\feval-options-interface
+@c snarfed from eval.c:3087
@deffn {Scheme Procedure} eval-options-interface [setting]
@deffnx {C Function} scm_eval_options_interface (setting)
Option interface for the evaluation options. Instead of using
@end deffn
\fevaluator-traps-interface
+@c snarfed from eval.c:3105
@deffn {Scheme Procedure} evaluator-traps-interface [setting]
@deffnx {C Function} scm_evaluator_traps (setting)
Option interface for the evaluator trap options.
@end deffn
\fdefined?
+@c snarfed from evalext.c:34
@deffn {Scheme Procedure} defined? sym [env]
@deffnx {C Function} scm_defined_p (sym, env)
Return @code{#t} if @var{sym} is defined in the lexical environment @var{env}. When @var{env} is not specified, look in the top-level environment as defined by the current module.
@end deffn
\fmap-in-order
+@c snarfed from evalext.c:80
@deffn {Scheme Procedure} map-in-order
implemented by the C function "scm_map"
@end deffn
+\fself-evaluating?
+@c snarfed from evalext.c:85
+@deffn {Scheme Procedure} self-evaluating? obj
+@deffnx {C Function} scm_self_evaluating_p (obj)
+Return #t for objects which Guile considers self-evaluating
+@end deffn
+
\fload-extension
+@c snarfed from extensions.c:143
@deffn {Scheme Procedure} load-extension lib init
@deffnx {C Function} scm_load_extension (lib, init)
Load and initialize the extension designated by LIB and INIT.
@end deffn
\fprogram-arguments
+@c snarfed from feature.c:56
@deffn {Scheme Procedure} program-arguments
@deffnx {Scheme Procedure} command-line
@deffnx {C Function} scm_program_arguments ()
@end deffn
\fmake-fluid
+@c snarfed from fluids.c:100
@deffn {Scheme Procedure} make-fluid
@deffnx {C Function} scm_make_fluid ()
Return a newly created fluid.
@end deffn
\ffluid?
+@c snarfed from fluids.c:113
@deffn {Scheme Procedure} fluid? obj
@deffnx {C Function} scm_fluid_p (obj)
Return @code{#t} iff @var{obj} is a fluid; otherwise, return
@end deffn
\ffluid-ref
+@c snarfed from fluids.c:124
@deffn {Scheme Procedure} fluid-ref fluid
@deffnx {C Function} scm_fluid_ref (fluid)
Return the value associated with @var{fluid} in the current
@end deffn
\ffluid-set!
+@c snarfed from fluids.c:140
@deffn {Scheme Procedure} fluid-set! fluid value
@deffnx {C Function} scm_fluid_set_x (fluid, value)
Set the value associated with @var{fluid} in the current dynamic root.
@end deffn
\fwith-fluids*
+@c snarfed from fluids.c:206
@deffn {Scheme Procedure} with-fluids* fluids values thunk
@deffnx {C Function} scm_with_fluids (fluids, values, thunk)
Set @var{fluids} to @var{values} temporary, and call @var{thunk}.
one after another. @var{thunk} must be a procedure with no argument.
@end deffn
+\fwith-fluid*
+@c snarfed from fluids.c:245
+@deffn {Scheme Procedure} with-fluid* fluid value thunk
+@deffnx {C Function} scm_with_fluid (fluid, value, thunk)
+Set @var{fluid} to @var{value} temporarily, and call @var{thunk}.
+@var{thunk} must be a procedure with no argument.
+@end deffn
+
\fsetvbuf
+@c snarfed from fports.c:137
@deffn {Scheme Procedure} setvbuf port mode [size]
@deffnx {C Function} scm_setvbuf (port, mode, size)
Set the buffering mode for @var{port}. @var{mode} can be:
@end deffn
\ffile-port?
+@c snarfed from fports.c:230
@deffn {Scheme Procedure} file-port? obj
@deffnx {C Function} scm_file_port_p (obj)
Determine whether @var{obj} is a port that is related to a file.
@end deffn
\fopen-file
+@c snarfed from fports.c:284
@deffn {Scheme Procedure} open-file filename mode
@deffnx {C Function} scm_open_file (filename, mode)
Open the file whose name is @var{filename}, and return a port
requested, @code{open-file} throws an exception.
@end deffn
-\fset-debug-cell-accesses!
-@deffn {Scheme Procedure} set-debug-cell-accesses! flag
-@deffnx {C Function} scm_set_debug_cell_accesses_x (flag)
-This function is used to turn on checking for a debug version of GUILE. This version does not support this functionality
+\fmake-future
+@c snarfed from futures.c:89
+@deffn {Scheme Procedure} make-future thunk
+@deffnx {C Function} scm_make_future (thunk)
+Make a future evaluating THUNK.
+@end deffn
+\ffuture-ref
+@c snarfed from futures.c:221
+@deffn {Scheme Procedure} future-ref future
+@deffnx {C Function} scm_future_ref (future)
+If the future @var{x} has not been computed yet, compute and
+return @var{x}, otherwise just return the previously computed
+value.
@end deffn
\fgc-stats
+@c snarfed from gc.c:283
@deffn {Scheme Procedure} gc-stats
@deffnx {C Function} scm_gc_stats ()
Return an association list of statistics about Guile's current
@end deffn
\fobject-address
+@c snarfed from gc.c:419
@deffn {Scheme Procedure} object-address obj
@deffnx {C Function} scm_object_address (obj)
Return an integer that for the lifetime of @var{obj} is uniquely
@end deffn
\fgc
+@c snarfed from gc.c:430
@deffn {Scheme Procedure} gc
@deffnx {C Function} scm_gc ()
Scans all of SCM objects and reclaims for further use those that are
@end deffn
\f%compute-slots
+@c snarfed from goops.c:265
@deffn {Scheme Procedure} %compute-slots class
@deffnx {C Function} scm_sys_compute_slots (class)
Return a list consisting of the names of all slots belonging to
@end deffn
\fget-keyword
+@c snarfed from goops.c:356
@deffn {Scheme Procedure} get-keyword key l default_value
@deffnx {C Function} scm_get_keyword (key, l, default_value)
Determine an associated value for the keyword @var{key} from
@end deffn
\f%initialize-object
+@c snarfed from goops.c:379
@deffn {Scheme Procedure} %initialize-object obj initargs
@deffnx {C Function} scm_sys_initialize_object (obj, initargs)
Initialize the object @var{obj} with the given arguments
@end deffn
\f%prep-layout!
+@c snarfed from goops.c:477
@deffn {Scheme Procedure} %prep-layout! class
@deffnx {C Function} scm_sys_prep_layout_x (class)
@end deffn
\f%inherit-magic!
+@c snarfed from goops.c:576
@deffn {Scheme Procedure} %inherit-magic! class dsupers
@deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers)
@end deffn
\finstance?
+@c snarfed from goops.c:816
@deffn {Scheme Procedure} instance? obj
@deffnx {C Function} scm_instance_p (obj)
Return @code{#t} if @var{obj} is an instance.
@end deffn
\fclass-name
+@c snarfed from goops.c:831
@deffn {Scheme Procedure} class-name obj
@deffnx {C Function} scm_class_name (obj)
Return the class name of @var{obj}.
@end deffn
\fclass-direct-supers
+@c snarfed from goops.c:841
@deffn {Scheme Procedure} class-direct-supers obj
@deffnx {C Function} scm_class_direct_supers (obj)
Return the direct superclasses of the class @var{obj}.
@end deffn
\fclass-direct-slots
+@c snarfed from goops.c:851
@deffn {Scheme Procedure} class-direct-slots obj
@deffnx {C Function} scm_class_direct_slots (obj)
Return the direct slots of the class @var{obj}.
@end deffn
\fclass-direct-subclasses
+@c snarfed from goops.c:861
@deffn {Scheme Procedure} class-direct-subclasses obj
@deffnx {C Function} scm_class_direct_subclasses (obj)
Return the direct subclasses of the class @var{obj}.
@end deffn
\fclass-direct-methods
+@c snarfed from goops.c:871
@deffn {Scheme Procedure} class-direct-methods obj
@deffnx {C Function} scm_class_direct_methods (obj)
Return the direct methods of the class @var{obj}
@end deffn
\fclass-precedence-list
+@c snarfed from goops.c:881
@deffn {Scheme Procedure} class-precedence-list obj
@deffnx {C Function} scm_class_precedence_list (obj)
Return the class precedence list of the class @var{obj}.
@end deffn
\fclass-slots
+@c snarfed from goops.c:891
@deffn {Scheme Procedure} class-slots obj
@deffnx {C Function} scm_class_slots (obj)
Return the slot list of the class @var{obj}.
@end deffn
\fclass-environment
+@c snarfed from goops.c:901
@deffn {Scheme Procedure} class-environment obj
@deffnx {C Function} scm_class_environment (obj)
Return the environment of the class @var{obj}.
@end deffn
\fgeneric-function-name
+@c snarfed from goops.c:912
@deffn {Scheme Procedure} generic-function-name obj
@deffnx {C Function} scm_generic_function_name (obj)
Return the name of the generic function @var{obj}.
@end deffn
\fgeneric-function-methods
+@c snarfed from goops.c:957
@deffn {Scheme Procedure} generic-function-methods obj
@deffnx {C Function} scm_generic_function_methods (obj)
Return the methods of the generic function @var{obj}.
@end deffn
\fmethod-generic-function
+@c snarfed from goops.c:970
@deffn {Scheme Procedure} method-generic-function obj
@deffnx {C Function} scm_method_generic_function (obj)
Return the generic function for the method @var{obj}.
@end deffn
\fmethod-specializers
+@c snarfed from goops.c:980
@deffn {Scheme Procedure} method-specializers obj
@deffnx {C Function} scm_method_specializers (obj)
Return specializers of the method @var{obj}.
@end deffn
\fmethod-procedure
+@c snarfed from goops.c:990
@deffn {Scheme Procedure} method-procedure obj
@deffnx {C Function} scm_method_procedure (obj)
Return the procedure of the method @var{obj}.
@end deffn
\faccessor-method-slot-definition
+@c snarfed from goops.c:1000
@deffn {Scheme Procedure} accessor-method-slot-definition obj
@deffnx {C Function} scm_accessor_method_slot_definition (obj)
Return the slot definition of the accessor @var{obj}.
@end deffn
\f%tag-body
+@c snarfed from goops.c:1010
@deffn {Scheme Procedure} %tag-body body
@deffnx {C Function} scm_sys_tag_body (body)
Internal GOOPS magic---don't use this function!
@end deffn
\fmake-unbound
+@c snarfed from goops.c:1025
@deffn {Scheme Procedure} make-unbound
@deffnx {C Function} scm_make_unbound ()
Return the unbound value.
@end deffn
\funbound?
+@c snarfed from goops.c:1034
@deffn {Scheme Procedure} unbound? obj
@deffnx {C Function} scm_unbound_p (obj)
Return @code{#t} if @var{obj} is unbound.
@end deffn
\fassert-bound
+@c snarfed from goops.c:1044
@deffn {Scheme Procedure} assert-bound value obj
@deffnx {C Function} scm_assert_bound (value, obj)
Return @var{value} if it is bound, and invoke the
@end deffn
\f@@assert-bound-ref
+@c snarfed from goops.c:1056
@deffn {Scheme Procedure} @@assert-bound-ref obj index
@deffnx {C Function} scm_at_assert_bound_ref (obj, index)
Like @code{assert-bound}, but use @var{index} for accessing
@end deffn
\f%fast-slot-ref
+@c snarfed from goops.c:1068
@deffn {Scheme Procedure} %fast-slot-ref obj index
@deffnx {C Function} scm_sys_fast_slot_ref (obj, index)
Return the slot value with index @var{index} from @var{obj}.
@end deffn
\f%fast-slot-set!
+@c snarfed from goops.c:1082
@deffn {Scheme Procedure} %fast-slot-set! obj index value
@deffnx {C Function} scm_sys_fast_slot_set_x (obj, index, value)
Set the slot with index @var{index} in @var{obj} to
@end deffn
\fslot-ref-using-class
+@c snarfed from goops.c:1219
@deffn {Scheme Procedure} slot-ref-using-class class obj slot_name
@deffnx {C Function} scm_slot_ref_using_class (class, obj, slot_name)
@end deffn
\fslot-set-using-class!
+@c snarfed from goops.c:1238
@deffn {Scheme Procedure} slot-set-using-class! class obj slot_name value
@deffnx {C Function} scm_slot_set_using_class_x (class, obj, slot_name, value)
@end deffn
\fslot-bound-using-class?
+@c snarfed from goops.c:1252
@deffn {Scheme Procedure} slot-bound-using-class? class obj slot_name
@deffnx {C Function} scm_slot_bound_using_class_p (class, obj, slot_name)
@end deffn
\fslot-exists-using-class?
+@c snarfed from goops.c:1267
@deffn {Scheme Procedure} slot-exists-using-class? class obj slot_name
@deffnx {C Function} scm_slot_exists_using_class_p (class, obj, slot_name)
@end deffn
\fslot-ref
+@c snarfed from goops.c:1283
@deffn {Scheme Procedure} slot-ref obj slot_name
@deffnx {C Function} scm_slot_ref (obj, slot_name)
Return the value from @var{obj}'s slot with the name
@end deffn
\fslot-set!
+@c snarfed from goops.c:1300
@deffn {Scheme Procedure} slot-set! obj slot_name value
@deffnx {C Function} scm_slot_set_x (obj, slot_name, value)
Set the slot named @var{slot_name} of @var{obj} to @var{value}.
@end deffn
\fslot-bound?
+@c snarfed from goops.c:1317
@deffn {Scheme Procedure} slot-bound? obj slot_name
@deffnx {C Function} scm_slot_bound_p (obj, slot_name)
Return @code{#t} if the slot named @var{slot_name} of @var{obj}
@end deffn
\fslot-exists?
+@c snarfed from goops.c:1335
@deffn {Scheme Procedure} slot-exists? obj slot_name
@deffnx {C Function} scm_slot_exists_p (obj, slot_name)
Return @code{#t} if @var{obj} has a slot named @var{slot_name}.
@end deffn
\f%allocate-instance
+@c snarfed from goops.c:1374
@deffn {Scheme Procedure} %allocate-instance class initargs
@deffnx {C Function} scm_sys_allocate_instance (class, initargs)
Create a new instance of class @var{class} and initialize it
@end deffn
\f%set-object-setter!
+@c snarfed from goops.c:1444
@deffn {Scheme Procedure} %set-object-setter! obj setter
@deffnx {C Function} scm_sys_set_object_setter_x (obj, setter)
@end deffn
\f%modify-instance
+@c snarfed from goops.c:1469
@deffn {Scheme Procedure} %modify-instance old new
@deffnx {C Function} scm_sys_modify_instance (old, new)
@end deffn
\f%modify-class
+@c snarfed from goops.c:1495
@deffn {Scheme Procedure} %modify-class old new
@deffnx {C Function} scm_sys_modify_class (old, new)
@end deffn
\f%invalidate-class
+@c snarfed from goops.c:1519
@deffn {Scheme Procedure} %invalidate-class class
@deffnx {C Function} scm_sys_invalidate_class (class)
@end deffn
\f%invalidate-method-cache!
+@c snarfed from goops.c:1641
@deffn {Scheme Procedure} %invalidate-method-cache! gf
@deffnx {C Function} scm_sys_invalidate_method_cache_x (gf)
@end deffn
\fgeneric-capability?
+@c snarfed from goops.c:1667
@deffn {Scheme Procedure} generic-capability? proc
@deffnx {C Function} scm_generic_capability_p (proc)
@end deffn
\fenable-primitive-generic!
+@c snarfed from goops.c:1680
@deffn {Scheme Procedure} enable-primitive-generic! . subrs
@deffnx {C Function} scm_enable_primitive_generic_x (subrs)
@end deffn
\fprimitive-generic-generic
+@c snarfed from goops.c:1701
@deffn {Scheme Procedure} primitive-generic-generic subr
@deffnx {C Function} scm_primitive_generic_generic (subr)
@end deffn
\fmake
+@c snarfed from goops.c:2069
@deffn {Scheme Procedure} make . args
@deffnx {C Function} scm_make (args)
Make a new object. @var{args} must contain the class and
@end deffn
\ffind-method
+@c snarfed from goops.c:2158
@deffn {Scheme Procedure} find-method . l
@deffnx {C Function} scm_find_method (l)
@end deffn
\f%method-more-specific?
+@c snarfed from goops.c:2178
@deffn {Scheme Procedure} %method-more-specific? m1 m2 targs
@deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs)
@end deffn
\f%goops-loaded
+@c snarfed from goops.c:2793
@deffn {Scheme Procedure} %goops-loaded
@deffnx {C Function} scm_sys_goops_loaded ()
Announce that GOOPS is loaded and perform initialization
@end deffn
\fmake-guardian
+@c snarfed from guardians.c:306
@deffn {Scheme Procedure} make-guardian [greedy_p]
@deffnx {C Function} scm_make_guardian (greedy_p)
Create a new guardian.
@end deffn
\fguardian-destroyed?
+@c snarfed from guardians.c:334
@deffn {Scheme Procedure} guardian-destroyed? guardian
@deffnx {C Function} scm_guardian_destroyed_p (guardian)
Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}.
@end deffn
\fguardian-greedy?
+@c snarfed from guardians.c:352
@deffn {Scheme Procedure} guardian-greedy? guardian
@deffnx {C Function} scm_guardian_greedy_p (guardian)
Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}.
@end deffn
\fdestroy-guardian!
+@c snarfed from guardians.c:363
@deffn {Scheme Procedure} destroy-guardian! guardian
@deffnx {C Function} scm_destroy_guardian_x (guardian)
Destroys @var{guardian}, by making it impossible to put any more
@end deffn
\fhashq
+@c snarfed from hash.c:176
@deffn {Scheme Procedure} hashq key size
@deffnx {C Function} scm_hashq (key, size)
Determine a hash value for @var{key} that is suitable for
@end deffn
\fhashv
+@c snarfed from hash.c:212
@deffn {Scheme Procedure} hashv key size
@deffnx {C Function} scm_hashv (key, size)
Determine a hash value for @var{key} that is suitable for
@end deffn
\fhash
+@c snarfed from hash.c:235
@deffn {Scheme Procedure} hash key size
@deffnx {C Function} scm_hash (key, size)
Determine a hash value for @var{key} that is suitable for
integer in the range 0 to @var{size} - 1.
@end deffn
+\fmake-hash-table
+@c snarfed from hashtab.c:309
+@deffn {Scheme Procedure} make-hash-table [n]
+@deffnx {C Function} scm_make_hash_table (n)
+Make a hash table with optional minimum number of buckets @var{n}
+
+@end deffn
+
+\fmake-weak-key-hash-table
+@c snarfed from hashtab.c:328
+@deffn {Scheme Procedure} make-weak-key-hash-table [n]
+@deffnx {Scheme Procedure} make-weak-value-hash-table size
+@deffnx {Scheme Procedure} make-doubly-weak-hash-table size
+@deffnx {C Function} scm_make_weak_key_hash_table (n)
+Return a weak hash table with @var{size} buckets. As with any
+hash table, choosing a good size for the table requires some
+caution.
+
+You can modify weak hash tables in exactly the same way you
+would modify regular hash tables. (@pxref{Hash Tables})
+@end deffn
+
+\fmake-weak-value-hash-table
+@c snarfed from hashtab.c:343
+@deffn {Scheme Procedure} make-weak-value-hash-table [n]
+@deffnx {C Function} scm_make_weak_value_hash_table (n)
+Return a hash table with weak values with @var{size} buckets.
+(@pxref{Hash Tables})
+@end deffn
+
+\fmake-doubly-weak-hash-table
+@c snarfed from hashtab.c:360
+@deffn {Scheme Procedure} make-doubly-weak-hash-table n
+@deffnx {C Function} scm_make_doubly_weak_hash_table (n)
+Return a hash table with weak keys and values with @var{size}
+buckets. (@pxref{Hash Tables})
+@end deffn
+
+\fhash-table?
+@c snarfed from hashtab.c:379
+@deffn {Scheme Procedure} hash-table? obj
+@deffnx {C Function} scm_hash_table_p (obj)
+Return @code{#t} if @var{obj} is a hash table.
+@end deffn
+
+\fweak-key-hash-table?
+@c snarfed from hashtab.c:393
+@deffn {Scheme Procedure} weak-key-hash-table? obj
+@deffnx {Scheme Procedure} weak-value-hash-table? obj
+@deffnx {Scheme Procedure} doubly-weak-hash-table? obj
+@deffnx {C Function} scm_weak_key_hash_table_p (obj)
+Return @code{#t} if @var{obj} is the specified weak hash
+table. Note that a doubly weak hash table is neither a weak key
+nor a weak value hash table.
+@end deffn
+
+\fweak-value-hash-table?
+@c snarfed from hashtab.c:403
+@deffn {Scheme Procedure} weak-value-hash-table? obj
+@deffnx {C Function} scm_weak_value_hash_table_p (obj)
+Return @code{#t} if @var{obj} is a weak value hash table.
+@end deffn
+
+\fdoubly-weak-hash-table?
+@c snarfed from hashtab.c:413
+@deffn {Scheme Procedure} doubly-weak-hash-table? obj
+@deffnx {C Function} scm_doubly_weak_hash_table_p (obj)
+Return @code{#t} if @var{obj} is a doubly weak hash table.
+@end deffn
+
+\fhash-clear!
+@c snarfed from hashtab.c:550
+@deffn {Scheme Procedure} hash-clear! table
+@deffnx {C Function} scm_hash_clear_x (table)
+Remove all items from TABLE (without triggering a resize).
+@end deffn
+
\fhashq-get-handle
+@c snarfed from hashtab.c:567
@deffn {Scheme Procedure} hashq-get-handle table key
@deffnx {C Function} scm_hashq_get_handle (table, key)
This procedure returns the @code{(key . value)} pair from the
@end deffn
\fhashq-create-handle!
+@c snarfed from hashtab.c:579
@deffn {Scheme Procedure} hashq-create-handle! table key init
@deffnx {C Function} scm_hashq_create_handle_x (table, key, init)
This function looks up @var{key} in @var{table} and returns its handle.
@end deffn
\fhashq-ref
+@c snarfed from hashtab.c:592
@deffn {Scheme Procedure} hashq-ref table key [dflt]
@deffnx {C Function} scm_hashq_ref (table, key, dflt)
Look up @var{key} in the hash table @var{table}, and return the
@end deffn
\fhashq-set!
+@c snarfed from hashtab.c:606
@deffn {Scheme Procedure} hashq-set! table key val
@deffnx {C Function} scm_hashq_set_x (table, key, val)
Find the entry in @var{table} associated with @var{key}, and
@end deffn
\fhashq-remove!
+@c snarfed from hashtab.c:618
@deffn {Scheme Procedure} hashq-remove! table key
@deffnx {C Function} scm_hashq_remove_x (table, key)
Remove @var{key} (and any value associated with it) from
@end deffn
\fhashv-get-handle
+@c snarfed from hashtab.c:634
@deffn {Scheme Procedure} hashv-get-handle table key
@deffnx {C Function} scm_hashv_get_handle (table, key)
This procedure returns the @code{(key . value)} pair from the
@end deffn
\fhashv-create-handle!
+@c snarfed from hashtab.c:646
@deffn {Scheme Procedure} hashv-create-handle! table key init
@deffnx {C Function} scm_hashv_create_handle_x (table, key, init)
This function looks up @var{key} in @var{table} and returns its handle.
@end deffn
\fhashv-ref
+@c snarfed from hashtab.c:660
@deffn {Scheme Procedure} hashv-ref table key [dflt]
@deffnx {C Function} scm_hashv_ref (table, key, dflt)
Look up @var{key} in the hash table @var{table}, and return the
@end deffn
\fhashv-set!
+@c snarfed from hashtab.c:674
@deffn {Scheme Procedure} hashv-set! table key val
@deffnx {C Function} scm_hashv_set_x (table, key, val)
Find the entry in @var{table} associated with @var{key}, and
@end deffn
\fhashv-remove!
+@c snarfed from hashtab.c:685
@deffn {Scheme Procedure} hashv-remove! table key
@deffnx {C Function} scm_hashv_remove_x (table, key)
Remove @var{key} (and any value associated with it) from
@end deffn
\fhash-get-handle
+@c snarfed from hashtab.c:700
@deffn {Scheme Procedure} hash-get-handle table key
@deffnx {C Function} scm_hash_get_handle (table, key)
This procedure returns the @code{(key . value)} pair from the
@end deffn
\fhash-create-handle!
+@c snarfed from hashtab.c:712
@deffn {Scheme Procedure} hash-create-handle! table key init
@deffnx {C Function} scm_hash_create_handle_x (table, key, init)
This function looks up @var{key} in @var{table} and returns its handle.
@end deffn
\fhash-ref
+@c snarfed from hashtab.c:725
@deffn {Scheme Procedure} hash-ref table key [dflt]
@deffnx {C Function} scm_hash_ref (table, key, dflt)
Look up @var{key} in the hash table @var{table}, and return the
@end deffn
\fhash-set!
+@c snarfed from hashtab.c:740
@deffn {Scheme Procedure} hash-set! table key val
@deffnx {C Function} scm_hash_set_x (table, key, val)
Find the entry in @var{table} associated with @var{key}, and
@end deffn
\fhash-remove!
+@c snarfed from hashtab.c:752
@deffn {Scheme Procedure} hash-remove! table key
@deffnx {C Function} scm_hash_remove_x (table, key)
Remove @var{key} (and any value associated with it) from
@end deffn
\fhashx-get-handle
+@c snarfed from hashtab.c:805
@deffn {Scheme Procedure} hashx-get-handle hash assoc table key
@deffnx {C Function} scm_hashx_get_handle (hash, assoc, table, key)
This behaves the same way as the corresponding
@end deffn
\fhashx-create-handle!
+@c snarfed from hashtab.c:824
@deffn {Scheme Procedure} hashx-create-handle! hash assoc table key init
@deffnx {C Function} scm_hashx_create_handle_x (hash, assoc, table, key, init)
This behaves the same way as the corresponding
@end deffn
\fhashx-ref
+@c snarfed from hashtab.c:847
@deffn {Scheme Procedure} hashx-ref hash assoc table key [dflt]
@deffnx {C Function} scm_hashx_ref (hash, assoc, table, key, dflt)
This behaves the same way as the corresponding @code{ref}
@end deffn
\fhashx-set!
+@c snarfed from hashtab.c:873
@deffn {Scheme Procedure} hashx-set! hash assoc table key val
@deffnx {C Function} scm_hashx_set_x (hash, assoc, table, key, val)
This behaves the same way as the corresponding @code{set!}
@end deffn
\fhash-fold
+@c snarfed from hashtab.c:975
@deffn {Scheme Procedure} hash-fold proc init table
@deffnx {C Function} scm_hash_fold (proc, init, table)
An iterator over hash-table elements.
table into an a-list of key-value pairs.
@end deffn
+\fhash-for-each
+@c snarfed from hashtab.c:996
+@deffn {Scheme Procedure} hash-for-each proc table
+@deffnx {C Function} scm_hash_for_each (proc, table)
+An iterator over hash-table elements.
+Applies PROC successively on all hash table items.
+The arguments to PROC are "(key value)" where key
+and value are successive pairs from the hash table TABLE.
+@end deffn
+
+\fhash-for-each-handle
+@c snarfed from hashtab.c:1013
+@deffn {Scheme Procedure} hash-for-each-handle proc table
+@deffnx {C Function} scm_hash_for_each_handle (proc, table)
+An iterator over hash-table elements.
+Applies PROC successively on all hash table handles.
+@end deffn
+
+\fhash-map->list
+@c snarfed from hashtab.c:1039
+@deffn {Scheme Procedure} hash-map->list proc table
+@deffnx {C Function} scm_hash_map_to_list (proc, table)
+An iterator over hash-table elements.
+Accumulates and returns as a list the results of applying PROC successively.
+The arguments to PROC are "(key value)" where key
+and value are successive pairs from the hash table TABLE.
+@end deffn
+
\fmake-hook
+@c snarfed from hooks.c:154
@deffn {Scheme Procedure} make-hook [n_args]
@deffnx {C Function} scm_make_hook (n_args)
Create a hook for storing procedure of arity @var{n_args}.
@end deffn
\fhook?
+@c snarfed from hooks.c:171
@deffn {Scheme Procedure} hook? x
@deffnx {C Function} scm_hook_p (x)
Return @code{#t} if @var{x} is a hook, @code{#f} otherwise.
@end deffn
\fhook-empty?
+@c snarfed from hooks.c:182
@deffn {Scheme Procedure} hook-empty? hook
@deffnx {C Function} scm_hook_empty_p (hook)
Return @code{#t} if @var{hook} is an empty hook, @code{#f}
@end deffn
\fadd-hook!
+@c snarfed from hooks.c:196
@deffn {Scheme Procedure} add-hook! hook proc [append_p]
@deffnx {C Function} scm_add_hook_x (hook, proc, append_p)
Add the procedure @var{proc} to the hook @var{hook}. The
@end deffn
\fremove-hook!
+@c snarfed from hooks.c:223
@deffn {Scheme Procedure} remove-hook! hook proc
@deffnx {C Function} scm_remove_hook_x (hook, proc)
Remove the procedure @var{proc} from the hook @var{hook}. The
@end deffn
\freset-hook!
+@c snarfed from hooks.c:237
@deffn {Scheme Procedure} reset-hook! hook
@deffnx {C Function} scm_reset_hook_x (hook)
Remove all procedures from the hook @var{hook}. The return
@end deffn
\frun-hook
+@c snarfed from hooks.c:251
@deffn {Scheme Procedure} run-hook hook . args
@deffnx {C Function} scm_run_hook (hook, args)
Apply all procedures from the hook @var{hook} to the arguments
@end deffn
\fhook->list
+@c snarfed from hooks.c:278
@deffn {Scheme Procedure} hook->list hook
@deffnx {C Function} scm_hook_to_list (hook)
Convert the procedure list of @var{hook} to a list.
@end deffn
\fftell
+@c snarfed from ioext.c:54
@deffn {Scheme Procedure} ftell fd_port
@deffnx {C Function} scm_ftell (fd_port)
Return an integer representing the current position of
@end deffn
\fredirect-port
+@c snarfed from ioext.c:72
@deffn {Scheme Procedure} redirect-port old new
@deffnx {C Function} scm_redirect_port (old, new)
This procedure takes two ports and duplicates the underlying file
@end deffn
\fdup->fdes
+@c snarfed from ioext.c:111
@deffn {Scheme Procedure} dup->fdes fd_or_port [fd]
@deffnx {C Function} scm_dup_to_fdes (fd_or_port, fd)
Return a new integer file descriptor referring to the open file
@end deffn
\fdup2
+@c snarfed from ioext.c:158
@deffn {Scheme Procedure} dup2 oldfd newfd
@deffnx {C Function} scm_dup2 (oldfd, newfd)
A simple wrapper for the @code{dup2} system call.
@end deffn
\ffileno
+@c snarfed from ioext.c:177
@deffn {Scheme Procedure} fileno port
@deffnx {C Function} scm_fileno (port)
Return the integer file descriptor underlying @var{port}. Does
@end deffn
\fisatty?
+@c snarfed from ioext.c:197
@deffn {Scheme Procedure} isatty? port
@deffnx {C Function} scm_isatty_p (port)
Return @code{#t} if @var{port} is using a serial non--file
@end deffn
\ffdopen
+@c snarfed from ioext.c:219
@deffn {Scheme Procedure} fdopen fdes modes
@deffnx {C Function} scm_fdopen (fdes, modes)
Return a new port based on the file descriptor @var{fdes}.
@end deffn
\fprimitive-move->fdes
+@c snarfed from ioext.c:241
@deffn {Scheme Procedure} primitive-move->fdes port fd
@deffnx {C Function} scm_primitive_move_to_fdes (port, fd)
Moves the underlying file descriptor for @var{port} to the integer
@end deffn
\ffdes->ports
+@c snarfed from ioext.c:274
@deffn {Scheme Procedure} fdes->ports fd
@deffnx {C Function} scm_fdes_to_ports (fd)
Return a list of existing ports which have @var{fdes} as an
@end deffn
\fmake-keyword-from-dash-symbol
+@c snarfed from keywords.c:52
@deffn {Scheme Procedure} make-keyword-from-dash-symbol symbol
@deffnx {C Function} scm_make_keyword_from_dash_symbol (symbol)
Make a keyword object from a @var{symbol} that starts with a dash.
@end deffn
\fkeyword?
+@c snarfed from keywords.c:91
@deffn {Scheme Procedure} keyword? obj
@deffnx {C Function} scm_keyword_p (obj)
Return @code{#t} if the argument @var{obj} is a keyword, else
@end deffn
\fkeyword-dash-symbol
+@c snarfed from keywords.c:102
@deffn {Scheme Procedure} keyword-dash-symbol keyword
@deffnx {C Function} scm_keyword_dash_symbol (keyword)
Return the dash symbol for @var{keyword}.
@end deffn
\flist
+@c snarfed from list.c:104
@deffn {Scheme Procedure} list . objs
@deffnx {C Function} scm_list (objs)
Return a list containing @var{objs}, the arguments to
@end deffn
\fcons*
+@c snarfed from list.c:119
@deffn {Scheme Procedure} cons* arg . rest
@deffnx {C Function} scm_cons_star (arg, rest)
Like @code{list}, but the last arg provides the tail of the
@end deffn
\fnull?
+@c snarfed from list.c:143
@deffn {Scheme Procedure} null? x
@deffnx {C Function} scm_null_p (x)
Return @code{#t} iff @var{x} is the empty list, else @code{#f}.
@end deffn
\flist?
+@c snarfed from list.c:153
@deffn {Scheme Procedure} list? x
@deffnx {C Function} scm_list_p (x)
Return @code{#t} iff @var{x} is a proper list, else @code{#f}.
@end deffn
\flength
+@c snarfed from list.c:194
@deffn {Scheme Procedure} length lst
@deffnx {C Function} scm_length (lst)
Return the number of elements in list @var{lst}.
@end deffn
\fappend
+@c snarfed from list.c:223
@deffn {Scheme Procedure} append . args
@deffnx {C Function} scm_append (args)
Return a list consisting of the elements the lists passed as
@end deffn
\fappend!
+@c snarfed from list.c:259
@deffn {Scheme Procedure} append! . lists
@deffnx {C Function} scm_append_x (lists)
A destructive version of @code{append} (@pxref{Pairs and
Lists,,,r5rs, The Revised^5 Report on Scheme}). The cdr field
of each list's final pair is changed to point to the head of
-the next list, so no consing is performed. Return a pointer to
+the next list, so no consing is performed. Return
the mutated list.
@end deffn
\flast-pair
+@c snarfed from list.c:291
@deffn {Scheme Procedure} last-pair lst
@deffnx {C Function} scm_last_pair (lst)
-Return a pointer to the last pair in @var{lst}, signalling an error if
+Return the last pair in @var{lst}, signalling an error if
@var{lst} is circular.
@end deffn
\freverse
+@c snarfed from list.c:321
@deffn {Scheme Procedure} reverse lst
@deffnx {C Function} scm_reverse (lst)
Return a new list that contains the elements of @var{lst} but
@end deffn
\freverse!
+@c snarfed from list.c:355
@deffn {Scheme Procedure} reverse! lst [new_tail]
@deffnx {C Function} scm_reverse_x (lst, new_tail)
A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r5rs,
The Revised^5 Report on Scheme}). The cdr of each cell in @var{lst} is
-modified to point to the previous list element. Return a pointer to the
-head of the reversed list.
+modified to point to the previous list element. Return the
+reversed list.
Caveat: because the list is modified in place, the tail of the original
list now becomes its head, and the head of the original list now becomes
@end deffn
\flist-ref
+@c snarfed from list.c:381
@deffn {Scheme Procedure} list-ref list k
@deffnx {C Function} scm_list_ref (list, k)
Return the @var{k}th element from @var{list}.
@end deffn
\flist-set!
+@c snarfed from list.c:405
@deffn {Scheme Procedure} list-set! list k val
@deffnx {C Function} scm_list_set_x (list, k, val)
Set the @var{k}th element of @var{list} to @var{val}.
@end deffn
\flist-cdr-ref
+@c snarfed from list.c:427
@deffn {Scheme Procedure} list-cdr-ref
implemented by the C function "scm_list_tail"
@end deffn
\flist-tail
+@c snarfed from list.c:436
@deffn {Scheme Procedure} list-tail lst k
@deffnx {Scheme Procedure} list-cdr-ref lst k
@deffnx {C Function} scm_list_tail (lst, k)
@end deffn
\flist-cdr-set!
+@c snarfed from list.c:451
@deffn {Scheme Procedure} list-cdr-set! list k val
@deffnx {C Function} scm_list_cdr_set_x (list, k, val)
Set the @var{k}th cdr of @var{list} to @var{val}.
@end deffn
\flist-head
+@c snarfed from list.c:479
@deffn {Scheme Procedure} list-head lst k
@deffnx {C Function} scm_list_head (lst, k)
Copy the first @var{k} elements from @var{lst} into a new list, and
@end deffn
\flist-copy
+@c snarfed from list.c:530
@deffn {Scheme Procedure} list-copy lst
@deffnx {C Function} scm_list_copy (lst)
Return a (newly-created) copy of @var{lst}.
@end deffn
\fmemq
+@c snarfed from list.c:584
@deffn {Scheme Procedure} memq x lst
@deffnx {C Function} scm_memq (x, lst)
Return the first sublist of @var{lst} whose car is @code{eq?}
@end deffn
\fmemv
+@c snarfed from list.c:600
@deffn {Scheme Procedure} memv x lst
@deffnx {C Function} scm_memv (x, lst)
Return the first sublist of @var{lst} whose car is @code{eqv?}
@end deffn
\fmember
+@c snarfed from list.c:621
@deffn {Scheme Procedure} member x lst
@deffnx {C Function} scm_member (x, lst)
Return the first sublist of @var{lst} whose car is
@end deffn
\fdelq!
+@c snarfed from list.c:646
@deffn {Scheme Procedure} delq! item lst
@deffnx {Scheme Procedure} delv! item lst
@deffnx {Scheme Procedure} delete! item lst
@deffnx {C Function} scm_delq_x (item, lst)
These procedures are destructive versions of @code{delq}, @code{delv}
-and @code{delete}: they modify the pointers in the existing @var{lst}
+and @code{delete}: they modify the existing @var{lst}
rather than creating a new list. Caveat evaluator: Like other
destructive list functions, these functions cannot modify the binding of
@var{lst}, and so cannot be used to delete the first element of
@end deffn
\fdelv!
+@c snarfed from list.c:670
@deffn {Scheme Procedure} delv! item lst
@deffnx {C Function} scm_delv_x (item, lst)
Destructively remove all elements from @var{lst} that are
@end deffn
\fdelete!
+@c snarfed from list.c:695
@deffn {Scheme Procedure} delete! item lst
@deffnx {C Function} scm_delete_x (item, lst)
Destructively remove all elements from @var{lst} that are
@end deffn
\fdelq
+@c snarfed from list.c:724
@deffn {Scheme Procedure} delq item lst
@deffnx {C Function} scm_delq (item, lst)
Return a newly-created copy of @var{lst} with elements
@end deffn
\fdelv
+@c snarfed from list.c:737
@deffn {Scheme Procedure} delv item lst
@deffnx {C Function} scm_delv (item, lst)
Return a newly-created copy of @var{lst} with elements
@end deffn
\fdelete
+@c snarfed from list.c:750
@deffn {Scheme Procedure} delete item lst
@deffnx {C Function} scm_delete (item, lst)
Return a newly-created copy of @var{lst} with elements
@end deffn
\fdelq1!
+@c snarfed from list.c:763
@deffn {Scheme Procedure} delq1! item lst
@deffnx {C Function} scm_delq1_x (item, lst)
Like @code{delq!}, but only deletes the first occurrence of
@end deffn
\fdelv1!
+@c snarfed from list.c:791
@deffn {Scheme Procedure} delv1! item lst
@deffnx {C Function} scm_delv1_x (item, lst)
Like @code{delv!}, but only deletes the first occurrence of
@end deffn
\fdelete1!
+@c snarfed from list.c:819
@deffn {Scheme Procedure} delete1! item lst
@deffnx {C Function} scm_delete1_x (item, lst)
Like @code{delete!}, but only deletes the first occurrence of
@code{equal?}. See also @code{delq1!} and @code{delv1!}.
@end deffn
+\ffilter
+@c snarfed from list.c:851
+@deffn {Scheme Procedure} filter pred list
+@deffnx {C Function} scm_filter (pred, list)
+Return all the elements of 2nd arg @var{list} that satisfy predicate @var{pred}.
+The list is not disordered -- elements that appear in the result list occur
+in the same order as they occur in the argument list. The returned list may
+share a common tail with the argument list. The dynamic order in which the
+various applications of pred are made is not specified.
+
+@lisp
+(filter even? '(0 7 8 8 43 -4)) => (0 8 8 -4)
+@end lisp
+@end deffn
+
+\ffilter!
+@c snarfed from list.c:878
+@deffn {Scheme Procedure} filter! pred list
+@deffnx {C Function} scm_filter_x (pred, list)
+Linear-update variant of @code{filter}.
+@end deffn
+
\fprimitive-load
+@c snarfed from load.c:94
@deffn {Scheme Procedure} primitive-load filename
@deffnx {C Function} scm_primitive_load (filename)
Load the file named @var{filename} and evaluate its contents in
@end deffn
\f%package-data-dir
+@c snarfed from load.c:134
@deffn {Scheme Procedure} %package-data-dir
@deffnx {C Function} scm_sys_package_data_dir ()
Return the name of the directory where Scheme packages, modules and
@end deffn
\f%library-dir
+@c snarfed from load.c:146
@deffn {Scheme Procedure} %library-dir
@deffnx {C Function} scm_sys_library_dir ()
Return the directory where the Guile Scheme library files are installed.
@end deffn
\f%site-dir
+@c snarfed from load.c:158
@deffn {Scheme Procedure} %site-dir
@deffnx {C Function} scm_sys_site_dir ()
Return the directory where the Guile site files are installed.
@end deffn
\fparse-path
+@c snarfed from load.c:183
@deffn {Scheme Procedure} parse-path path [tail]
@deffnx {C Function} scm_parse_path (path, tail)
Parse @var{path}, which is expected to be a colon-separated
@end deffn
\fsearch-path
+@c snarfed from load.c:310
@deffn {Scheme Procedure} search-path path filename [extensions]
@deffnx {C Function} scm_search_path (path, filename, extensions)
Search @var{path} for a directory containing a file named
@end deffn
\f%search-load-path
+@c snarfed from load.c:447
@deffn {Scheme Procedure} %search-load-path filename
@deffnx {C Function} scm_sys_search_load_path (filename)
Search @var{%load-path} for the file named @var{filename},
@end deffn
\fprimitive-load-path
+@c snarfed from load.c:468
@deffn {Scheme Procedure} primitive-load-path filename
@deffnx {C Function} scm_primitive_load_path (filename)
Search @var{%load-path} for the file named @var{filename} and
an error is signalled.
@end deffn
-\fprocedure->syntax
-@deffn {Scheme Procedure} procedure->syntax code
-@deffnx {C Function} scm_makacro (code)
-Return a @dfn{macro} which, when a symbol defined to this value
-appears as the first symbol in an expression, returns the
-result of applying @var{code} to the expression and the
-environment.
-@end deffn
-
-\fprocedure->macro
-@deffn {Scheme Procedure} procedure->macro code
-@deffnx {C Function} scm_makmacro (code)
-Return a @dfn{macro} which, when a symbol defined to this value
-appears as the first symbol in an expression, evaluates the
-result of applying @var{code} to the expression and the
-environment. For example:
-
-@lisp
-(define trace
- (procedure->macro
- (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))
-
-(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
-@end lisp
-@end deffn
-
\fprocedure->memoizing-macro
+@c snarfed from macros.c:109
@deffn {Scheme Procedure} procedure->memoizing-macro code
@deffnx {C Function} scm_makmmacro (code)
Return a @dfn{macro} which, when a symbol defined to this value
form of the containing code.
@end deffn
+\fprocedure->syntax
+@c snarfed from macros.c:123
+@deffn {Scheme Procedure} procedure->syntax code
+@deffnx {C Function} scm_makacro (code)
+Return a @dfn{macro} which, when a symbol defined to this value
+appears as the first symbol in an expression, returns the
+result of applying @var{code} to the expression and the
+environment.
+@end deffn
+
\fmacro?
+@c snarfed from macros.c:165
@deffn {Scheme Procedure} macro? obj
@deffnx {C Function} scm_macro_p (obj)
Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a
@end deffn
\fmacro-type
+@c snarfed from macros.c:186
@deffn {Scheme Procedure} macro-type m
@deffnx {C Function} scm_macro_type (m)
Return one of the symbols @code{syntax}, @code{macro} or
@end deffn
\fmacro-name
+@c snarfed from macros.c:207
@deffn {Scheme Procedure} macro-name m
@deffnx {C Function} scm_macro_name (m)
Return the name of the macro @var{m}.
@end deffn
\fmacro-transformer
+@c snarfed from macros.c:218
@deffn {Scheme Procedure} macro-transformer m
@deffnx {C Function} scm_macro_transformer (m)
Return the transformer of the macro @var{m}.
@end deffn
\fcurrent-module
+@c snarfed from modules.c:45
@deffn {Scheme Procedure} current-module
@deffnx {C Function} scm_current_module ()
Return the current module.
@end deffn
\fset-current-module
+@c snarfed from modules.c:57
@deffn {Scheme Procedure} set-current-module module
@deffnx {C Function} scm_set_current_module (module)
Set the current module to @var{module} and return
@end deffn
\finteraction-environment
+@c snarfed from modules.c:80
@deffn {Scheme Procedure} interaction-environment
@deffnx {C Function} scm_interaction_environment ()
Return a specifier for the environment that contains
@end deffn
\fenv-module
+@c snarfed from modules.c:261
@deffn {Scheme Procedure} env-module env
@deffnx {C Function} scm_env_module (env)
Return the module of @var{ENV}, a lexical environment.
@end deffn
\fstandard-eval-closure
+@c snarfed from modules.c:337
@deffn {Scheme Procedure} standard-eval-closure module
@deffnx {C Function} scm_standard_eval_closure (module)
Return an eval closure for the module @var{module}.
@end deffn
\fstandard-interface-eval-closure
+@c snarfed from modules.c:348
@deffn {Scheme Procedure} standard-interface-eval-closure module
@deffnx {C Function} scm_standard_interface_eval_closure (module)
Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added.
@end deffn
+\fmodule-import-interface
+@c snarfed from modules.c:394
+@deffn {Scheme Procedure} module-import-interface module sym
+@deffnx {C Function} scm_module_import_interface (module, sym)
+
+@end deffn
+
\f%get-pre-modules-obarray
+@c snarfed from modules.c:611
@deffn {Scheme Procedure} %get-pre-modules-obarray
@deffnx {C Function} scm_get_pre_modules_obarray ()
Return the obarray that is used for all new bindings before the module system is booted. The first call to @code{set-current-module} will boot the module system.
@end deffn
\fexact?
+@c snarfed from numbers.c:461
@deffn {Scheme Procedure} exact? x
@deffnx {C Function} scm_exact_p (x)
Return @code{#t} if @var{x} is an exact number, @code{#f}
@end deffn
\fodd?
+@c snarfed from numbers.c:480
@deffn {Scheme Procedure} odd? n
@deffnx {C Function} scm_odd_p (n)
Return @code{#t} if @var{n} is an odd number, @code{#f}
@end deffn
\feven?
+@c snarfed from numbers.c:515
@deffn {Scheme Procedure} even? n
@deffnx {C Function} scm_even_p (n)
Return @code{#t} if @var{n} is an even number, @code{#f}
@end deffn
\finf?
+@c snarfed from numbers.c:549
@deffn {Scheme Procedure} inf? n
@deffnx {C Function} scm_inf_p (n)
Return @code{#t} if @var{n} is infinite, @code{#f}
@end deffn
\fnan?
+@c snarfed from numbers.c:565
@deffn {Scheme Procedure} nan? n
@deffnx {C Function} scm_nan_p (n)
Return @code{#t} if @var{n} is a NaN, @code{#f}
@end deffn
\finf
+@c snarfed from numbers.c:635
@deffn {Scheme Procedure} inf
@deffnx {C Function} scm_inf ()
Return Inf.
@end deffn
\fnan
+@c snarfed from numbers.c:650
@deffn {Scheme Procedure} nan
@deffnx {C Function} scm_nan ()
Return NaN.
@end deffn
+\fabs
+@c snarfed from numbers.c:666
+@deffn {Scheme Procedure} abs x
+@deffnx {C Function} scm_abs (x)
+Return the absolute value of @var{x}.
+@end deffn
+
\flogand
+@c snarfed from numbers.c:1201
@deffn {Scheme Procedure} logand n1 n2
Return the bitwise AND of the integer arguments.
@end deffn
\flogior
+@c snarfed from numbers.c:1277
@deffn {Scheme Procedure} logior n1 n2
Return the bitwise OR of the integer arguments.
@end deffn
\flogxor
+@c snarfed from numbers.c:1353
@deffn {Scheme Procedure} logxor n1 n2
Return the bitwise XOR of the integer arguments. A bit is
set in the result if it is set in an odd number of arguments.
@end deffn
\flogtest
+@c snarfed from numbers.c:1424
@deffn {Scheme Procedure} logtest j k
@deffnx {C Function} scm_logtest (j, k)
@lisp
@end deffn
\flogbit?
+@c snarfed from numbers.c:1495
@deffn {Scheme Procedure} logbit? index j
@deffnx {C Function} scm_logbit_p (index, j)
@lisp
@end deffn
\flognot
+@c snarfed from numbers.c:1529
@deffn {Scheme Procedure} lognot n
@deffnx {C Function} scm_lognot (n)
-Return the integer which is the 2s-complement of the integer
+Return the integer which is the ones-complement of the integer
argument.
@lisp
@end lisp
@end deffn
+\fmodulo-expt
+@c snarfed from numbers.c:1574
+@deffn {Scheme Procedure} modulo-expt n k m
+@deffnx {C Function} scm_modulo_expt (n, k, m)
+Return @var{n} raised to the integer exponent
+@var{k}, modulo @var{m}.
+
+@lisp
+(modulo-expt 2 3 5)
+ @result{} 3
+@end lisp
+@end deffn
+
\finteger-expt
+@c snarfed from numbers.c:1679
@deffn {Scheme Procedure} integer-expt n k
@deffnx {C Function} scm_integer_expt (n, k)
Return @var{n} raised to the non-negative integer exponent
@end deffn
\fash
+@c snarfed from numbers.c:1785
@deffn {Scheme Procedure} ash n cnt
@deffnx {C Function} scm_ash (n, cnt)
-The function ash performs an arithmetic shift left by @var{cnt}
-bits (or shift right, if @var{cnt} is negative). 'Arithmetic'
-means, that the function does not guarantee to keep the bit
-structure of @var{n}, but rather guarantees that the result
-will always be rounded towards minus infinity. Therefore, the
-results of ash and a corresponding bitwise shift will differ if
-@var{n} is negative.
+Return @var{n} shifted left by @var{cnt} bits, or shifted right
+if @var{cnt} is negative. This is an ``arithmetic'' shift.
+
+This is effectively a multiplication by 2^@var{cnt}, and when
+@var{cnt} is negative it's a division, rounded towards negative
+infinity. (Note that this is not the same rounding as
+@code{quotient} does.)
-Formally, the function returns an integer equivalent to
-@code{(inexact->exact (floor (* @var{n} (expt 2 @var{cnt}))))}.
+With @var{n} viewed as an infinite precision twos complement,
+@code{ash} means a left shift introducing zero bits, or a right
+shift dropping bits.
@lisp
(number->string (ash #b1 3) 2) @result{} "1000"
(number->string (ash #b1010 -1) 2) @result{} "101"
+
+;; -23 is bits ...11101001, -6 is bits ...111010
+(ash -23 -2) @result{} -6
@end lisp
@end deffn
\fbit-extract
+@c snarfed from numbers.c:1825
@deffn {Scheme Procedure} bit-extract n start end
@deffnx {C Function} scm_bit_extract (n, start, end)
Return the integer composed of the @var{start} (inclusive)
@end deffn
\flogcount
+@c snarfed from numbers.c:1904
@deffn {Scheme Procedure} logcount n
@deffnx {C Function} scm_logcount (n)
Return the number of bits in integer @var{n}. If integer is
@end deffn
\finteger-length
+@c snarfed from numbers.c:1952
@deffn {Scheme Procedure} integer-length n
@deffnx {C Function} scm_integer_length (n)
Return the number of bits necessary to represent @var{n}.
@end deffn
\fnumber->string
+@c snarfed from numbers.c:2275
@deffn {Scheme Procedure} number->string n [radix]
@deffnx {C Function} scm_number_to_string (n, radix)
Return a string holding the external representation of the
@end deffn
\fstring->number
+@c snarfed from numbers.c:2958
@deffn {Scheme Procedure} string->number string [radix]
@deffnx {C Function} scm_string_to_number (string, radix)
Return a number of the maximally precise representation
@end deffn
\fnumber?
-@deffn {Scheme Procedure} number?
-implemented by the C function "scm_number_p"
+@c snarfed from numbers.c:3021
+@deffn {Scheme Procedure} number? x
+@deffnx {C Function} scm_number_p (x)
+Return @code{#t} if @var{x} is a number, @code{#f}
+otherwise.
@end deffn
\fcomplex?
+@c snarfed from numbers.c:3034
@deffn {Scheme Procedure} complex? x
-@deffnx {C Function} scm_number_p (x)
+@deffnx {C Function} scm_complex_p (x)
Return @code{#t} if @var{x} is a complex number, @code{#f}
otherwise. Note that the sets of real, rational and integer
values form subsets of the set of complex numbers, i. e. the
@end deffn
\freal?
-@deffn {Scheme Procedure} real?
-implemented by the C function "scm_real_p"
+@c snarfed from numbers.c:3047
+@deffn {Scheme Procedure} real? x
+@deffnx {C Function} scm_real_p (x)
+Return @code{#t} if @var{x} is a real number, @code{#f}
+otherwise. Note that the set of integer values forms a subset of
+the set of real numbers, i. e. the predicate will also be
+fulfilled if @var{x} is an integer number.
@end deffn
\frational?
+@c snarfed from numbers.c:3060
@deffn {Scheme Procedure} rational? x
-@deffnx {C Function} scm_real_p (x)
+@deffnx {C Function} scm_rational_p (x)
Return @code{#t} if @var{x} is a rational number, @code{#f}
otherwise. Note that the set of integer values forms a subset of
the set of rational numbers, i. e. the predicate will also be
-fulfilled if @var{x} is an integer number. Real numbers
-will also satisfy this predicate, because of their limited
-precision.
+fulfilled if @var{x} is an integer number.
@end deffn
\finteger?
+@c snarfed from numbers.c:3083
@deffn {Scheme Procedure} integer? x
@deffnx {C Function} scm_integer_p (x)
Return @code{#t} if @var{x} is an integer number, @code{#f}
@end deffn
\finexact?
+@c snarfed from numbers.c:3108
@deffn {Scheme Procedure} inexact? x
@deffnx {C Function} scm_inexact_p (x)
Return @code{#t} if @var{x} is an inexact number, @code{#f}
else.
@end deffn
+\ftruncate
+@c snarfed from numbers.c:4955
+@deffn {Scheme Procedure} truncate x
+@deffnx {C Function} scm_truncate_number (x)
+Round the number @var{x} towards zero.
+@end deffn
+
+\fround
+@c snarfed from numbers.c:4971
+@deffn {Scheme Procedure} round x
+@deffnx {C Function} scm_round_number (x)
+Round the number @var{x} towards the nearest integer. When it is exactly halfway between two integers, round towards the even one.
+@end deffn
+
+\ffloor
+@c snarfed from numbers.c:4997
+@deffn {Scheme Procedure} floor x
+@deffnx {C Function} scm_floor (x)
+Round the number @var{x} towards minus infinity.
+@end deffn
+
+\fceiling
+@c snarfed from numbers.c:5028
+@deffn {Scheme Procedure} ceiling x
+@deffnx {C Function} scm_ceiling (x)
+Round the number @var{x} towards infinity.
+@end deffn
+
\f$expt
+@c snarfed from numbers.c:5137
@deffn {Scheme Procedure} $expt x y
@deffnx {C Function} scm_sys_expt (x, y)
Return @var{x} raised to the power of @var{y}. This
@end deffn
\f$atan2
+@c snarfed from numbers.c:5153
@deffn {Scheme Procedure} $atan2 x y
@deffnx {C Function} scm_sys_atan2 (x, y)
Return the arc tangent of the two arguments @var{x} and
@end deffn
\fmake-rectangular
+@c snarfed from numbers.c:5181
@deffn {Scheme Procedure} make-rectangular real imaginary
@deffnx {C Function} scm_make_rectangular (real, imaginary)
Return a complex number constructed of the given @var{real} and
@end deffn
\fmake-polar
+@c snarfed from numbers.c:5205
@deffn {Scheme Procedure} make-polar x y
@deffnx {C Function} scm_make_polar (x, y)
Return the complex number @var{x} * e^(i * @var{y}).
@end deffn
\finexact->exact
+@c snarfed from numbers.c:5408
@deffn {Scheme Procedure} inexact->exact z
@deffnx {C Function} scm_inexact_to_exact (z)
Return an exact number that is numerically closest to @var{z}.
@end deffn
+\frationalize
+@c snarfed from numbers.c:5445
+@deffn {Scheme Procedure} rationalize x err
+@deffnx {C Function} scm_rationalize (x, err)
+Return an exact number that is within @var{err} of @var{x}.
+@end deffn
+
\fclass-of
+@c snarfed from objects.c:62
@deffn {Scheme Procedure} class-of x
@deffnx {C Function} scm_class_of (x)
Return the class of @var{x}.
@end deffn
\fentity?
+@c snarfed from objects.c:342
@deffn {Scheme Procedure} entity? obj
@deffnx {C Function} scm_entity_p (obj)
Return @code{#t} if @var{obj} is an entity.
@end deffn
\foperator?
+@c snarfed from objects.c:351
@deffn {Scheme Procedure} operator? obj
@deffnx {C Function} scm_operator_p (obj)
Return @code{#t} if @var{obj} is an operator.
@end deffn
\fvalid-object-procedure?
+@c snarfed from objects.c:367
@deffn {Scheme Procedure} valid-object-procedure? proc
@deffnx {C Function} scm_valid_object_procedure_p (proc)
Return @code{#t} iff @var{proc} is a procedure that can be used with @code{set-object-procedure}. It is always valid to use a closure constructed by @code{lambda}.
@end deffn
\fset-object-procedure!
+@c snarfed from objects.c:389
@deffn {Scheme Procedure} set-object-procedure! obj proc
@deffnx {C Function} scm_set_object_procedure_x (obj, proc)
Set the object procedure of @var{obj} to @var{proc}.
@end deffn
\fmake-class-object
+@c snarfed from objects.c:449
@deffn {Scheme Procedure} make-class-object metaclass layout
@deffnx {C Function} scm_make_class_object (metaclass, layout)
Create a new class object of class @var{metaclass}, with the
@end deffn
\fmake-subclass-object
+@c snarfed from objects.c:464
@deffn {Scheme Procedure} make-subclass-object class layout
@deffnx {C Function} scm_make_subclass_object (class, layout)
Create a subclass object of @var{class}, with the slot layout
@end deffn
\fobject-properties
+@c snarfed from objprop.c:35
@deffn {Scheme Procedure} object-properties obj
@deffnx {C Function} scm_object_properties (obj)
Return @var{obj}'s property list.
@end deffn
\fset-object-properties!
+@c snarfed from objprop.c:45
@deffn {Scheme Procedure} set-object-properties! obj alist
@deffnx {C Function} scm_set_object_properties_x (obj, alist)
Set @var{obj}'s property list to @var{alist}.
@end deffn
\fobject-property
+@c snarfed from objprop.c:56
@deffn {Scheme Procedure} object-property obj key
@deffnx {C Function} scm_object_property (obj, key)
Return the property of @var{obj} with name @var{key}.
@end deffn
\fset-object-property!
+@c snarfed from objprop.c:68
@deffn {Scheme Procedure} set-object-property! obj key value
@deffnx {C Function} scm_set_object_property_x (obj, key, value)
In @var{obj}'s property list, set the property named @var{key}
@end deffn
\fcons
+@c snarfed from pairs.c:56
@deffn {Scheme Procedure} cons x y
@deffnx {C Function} scm_cons (x, y)
Return a newly allocated pair whose car is @var{x} and whose
@end deffn
\fpair?
+@c snarfed from pairs.c:74
@deffn {Scheme Procedure} pair? x
@deffnx {C Function} scm_pair_p (x)
Return @code{#t} if @var{x} is a pair; otherwise return
@end deffn
\fset-car!
+@c snarfed from pairs.c:85
@deffn {Scheme Procedure} set-car! pair value
@deffnx {C Function} scm_set_car_x (pair, value)
Stores @var{value} in the car field of @var{pair}. The value returned
@end deffn
\fset-cdr!
+@c snarfed from pairs.c:98
@deffn {Scheme Procedure} set-cdr! pair value
@deffnx {C Function} scm_set_cdr_x (pair, value)
Stores @var{value} in the cdr field of @var{pair}. The value returned
@end deffn
\fchar-ready?
+@c snarfed from ports.c:242
@deffn {Scheme Procedure} char-ready? [port]
@deffnx {C Function} scm_char_ready_p (port)
Return @code{#t} if a character is ready on input @var{port}
@code{#t} then the next @code{read-char} operation on
@var{port} is guaranteed not to hang. If @var{port} is a file
port at end of file then @code{char-ready?} returns @code{#t}.
-@footnote{@code{char-ready?} exists to make it possible for a
+
+@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without
getting stuck waiting for input. Any input editors associated
with such ports must make sure that characters whose existence
has been asserted by @code{char-ready?} cannot be rubbed out.
If @code{char-ready?} were to return @code{#f} at end of file,
a port at end of file would be indistinguishable from an
-interactive port that has no ready characters.}
+interactive port that has no ready characters.
@end deffn
\fdrain-input
+@c snarfed from ports.c:319
@deffn {Scheme Procedure} drain-input port
@deffnx {C Function} scm_drain_input (port)
This procedure clears a port's input buffers, similar
@end deffn
\fcurrent-input-port
+@c snarfed from ports.c:347
@deffn {Scheme Procedure} current-input-port
@deffnx {C Function} scm_current_input_port ()
Return the current input port. This is the default port used
@end deffn
\fcurrent-output-port
+@c snarfed from ports.c:359
@deffn {Scheme Procedure} current-output-port
@deffnx {C Function} scm_current_output_port ()
Return the current output port. This is the default port used
@end deffn
\fcurrent-error-port
+@c snarfed from ports.c:369
@deffn {Scheme Procedure} current-error-port
@deffnx {C Function} scm_current_error_port ()
Return the port to which errors and warnings should be sent (the
@end deffn
\fcurrent-load-port
+@c snarfed from ports.c:379
@deffn {Scheme Procedure} current-load-port
@deffnx {C Function} scm_current_load_port ()
Return the current-load-port.
@end deffn
\fset-current-input-port
+@c snarfed from ports.c:392
@deffn {Scheme Procedure} set-current-input-port port
@deffnx {Scheme Procedure} set-current-output-port port
@deffnx {Scheme Procedure} set-current-error-port port
@end deffn
\fset-current-output-port
+@c snarfed from ports.c:405
@deffn {Scheme Procedure} set-current-output-port port
@deffnx {C Function} scm_set_current_output_port (port)
Set the current default output port to @var{port}.
@end deffn
\fset-current-error-port
+@c snarfed from ports.c:419
@deffn {Scheme Procedure} set-current-error-port port
@deffnx {C Function} scm_set_current_error_port (port)
Set the current default error port to @var{port}.
@end deffn
\fport-revealed
+@c snarfed from ports.c:639
@deffn {Scheme Procedure} port-revealed port
@deffnx {C Function} scm_port_revealed (port)
Return the revealed count for @var{port}.
@end deffn
\fset-port-revealed!
+@c snarfed from ports.c:652
@deffn {Scheme Procedure} set-port-revealed! port rcount
@deffnx {C Function} scm_set_port_revealed_x (port, rcount)
Sets the revealed count for a port to a given value.
@end deffn
\fport-mode
+@c snarfed from ports.c:713
@deffn {Scheme Procedure} port-mode port
@deffnx {C Function} scm_port_mode (port)
Return the port modes associated with the open port @var{port}.
@end deffn
\fclose-port
+@c snarfed from ports.c:750
@deffn {Scheme Procedure} close-port port
@deffnx {C Function} scm_close_port (port)
Close the specified port object. Return @code{#t} if it
@end deffn
\fclose-input-port
+@c snarfed from ports.c:780
@deffn {Scheme Procedure} close-input-port port
@deffnx {C Function} scm_close_input_port (port)
Close the specified input port object. The routine has no effect if
@end deffn
\fclose-output-port
+@c snarfed from ports.c:795
@deffn {Scheme Procedure} close-output-port port
@deffnx {C Function} scm_close_output_port (port)
Close the specified output port object. The routine has no effect if
@end deffn
\fport-for-each
+@c snarfed from ports.c:841
@deffn {Scheme Procedure} port-for-each proc
@deffnx {C Function} scm_port_for_each (proc)
Apply @var{proc} to each port in the Guile port table
@end deffn
\finput-port?
+@c snarfed from ports.c:859
@deffn {Scheme Procedure} input-port? x
@deffnx {C Function} scm_input_port_p (x)
Return @code{#t} if @var{x} is an input port, otherwise return
@end deffn
\foutput-port?
+@c snarfed from ports.c:870
@deffn {Scheme Procedure} output-port? x
@deffnx {C Function} scm_output_port_p (x)
Return @code{#t} if @var{x} is an output port, otherwise return
@end deffn
\fport?
+@c snarfed from ports.c:882
@deffn {Scheme Procedure} port? x
@deffnx {C Function} scm_port_p (x)
Return a boolean indicating whether @var{x} is a port.
@end deffn
\fport-closed?
+@c snarfed from ports.c:892
@deffn {Scheme Procedure} port-closed? port
@deffnx {C Function} scm_port_closed_p (port)
Return @code{#t} if @var{port} is closed or @code{#f} if it is
@end deffn
\feof-object?
+@c snarfed from ports.c:903
@deffn {Scheme Procedure} eof-object? x
@deffnx {C Function} scm_eof_object_p (x)
Return @code{#t} if @var{x} is an end-of-file object; otherwise
@end deffn
\fforce-output
+@c snarfed from ports.c:917
@deffn {Scheme Procedure} force-output [port]
@deffnx {C Function} scm_force_output (port)
Flush the specified output port, or the current output port if @var{port}
@end deffn
\fflush-all-ports
+@c snarfed from ports.c:935
@deffn {Scheme Procedure} flush-all-ports
@deffnx {C Function} scm_flush_all_ports ()
Equivalent to calling @code{force-output} on
@end deffn
\fread-char
+@c snarfed from ports.c:955
@deffn {Scheme Procedure} read-char [port]
@deffnx {C Function} scm_read_char (port)
Return the next character available from @var{port}, updating
@end deffn
\fpeek-char
+@c snarfed from ports.c:1281
@deffn {Scheme Procedure} peek-char [port]
@deffnx {C Function} scm_peek_char (port)
Return the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character. If no more characters are available, the
-end-of-file object is returned.@footnote{The value returned by
+end-of-file object is returned.
+
+The value returned by
a call to @code{peek-char} is the same as the value that would
have been returned by a call to @code{read-char} on the same
port. The only difference is that the very next call to
return the value returned by the preceding call to
@code{peek-char}. In particular, a call to @code{peek-char} on
an interactive port will hang waiting for input whenever a call
-to @code{read-char} would have hung.}
+to @code{read-char} would have hung.
@end deffn
\funread-char
+@c snarfed from ports.c:1304
@deffn {Scheme Procedure} unread-char cobj [port]
@deffnx {C Function} scm_unread_char (cobj, port)
Place @var{char} in @var{port} so that it will be read by the
@end deffn
\funread-string
+@c snarfed from ports.c:1327
@deffn {Scheme Procedure} unread-string str port
@deffnx {C Function} scm_unread_string (str, port)
Place the string @var{str} in @var{port} so that its characters will be
@end deffn
\fseek
+@c snarfed from ports.c:1366
@deffn {Scheme Procedure} seek fd_port offset whence
@deffnx {C Function} scm_seek (fd_port, offset, whence)
Sets the current position of @var{fd/port} to the integer
@end deffn
\ftruncate-file
+@c snarfed from ports.c:1424
@deffn {Scheme Procedure} truncate-file object [length]
@deffnx {C Function} scm_truncate_file (object, length)
Truncates the object referred to by @var{object} to at most
@var{length} bytes. @var{object} can be a string containing a
file name or an integer file descriptor or a port.
@var{length} may be omitted if @var{object} is not a file name,
-in which case the truncation occurs at the current port.
+in which case the truncation occurs at the current port
position. The return value is unspecified.
@end deffn
\fport-line
+@c snarfed from ports.c:1484
@deffn {Scheme Procedure} port-line port
@deffnx {C Function} scm_port_line (port)
Return the current line number for @var{port}.
+
+The first line of a file is 0. But you might want to add 1
+when printing line numbers, since starting from 1 is
+traditional in error messages, and likely to be more natural to
+non-programmers.
@end deffn
\fset-port-line!
+@c snarfed from ports.c:1496
@deffn {Scheme Procedure} set-port-line! port line
@deffnx {C Function} scm_set_port_line_x (port, line)
-Set the current line number for @var{port} to @var{line}.
+Set the current line number for @var{port} to @var{line}. The
+first line of a file is 0.
@end deffn
\fport-column
+@c snarfed from ports.c:1515
@deffn {Scheme Procedure} port-column port
-@deffnx {Scheme Procedure} port-line port
@deffnx {C Function} scm_port_column (port)
-Return the current column number or line number of @var{port},
-using the current input port if none is specified. If the number is
+Return the current column number of @var{port}.
+If the number is
unknown, the result is #f. Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
@end deffn
\fset-port-column!
+@c snarfed from ports.c:1527
@deffn {Scheme Procedure} set-port-column! port column
-@deffnx {Scheme Procedure} set-port-line! port line
@deffnx {C Function} scm_set_port_column_x (port, column)
-Set the current column or line number of @var{port}, using the
-current input port if none is specified.
+Set the current column of @var{port}. Before reading the first
+character on a line the column should be 0.
@end deffn
\fport-filename
+@c snarfed from ports.c:1541
@deffn {Scheme Procedure} port-filename port
@deffnx {C Function} scm_port_filename (port)
Return the filename associated with @var{port}. This function returns
@end deffn
\fset-port-filename!
+@c snarfed from ports.c:1555
@deffn {Scheme Procedure} set-port-filename! port filename
@deffnx {C Function} scm_set_port_filename_x (port, filename)
Change the filename associated with @var{port}, using the current input
@end deffn
\f%make-void-port
+@c snarfed from ports.c:1649
@deffn {Scheme Procedure} %make-void-port mode
@deffnx {C Function} scm_sys_make_void_port (mode)
Create and return a new void port. A void port acts like
@end deffn
\fprint-options-interface
+@c snarfed from print.c:83
@deffn {Scheme Procedure} print-options-interface [setting]
@deffnx {C Function} scm_print_options (setting)
Option interface for the print options. Instead of using
@end deffn
\fsimple-format
+@c snarfed from print.c:914
@deffn {Scheme Procedure} simple-format destination message . args
@deffnx {C Function} scm_simple_format (destination, message, args)
Write @var{message} to @var{destination}, defaulting to
@end deffn
\fnewline
+@c snarfed from print.c:1004
@deffn {Scheme Procedure} newline [port]
@deffnx {C Function} scm_newline (port)
Send a newline to @var{port}.
@end deffn
\fwrite-char
+@c snarfed from print.c:1019
@deffn {Scheme Procedure} write-char chr [port]
@deffnx {C Function} scm_write_char (chr, port)
Send character @var{chr} to @var{port}.
@end deffn
\fport-with-print-state
-@deffn {Scheme Procedure} port-with-print-state port pstate
+@c snarfed from print.c:1073
+@deffn {Scheme Procedure} port-with-print-state port [pstate]
@deffnx {C Function} scm_port_with_print_state (port, pstate)
Create a new port which behaves like @var{port}, but with an
-included print state @var{pstate}.
+included print state @var{pstate}. @var{pstate} is optional.
+If @var{pstate} isn't supplied and @var{port} already has
+a print state, the old print state is reused.
@end deffn
\fget-print-state
+@c snarfed from print.c:1086
@deffn {Scheme Procedure} get-print-state port
@deffnx {C Function} scm_get_print_state (port)
Return the print state of the port @var{port}. If @var{port}
@end deffn
\fprocedure-properties
+@c snarfed from procprop.c:160
@deffn {Scheme Procedure} procedure-properties proc
@deffnx {C Function} scm_procedure_properties (proc)
Return @var{obj}'s property list.
@end deffn
\fset-procedure-properties!
+@c snarfed from procprop.c:173
@deffn {Scheme Procedure} set-procedure-properties! proc new_val
@deffnx {C Function} scm_set_procedure_properties_x (proc, new_val)
Set @var{obj}'s property list to @var{alist}.
@end deffn
\fprocedure-property
+@c snarfed from procprop.c:186
@deffn {Scheme Procedure} procedure-property p k
@deffnx {C Function} scm_procedure_property (p, k)
Return the property of @var{obj} with name @var{key}.
@end deffn
\fset-procedure-property!
+@c snarfed from procprop.c:209
@deffn {Scheme Procedure} set-procedure-property! p k v
@deffnx {C Function} scm_set_procedure_property_x (p, k, v)
In @var{obj}'s property list, set the property named @var{key} to
@end deffn
\fprocedure?
+@c snarfed from procs.c:162
@deffn {Scheme Procedure} procedure? obj
@deffnx {C Function} scm_procedure_p (obj)
Return @code{#t} if @var{obj} is a procedure.
@end deffn
\fclosure?
+@c snarfed from procs.c:189
@deffn {Scheme Procedure} closure? obj
@deffnx {C Function} scm_closure_p (obj)
Return @code{#t} if @var{obj} is a closure.
@end deffn
\fthunk?
+@c snarfed from procs.c:198
@deffn {Scheme Procedure} thunk? obj
@deffnx {C Function} scm_thunk_p (obj)
Return @code{#t} if @var{obj} is a thunk.
@end deffn
\fprocedure-documentation
+@c snarfed from procs.c:248
@deffn {Scheme Procedure} procedure-documentation proc
@deffnx {C Function} scm_procedure_documentation (proc)
Return the documentation string associated with @code{proc}. By
@end deffn
\fprocedure-with-setter?
+@c snarfed from procs.c:284
@deffn {Scheme Procedure} procedure-with-setter? obj
@deffnx {C Function} scm_procedure_with_setter_p (obj)
Return @code{#t} if @var{obj} is a procedure with an
@end deffn
\fmake-procedure-with-setter
+@c snarfed from procs.c:294
@deffn {Scheme Procedure} make-procedure-with-setter procedure setter
@deffnx {C Function} scm_make_procedure_with_setter (procedure, setter)
Create a new procedure which behaves like @var{procedure}, but
@end deffn
\fprocedure
+@c snarfed from procs.c:308
@deffn {Scheme Procedure} procedure proc
@deffnx {C Function} scm_procedure (proc)
Return the procedure of @var{proc}, which must be either a
@end deffn
\fprimitive-make-property
+@c snarfed from properties.c:40
@deffn {Scheme Procedure} primitive-make-property not_found_proc
@deffnx {C Function} scm_primitive_make_property (not_found_proc)
Create a @dfn{property token} that can be used with
@end deffn
\fprimitive-property-ref
+@c snarfed from properties.c:59
@deffn {Scheme Procedure} primitive-property-ref prop obj
@deffnx {C Function} scm_primitive_property_ref (prop, obj)
-Return the property @var{prop} of @var{obj}. When no value
-has yet been associated with @var{prop} and @var{obj}, call
-@var{not-found-proc} instead (see @code{primitive-make-property})
-and use its return value. That value is also associated with
-@var{obj} via @code{primitive-property-set!}. When
-@var{not-found-proc} is @code{#f}, use @code{#f} as the
-default value of @var{prop}.
+Return the property @var{prop} of @var{obj}.
+
+When no value has yet been associated with @var{prop} and
+@var{obj}, the @var{not-found-proc} from @var{prop} is used. A
+call @code{(@var{not-found-proc} @var{prop} @var{obj})} is made
+and the result set as the property value. If
+@var{not-found-proc} is @code{#f} then @code{#f} is the
+property value.
@end deffn
\fprimitive-property-set!
+@c snarfed from properties.c:90
@deffn {Scheme Procedure} primitive-property-set! prop obj val
@deffnx {C Function} scm_primitive_property_set_x (prop, obj, val)
-Associate @var{code} with @var{prop} and @var{obj}.
+Set the property @var{prop} of @var{obj} to @var{val}.
@end deffn
\fprimitive-property-del!
+@c snarfed from properties.c:111
@deffn {Scheme Procedure} primitive-property-del! prop obj
@deffnx {C Function} scm_primitive_property_del_x (prop, obj)
Remove any value associated with @var{prop} and @var{obj}.
@end deffn
\frandom
+@c snarfed from random.c:346
@deffn {Scheme Procedure} random n [state]
@deffnx {C Function} scm_random (n, state)
Return a number in [0, N).
@end deffn
\fcopy-random-state
+@c snarfed from random.c:371
@deffn {Scheme Procedure} copy-random-state [state]
@deffnx {C Function} scm_copy_random_state (state)
Return a copy of the random state @var{state}.
@end deffn
\fseed->random-state
+@c snarfed from random.c:383
@deffn {Scheme Procedure} seed->random-state seed
@deffnx {C Function} scm_seed_to_random_state (seed)
Return a new random state using @var{seed}.
@end deffn
\frandom:uniform
+@c snarfed from random.c:401
@deffn {Scheme Procedure} random:uniform [state]
@deffnx {C Function} scm_random_uniform (state)
Return a uniformly distributed inexact real random number in
@end deffn
\frandom:normal
+@c snarfed from random.c:416
@deffn {Scheme Procedure} random:normal [state]
@deffnx {C Function} scm_random_normal (state)
Return an inexact real in a normal distribution. The
@end deffn
\frandom:solid-sphere!
+@c snarfed from random.c:472
@deffn {Scheme Procedure} random:solid-sphere! v [state]
@deffnx {C Function} scm_random_solid_sphere_x (v, state)
Fills vect with inexact real random numbers
@end deffn
\frandom:hollow-sphere!
+@c snarfed from random.c:495
@deffn {Scheme Procedure} random:hollow-sphere! v [state]
@deffnx {C Function} scm_random_hollow_sphere_x (v, state)
Fills vect with inexact real random numbers
@end deffn
\frandom:normal-vector!
+@c snarfed from random.c:513
@deffn {Scheme Procedure} random:normal-vector! v [state]
@deffnx {C Function} scm_random_normal_vector_x (v, state)
Fills vect with inexact real random numbers that are
@end deffn
\frandom:exp
+@c snarfed from random.c:538
@deffn {Scheme Procedure} random:exp [state]
@deffnx {C Function} scm_random_exp (state)
Return an inexact real in an exponential distribution with mean
@end deffn
\f%read-delimited!
+@c snarfed from rdelim.c:55
@deffn {Scheme Procedure} %read-delimited! delims str gobble [port [start [end]]]
@deffnx {C Function} scm_read_delimited_x (delims, str, gobble, port, start, end)
Read characters from @var{port} into @var{str} until one of the
@end deffn
\f%read-line
+@c snarfed from rdelim.c:202
@deffn {Scheme Procedure} %read-line [port]
@deffnx {C Function} scm_read_line (port)
Read a newline-terminated line from @var{port}, allocating storage as
@end deffn
\fwrite-line
+@c snarfed from rdelim.c:255
@deffn {Scheme Procedure} write-line obj [port]
@deffnx {C Function} scm_write_line (obj, port)
Display @var{obj} and a newline character to @var{port}. If
@end deffn
\fread-options-interface
+@c snarfed from read.c:109
@deffn {Scheme Procedure} read-options-interface [setting]
@deffnx {C Function} scm_read_options (setting)
Option interface for the read options. Instead of using
@end deffn
\fread
+@c snarfed from read.c:129
@deffn {Scheme Procedure} read [port]
@deffnx {C Function} scm_read (port)
Read an s-expression from the input port @var{port}, or from
@end deffn
\fread-hash-extend
+@c snarfed from read.c:866
@deffn {Scheme Procedure} read-hash-extend chr proc
@deffnx {C Function} scm_read_hash_extend (chr, proc)
Install the procedure @var{proc} for reading expressions
@end deffn
\fcall-with-dynamic-root
+@c snarfed from root.c:320
@deffn {Scheme Procedure} call-with-dynamic-root thunk handler
@deffnx {C Function} scm_call_with_dynamic_root (thunk, handler)
Evaluate @code{(thunk)} in a new dynamic context, returning its value.
@end deffn
\fdynamic-root
+@c snarfed from root.c:333
@deffn {Scheme Procedure} dynamic-root
@deffnx {C Function} scm_dynamic_root ()
Return an object representing the current dynamic root.
@end deffn
\fread-string!/partial
+@c snarfed from rw.c:101
@deffn {Scheme Procedure} read-string!/partial str [port_or_fdes [start [end]]]
@deffnx {C Function} scm_read_string_x_partial (str, port_or_fdes, start, end)
Read characters from a port or file descriptor into a
@end deffn
\fwrite-string/partial
+@c snarfed from rw.c:205
@deffn {Scheme Procedure} write-string/partial str [port_or_fdes [start [end]]]
@deffnx {C Function} scm_write_string_partial (str, port_or_fdes, start, end)
Write characters from a string @var{str} to a port or file
@end deffn
\fsigaction
+@c snarfed from scmsigs.c:285
@deffn {Scheme Procedure} sigaction signum [handler [flags [thread]]]
@deffnx {C Function} scm_sigaction_for_thread (signum, handler, flags, thread)
Install or report the signal handler for a specified signal.
@end deffn
\frestore-signals
+@c snarfed from scmsigs.c:456
@deffn {Scheme Procedure} restore-signals
@deffnx {C Function} scm_restore_signals ()
Return all signal handlers to the values they had before any call to
@end deffn
\falarm
+@c snarfed from scmsigs.c:493
@deffn {Scheme Procedure} alarm i
@deffnx {C Function} scm_alarm (i)
Set a timer to raise a @code{SIGALRM} signal after the specified
@end deffn
\fsetitimer
+@c snarfed from scmsigs.c:520
@deffn {Scheme Procedure} setitimer which_timer interval_seconds interval_microseconds value_seconds value_microseconds
@deffnx {C Function} scm_setitimer (which_timer, interval_seconds, interval_microseconds, value_seconds, value_microseconds)
Set the timer specified by @var{which_timer} according to the given
@end deffn
\fgetitimer
+@c snarfed from scmsigs.c:561
@deffn {Scheme Procedure} getitimer which_timer
@deffnx {C Function} scm_getitimer (which_timer)
Return information about the timer specified by @var{which_timer}
@end deffn
\fpause
+@c snarfed from scmsigs.c:588
@deffn {Scheme Procedure} pause
@deffnx {C Function} scm_pause ()
Pause the current process (thread?) until a signal arrives whose
@end deffn
\fsleep
+@c snarfed from scmsigs.c:601
@deffn {Scheme Procedure} sleep i
@deffnx {C Function} scm_sleep (i)
Wait for the given number of seconds (an integer) or until a signal
@end deffn
\fusleep
+@c snarfed from scmsigs.c:610
@deffn {Scheme Procedure} usleep i
@deffnx {C Function} scm_usleep (i)
-Sleep for I microseconds. @code{usleep} is not available on
-all platforms.
+Sleep for @var{i} microseconds.
@end deffn
\fraise
+@c snarfed from scmsigs.c:620
@deffn {Scheme Procedure} raise sig
@deffnx {C Function} scm_raise (sig)
Sends a specified signal @var{sig} to the current process, where
@end deffn
\fsystem
+@c snarfed from simpos.c:64
@deffn {Scheme Procedure} system [cmd]
@deffnx {C Function} scm_system (cmd)
Execute @var{cmd} using the operating system's "command
processor". Under Unix this is usually the default shell
@code{sh}. The value returned is @var{cmd}'s exit status as
-returned by @code{waitpid}, which can be interpreted using the
-functions above.
+returned by @code{waitpid}, which can be interpreted using
+@code{status:exit-val} and friends.
If @code{system} is called without arguments, return a boolean
indicating whether the command processor is available.
@end deffn
+\fsystem*
+@c snarfed from simpos.c:114
+@deffn {Scheme Procedure} system* . args
+@deffnx {C Function} scm_system_star (args)
+Execute the command indicated by @var{args}. The first element must
+be a string indicating the command to be executed, and the remaining
+items must be strings representing each of the arguments to that
+command.
+
+This function returns the exit status of the command as provided by
+@code{waitpid}. This value can be handled with @code{status:exit-val}
+and the related functions.
+
+@code{system*} is similar to @code{system}, but accepts only one
+string per-argument, and performs no shell interpretation. The
+command is executed using fork and execlp. Accordingly this function
+may be safer than @code{system} in situations where shell
+interpretation is not required.
+
+Example: (system* "echo" "foo" "bar")
+@end deffn
+
\fgetenv
+@c snarfed from simpos.c:184
@deffn {Scheme Procedure} getenv nam
@deffnx {C Function} scm_getenv (nam)
Looks up the string @var{name} in the current environment. The return
@end deffn
\fprimitive-exit
+@c snarfed from simpos.c:200
@deffn {Scheme Procedure} primitive-exit [status]
@deffnx {C Function} scm_primitive_exit (status)
Terminate the current process without unwinding the Scheme stack.
@end deffn
\frestricted-vector-sort!
+@c snarfed from sort.c:291
@deffn {Scheme Procedure} restricted-vector-sort! vec less startpos endpos
@deffnx {C Function} scm_restricted_vector_sort_x (vec, less, startpos, endpos)
Sort the vector @var{vec}, using @var{less} for comparing
@end deffn
\fsorted?
+@c snarfed from sort.c:321
@deffn {Scheme Procedure} sorted? items less
@deffnx {C Function} scm_sorted_p (items, less)
Return @code{#t} iff @var{items} is a list or a vector such that
@end deffn
\fmerge
+@c snarfed from sort.c:393
@deffn {Scheme Procedure} merge alist blist less
@deffnx {C Function} scm_merge (alist, blist, less)
Merge two already sorted lists into one.
@end deffn
\fmerge!
+@c snarfed from sort.c:508
@deffn {Scheme Procedure} merge! alist blist less
@deffnx {C Function} scm_merge_x (alist, blist, less)
Takes two lists @var{alist} and @var{blist} such that
@end deffn
\fsort!
+@c snarfed from sort.c:577
@deffn {Scheme Procedure} sort! items less
@deffnx {C Function} scm_sort_x (items, less)
Sort the sequence @var{items}, which may be a list or a
@end deffn
\fsort
+@c snarfed from sort.c:609
@deffn {Scheme Procedure} sort items less
@deffnx {C Function} scm_sort (items, less)
Sort the sequence @var{items}, which may be a list or a
@end deffn
\fstable-sort!
+@c snarfed from sort.c:717
@deffn {Scheme Procedure} stable-sort! items less
@deffnx {C Function} scm_stable_sort_x (items, less)
Sort the sequence @var{items}, which may be a list or a
@end deffn
\fstable-sort
+@c snarfed from sort.c:756
@deffn {Scheme Procedure} stable-sort items less
@deffnx {C Function} scm_stable_sort (items, less)
Sort the sequence @var{items}, which may be a list or a
@end deffn
\fsort-list!
+@c snarfed from sort.c:797
@deffn {Scheme Procedure} sort-list! items less
@deffnx {C Function} scm_sort_list_x (items, less)
Sort the list @var{items}, using @var{less} for comparing the
@end deffn
\fsort-list
+@c snarfed from sort.c:812
@deffn {Scheme Procedure} sort-list items less
@deffnx {C Function} scm_sort_list (items, less)
Sort the list @var{items}, using @var{less} for comparing the
@end deffn
\fsource-properties
+@c snarfed from srcprop.c:152
@deffn {Scheme Procedure} source-properties obj
@deffnx {C Function} scm_source_properties (obj)
Return the source property association list of @var{obj}.
@end deffn
\fset-source-properties!
+@c snarfed from srcprop.c:175
@deffn {Scheme Procedure} set-source-properties! obj plist
@deffnx {C Function} scm_set_source_properties_x (obj, plist)
Install the association list @var{plist} as the source property
@end deffn
\fsource-property
+@c snarfed from srcprop.c:193
@deffn {Scheme Procedure} source-property obj key
@deffnx {C Function} scm_source_property (obj, key)
Return the source property specified by @var{key} from
@end deffn
\fset-source-property!
+@c snarfed from srcprop.c:224
@deffn {Scheme Procedure} set-source-property! obj key datum
@deffnx {C Function} scm_set_source_property_x (obj, key, datum)
Set the source property of object @var{obj}, which is specified by
@end deffn
\fstack?
+@c snarfed from stacks.c:384
@deffn {Scheme Procedure} stack? obj
@deffnx {C Function} scm_stack_p (obj)
Return @code{#t} if @var{obj} is a calling stack.
@end deffn
\fmake-stack
+@c snarfed from stacks.c:415
@deffn {Scheme Procedure} make-stack obj . args
@deffnx {C Function} scm_make_stack (obj, args)
Create a new stack. If @var{obj} is @code{#t}, the current
@end deffn
\fstack-id
+@c snarfed from stacks.c:507
@deffn {Scheme Procedure} stack-id stack
@deffnx {C Function} scm_stack_id (stack)
Return the identifier given to @var{stack} by @code{start-stack}.
@end deffn
\fstack-ref
+@c snarfed from stacks.c:548
@deffn {Scheme Procedure} stack-ref stack index
@deffnx {C Function} scm_stack_ref (stack, index)
Return the @var{index}'th frame from @var{stack}.
@end deffn
\fstack-length
+@c snarfed from stacks.c:561
@deffn {Scheme Procedure} stack-length stack
@deffnx {C Function} scm_stack_length (stack)
Return the length of @var{stack}.
@end deffn
\fframe?
+@c snarfed from stacks.c:574
@deffn {Scheme Procedure} frame? obj
@deffnx {C Function} scm_frame_p (obj)
Return @code{#t} if @var{obj} is a stack frame.
@end deffn
\flast-stack-frame
+@c snarfed from stacks.c:585
@deffn {Scheme Procedure} last-stack-frame obj
@deffnx {C Function} scm_last_stack_frame (obj)
Return a stack which consists of a single frame, which is the
@end deffn
\fframe-number
+@c snarfed from stacks.c:627
@deffn {Scheme Procedure} frame-number frame
@deffnx {C Function} scm_frame_number (frame)
Return the frame number of @var{frame}.
@end deffn
\fframe-source
+@c snarfed from stacks.c:637
@deffn {Scheme Procedure} frame-source frame
@deffnx {C Function} scm_frame_source (frame)
Return the source of @var{frame}.
@end deffn
\fframe-procedure
+@c snarfed from stacks.c:648
@deffn {Scheme Procedure} frame-procedure frame
@deffnx {C Function} scm_frame_procedure (frame)
Return the procedure for @var{frame}, or @code{#f} if no
@end deffn
\fframe-arguments
+@c snarfed from stacks.c:660
@deffn {Scheme Procedure} frame-arguments frame
@deffnx {C Function} scm_frame_arguments (frame)
Return the arguments of @var{frame}.
@end deffn
\fframe-previous
+@c snarfed from stacks.c:671
@deffn {Scheme Procedure} frame-previous frame
@deffnx {C Function} scm_frame_previous (frame)
Return the previous frame of @var{frame}, or @code{#f} if
@end deffn
\fframe-next
+@c snarfed from stacks.c:687
@deffn {Scheme Procedure} frame-next frame
@deffnx {C Function} scm_frame_next (frame)
Return the next frame of @var{frame}, or @code{#f} if
@end deffn
\fframe-real?
+@c snarfed from stacks.c:702
@deffn {Scheme Procedure} frame-real? frame
@deffnx {C Function} scm_frame_real_p (frame)
Return @code{#t} if @var{frame} is a real frame.
@end deffn
\fframe-procedure?
+@c snarfed from stacks.c:712
@deffn {Scheme Procedure} frame-procedure? frame
@deffnx {C Function} scm_frame_procedure_p (frame)
Return @code{#t} if a procedure is associated with @var{frame}.
@end deffn
\fframe-evaluating-args?
+@c snarfed from stacks.c:722
@deffn {Scheme Procedure} frame-evaluating-args? frame
@deffnx {C Function} scm_frame_evaluating_args_p (frame)
Return @code{#t} if @var{frame} contains evaluated arguments.
@end deffn
\fframe-overflow?
+@c snarfed from stacks.c:732
@deffn {Scheme Procedure} frame-overflow? frame
@deffnx {C Function} scm_frame_overflow_p (frame)
Return @code{#t} if @var{frame} is an overflow frame.
@end deffn
\fget-internal-real-time
+@c snarfed from stime.c:117
@deffn {Scheme Procedure} get-internal-real-time
@deffnx {C Function} scm_get_internal_real_time ()
Return the number of time units since the interpreter was
@end deffn
\ftimes
+@c snarfed from stime.c:164
@deffn {Scheme Procedure} times
@deffnx {C Function} scm_times ()
Return an object with information about real and processor
@end deffn
\fget-internal-run-time
+@c snarfed from stime.c:196
@deffn {Scheme Procedure} get-internal-run-time
@deffnx {C Function} scm_get_internal_run_time ()
Return the number of time units of processor time used by the
@end deffn
\fcurrent-time
+@c snarfed from stime.c:213
@deffn {Scheme Procedure} current-time
@deffnx {C Function} scm_current_time ()
Return the number of seconds since 1970-01-01 00:00:00 UTC,
@end deffn
\fgettimeofday
+@c snarfed from stime.c:231
@deffn {Scheme Procedure} gettimeofday
@deffnx {C Function} scm_gettimeofday ()
Return a pair containing the number of seconds and microseconds
@end deffn
\flocaltime
+@c snarfed from stime.c:335
@deffn {Scheme Procedure} localtime time [zone]
@deffnx {C Function} scm_localtime (time, zone)
Return an object representing the broken down components of
@end deffn
\fgmtime
+@c snarfed from stime.c:420
@deffn {Scheme Procedure} gmtime time
@deffnx {C Function} scm_gmtime (time)
Return an object representing the broken down components of
@end deffn
\fmktime
+@c snarfed from stime.c:498
@deffn {Scheme Procedure} mktime sbd_time [zone]
@deffnx {C Function} scm_mktime (sbd_time, zone)
@var{bd-time} is an object representing broken down time and @code{zone}
@end deffn
\ftzset
+@c snarfed from stime.c:581
@deffn {Scheme Procedure} tzset
@deffnx {C Function} scm_tzset ()
Initialize the timezone from the TZ environment variable
@end deffn
\fstrftime
+@c snarfed from stime.c:598
@deffn {Scheme Procedure} strftime format stime
@deffnx {C Function} scm_strftime (format, stime)
Formats a time specification @var{time} using @var{template}. @var{time}
@end deffn
\fstrptime
+@c snarfed from stime.c:696
@deffn {Scheme Procedure} strptime format string
@deffnx {C Function} scm_strptime (format, string)
Performs the reverse action to @code{strftime}, parsing
@end deffn
\fstring?
+@c snarfed from strings.c:481
@deffn {Scheme Procedure} string? obj
@deffnx {C Function} scm_string_p (obj)
Return @code{#t} if @var{obj} is a string, else @code{#f}.
@end deffn
\flist->string
+@c snarfed from strings.c:489
@deffn {Scheme Procedure} list->string
implemented by the C function "scm_string"
@end deffn
\fstring
+@c snarfed from strings.c:495
@deffn {Scheme Procedure} string . chrs
@deffnx {Scheme Procedure} list->string chrs
@deffnx {C Function} scm_string (chrs)
@end deffn
\fmake-string
+@c snarfed from strings.c:533
@deffn {Scheme Procedure} make-string k [chr]
@deffnx {C Function} scm_make_string (k, chr)
Return a newly allocated string of
@end deffn
\fstring-length
+@c snarfed from strings.c:559
@deffn {Scheme Procedure} string-length string
@deffnx {C Function} scm_string_length (string)
Return the number of characters in @var{string}.
@end deffn
\fstring-ref
+@c snarfed from strings.c:578
@deffn {Scheme Procedure} string-ref str k
@deffnx {C Function} scm_string_ref (str, k)
Return character @var{k} of @var{str} using zero-origin
@end deffn
\fstring-set!
+@c snarfed from strings.c:601
@deffn {Scheme Procedure} string-set! str k chr
@deffnx {C Function} scm_string_set_x (str, k, chr)
Store @var{chr} in element @var{k} of @var{str} and return
@end deffn
\fsubstring
+@c snarfed from strings.c:637
@deffn {Scheme Procedure} substring str start [end]
@deffnx {C Function} scm_substring (str, start, end)
Return a newly allocated string formed from the characters
0 <= @var{start} <= @var{end} <= (string-length @var{str}).
@end deffn
+\fsubstring/copy
+@c snarfed from strings.c:660
+@deffn {Scheme Procedure} substring/copy str start [end]
+@deffnx {C Function} scm_substring_copy (str, start, end)
+Return a newly allocated string formed from the characters
+of @var{str} beginning with index @var{start} (inclusive) and
+ending with index @var{end} (exclusive).
+@var{str} must be a string, @var{start} and @var{end} must be
+exact integers satisfying:
+
+0 <= @var{start} <= @var{end} <= (string-length @var{str}).
+@end deffn
+
+\fsubstring/shared
+@c snarfed from strings.c:683
+@deffn {Scheme Procedure} substring/shared str start [end]
+@deffnx {C Function} scm_substring_shared (str, start, end)
+Return string that indirectly refers to the characters
+of @var{str} beginning with index @var{start} (inclusive) and
+ending with index @var{end} (exclusive).
+@var{str} must be a string, @var{start} and @var{end} must be
+exact integers satisfying:
+
+0 <= @var{start} <= @var{end} <= (string-length @var{str}).
+@end deffn
+
\fstring-append
+@c snarfed from strings.c:702
@deffn {Scheme Procedure} string-append . args
@deffnx {C Function} scm_string_append (args)
Return a newly allocated string whose characters form the
@end deffn
\fstring-index
+@c snarfed from strop.c:113
@deffn {Scheme Procedure} string-index str chr [frm [to]]
@deffnx {C Function} scm_string_index (str, chr, frm, to)
Return the index of the first occurrence of @var{chr} in
@end deffn
\fstring-rindex
+@c snarfed from strop.c:143
@deffn {Scheme Procedure} string-rindex str chr [frm [to]]
@deffnx {C Function} scm_string_rindex (str, chr, frm, to)
Like @code{string-index}, but search from the right of the
@end deffn
\fsubstring-move!
+@c snarfed from strop.c:163
@deffn {Scheme Procedure} substring-move! str1 start1 end1 str2 start2
@deffnx {C Function} scm_substring_move_x (str1, start1, end1, str2, start2)
Copy the substring of @var{str1} bounded by @var{start1} and @var{end1}
@end deffn
\fsubstring-fill!
+@c snarfed from strop.c:198
@deffn {Scheme Procedure} substring-fill! str start end fill
@deffnx {C Function} scm_substring_fill_x (str, start, end, fill)
Change every character in @var{str} between @var{start} and
@end deffn
\fstring-null?
+@c snarfed from strop.c:227
@deffn {Scheme Procedure} string-null? str
@deffnx {C Function} scm_string_null_p (str)
Return @code{#t} if @var{str}'s length is zero, and
@end deffn
\fstring->list
+@c snarfed from strop.c:241
@deffn {Scheme Procedure} string->list str
@deffnx {C Function} scm_string_to_list (str)
Return a newly allocated list of the characters that make up
@end deffn
\fstring-copy
+@c snarfed from strop.c:274
@deffn {Scheme Procedure} string-copy str
@deffnx {C Function} scm_string_copy (str)
Return a newly allocated copy of the given @var{string}.
@end deffn
\fstring-fill!
+@c snarfed from strop.c:285
@deffn {Scheme Procedure} string-fill! str chr
@deffnx {C Function} scm_string_fill_x (str, chr)
Store @var{char} in every element of the given @var{string} and
@end deffn
\fstring-upcase!
+@c snarfed from strop.c:327
@deffn {Scheme Procedure} string-upcase! str
@deffnx {C Function} scm_string_upcase_x (str)
Destructively upcase every character in @var{str} and return
@end deffn
\fstring-upcase
+@c snarfed from strop.c:340
@deffn {Scheme Procedure} string-upcase str
@deffnx {C Function} scm_string_upcase (str)
Return a freshly allocated string containing the characters of
@end deffn
\fstring-downcase!
+@c snarfed from strop.c:376
@deffn {Scheme Procedure} string-downcase! str
@deffnx {C Function} scm_string_downcase_x (str)
Destructively downcase every character in @var{str} and return
@end deffn
\fstring-downcase
+@c snarfed from strop.c:389
@deffn {Scheme Procedure} string-downcase str
@deffnx {C Function} scm_string_downcase (str)
Return a freshly allocation string containing the characters in
@end deffn
\fstring-capitalize!
+@c snarfed from strop.c:441
@deffn {Scheme Procedure} string-capitalize! str
@deffnx {C Function} scm_string_capitalize_x (str)
Upcase the first character of every word in @var{str}
@end deffn
\fstring-capitalize
+@c snarfed from strop.c:455
@deffn {Scheme Procedure} string-capitalize str
@deffnx {C Function} scm_string_capitalize (str)
Return a freshly allocated string with the characters in
@end deffn
\fstring-split
+@c snarfed from strop.c:484
@deffn {Scheme Procedure} string-split str chr
@deffnx {C Function} scm_string_split (str, chr)
Split the string @var{str} into the a list of the substrings delimited
@end deffn
\fstring-ci->symbol
+@c snarfed from strop.c:520
@deffn {Scheme Procedure} string-ci->symbol str
@deffnx {C Function} scm_string_ci_to_symbol (str)
Return the symbol whose name is @var{str}. @var{str} is
@end deffn
\fstring=?
+@c snarfed from strorder.c:38
@deffn {Scheme Procedure} string=? s1 s2
Lexicographic equality predicate; return @code{#t} if the two
strings are the same length and contain the same characters in
@end deffn
\fstring-ci=?
+@c snarfed from strorder.c:77
@deffn {Scheme Procedure} string-ci=? s1 s2
Case-insensitive string equality predicate; return @code{#t} if
the two strings are the same length and their component
@end deffn
\fstring<?
+@c snarfed from strorder.c:140
@deffn {Scheme Procedure} string<? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically less than @var{s2}.
@end deffn
\fstring<=?
+@c snarfed from strorder.c:154
@deffn {Scheme Procedure} string<=? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically less than or equal to @var{s2}.
@end deffn
\fstring>?
+@c snarfed from strorder.c:168
@deffn {Scheme Procedure} string>? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically greater than @var{s2}.
@end deffn
\fstring>=?
+@c snarfed from strorder.c:182
@deffn {Scheme Procedure} string>=? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically greater than or equal to @var{s2}.
@end deffn
\fstring-ci<?
+@c snarfed from strorder.c:223
@deffn {Scheme Procedure} string-ci<? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than @var{s2}
@end deffn
\fstring-ci<=?
+@c snarfed from strorder.c:238
@deffn {Scheme Procedure} string-ci<=? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than or equal
@end deffn
\fstring-ci>?
+@c snarfed from strorder.c:253
@deffn {Scheme Procedure} string-ci>? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than
@end deffn
\fstring-ci>=?
+@c snarfed from strorder.c:268
@deffn {Scheme Procedure} string-ci>=? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than or
@end deffn
\fobject->string
+@c snarfed from strports.c:332
@deffn {Scheme Procedure} object->string obj [printer]
@deffnx {C Function} scm_object_to_string (obj, printer)
Return a Scheme string obtained by printing @var{obj}.
@end deffn
\fcall-with-output-string
+@c snarfed from strports.c:356
@deffn {Scheme Procedure} call-with-output-string proc
@deffnx {C Function} scm_call_with_output_string (proc)
Calls the one-argument procedure @var{proc} with a newly created output
@end deffn
\fcall-with-input-string
+@c snarfed from strports.c:375
@deffn {Scheme Procedure} call-with-input-string string proc
@deffnx {C Function} scm_call_with_input_string (string, proc)
Calls the one-argument procedure @var{proc} with a newly
@end deffn
\fopen-input-string
+@c snarfed from strports.c:388
@deffn {Scheme Procedure} open-input-string str
@deffnx {C Function} scm_open_input_string (str)
Take a string and return an input port that delivers characters
@end deffn
\fopen-output-string
+@c snarfed from strports.c:402
@deffn {Scheme Procedure} open-output-string
@deffnx {C Function} scm_open_output_string ()
Return an output port that will accumulate characters for
@end deffn
\fget-output-string
+@c snarfed from strports.c:419
@deffn {Scheme Procedure} get-output-string port
@deffnx {C Function} scm_get_output_string (port)
Given an output port created by @code{open-output-string},
@end deffn
\feval-string
+@c snarfed from strports.c:488
@deffn {Scheme Procedure} eval-string string [module]
@deffnx {C Function} scm_eval_string_in_module (string, module)
Evaluate @var{string} as the text representation of a Scheme
@end deffn
\fmake-struct-layout
+@c snarfed from struct.c:55
@deffn {Scheme Procedure} make-struct-layout fields
@deffnx {C Function} scm_make_struct_layout (fields)
Return a new structure layout object.
@end deffn
\fstruct?
+@c snarfed from struct.c:222
@deffn {Scheme Procedure} struct? x
@deffnx {C Function} scm_struct_p (x)
Return @code{#t} iff @var{x} is a structure object, else
@end deffn
\fstruct-vtable?
+@c snarfed from struct.c:231
@deffn {Scheme Procedure} struct-vtable? x
@deffnx {C Function} scm_struct_vtable_p (x)
Return @code{#t} iff @var{x} is a vtable structure.
@end deffn
\fmake-struct
+@c snarfed from struct.c:417
@deffn {Scheme Procedure} make-struct vtable tail_array_size . init
@deffnx {C Function} scm_make_struct (vtable, tail_array_size, init)
Create a new structure.
@end deffn
\fmake-vtable-vtable
+@c snarfed from struct.c:501
@deffn {Scheme Procedure} make-vtable-vtable user_fields tail_array_size . init
@deffnx {C Function} scm_make_vtable_vtable (user_fields, tail_array_size, init)
Return a new, self-describing vtable structure.
@end deffn
\fstruct-ref
+@c snarfed from struct.c:541
@deffn {Scheme Procedure} struct-ref handle pos
@deffnx {Scheme Procedure} struct-set! struct n value
@deffnx {C Function} scm_struct_ref (handle, pos)
@end deffn
\fstruct-set!
+@c snarfed from struct.c:620
@deffn {Scheme Procedure} struct-set! handle pos val
@deffnx {C Function} scm_struct_set_x (handle, pos, val)
Set the slot of the structure @var{handle} with index @var{pos}
@end deffn
\fstruct-vtable
+@c snarfed from struct.c:691
@deffn {Scheme Procedure} struct-vtable handle
@deffnx {C Function} scm_struct_vtable (handle)
Return the vtable structure that describes the type of @var{struct}.
@end deffn
\fstruct-vtable-tag
+@c snarfed from struct.c:702
@deffn {Scheme Procedure} struct-vtable-tag handle
@deffnx {C Function} scm_struct_vtable_tag (handle)
Return the vtable tag of the structure @var{handle}.
@end deffn
\fstruct-vtable-name
+@c snarfed from struct.c:741
@deffn {Scheme Procedure} struct-vtable-name vtable
@deffnx {C Function} scm_struct_vtable_name (vtable)
Return the name of the vtable @var{vtable}.
@end deffn
\fset-struct-vtable-name!
+@c snarfed from struct.c:751
@deffn {Scheme Procedure} set-struct-vtable-name! vtable name
@deffnx {C Function} scm_set_struct_vtable_name_x (vtable, name)
Set the name of the vtable @var{vtable} to @var{name}.
@end deffn
\fsymbol?
+@c snarfed from symbols.c:156
@deffn {Scheme Procedure} symbol? obj
@deffnx {C Function} scm_symbol_p (obj)
Return @code{#t} if @var{obj} is a symbol, otherwise return
@end deffn
\fsymbol-interned?
+@c snarfed from symbols.c:166
@deffn {Scheme Procedure} symbol-interned? symbol
@deffnx {C Function} scm_symbol_interned_p (symbol)
Return @code{#t} if @var{symbol} is interned, otherwise return
@end deffn
\fmake-symbol
+@c snarfed from symbols.c:178
@deffn {Scheme Procedure} make-symbol name
@deffnx {C Function} scm_make_symbol (name)
Return a new uninterned symbol with the name @var{name}. The returned symbol is guaranteed to be unique and future calls to @code{string->symbol} will not return it.
@end deffn
\fsymbol->string
+@c snarfed from symbols.c:210
@deffn {Scheme Procedure} symbol->string s
@deffnx {C Function} scm_symbol_to_string (s)
Return the name of @var{symbol} as a string. If the symbol was
@end deffn
\fstring->symbol
+@c snarfed from symbols.c:240
@deffn {Scheme Procedure} string->symbol string
@deffnx {C Function} scm_string_to_symbol (string)
Return the symbol whose name is @var{string}. This procedure
@end deffn
\fgensym
+@c snarfed from symbols.c:256
@deffn {Scheme Procedure} gensym [prefix]
@deffnx {C Function} scm_gensym (prefix)
Create a new symbol with a name constructed from a prefix and
@end deffn
\fsymbol-hash
+@c snarfed from symbols.c:282
@deffn {Scheme Procedure} symbol-hash symbol
@deffnx {C Function} scm_symbol_hash (symbol)
Return a hash value for @var{symbol}.
@end deffn
\fsymbol-fref
+@c snarfed from symbols.c:292
@deffn {Scheme Procedure} symbol-fref s
@deffnx {C Function} scm_symbol_fref (s)
Return the contents of @var{symbol}'s @dfn{function slot}.
@end deffn
\fsymbol-pref
+@c snarfed from symbols.c:303
@deffn {Scheme Procedure} symbol-pref s
@deffnx {C Function} scm_symbol_pref (s)
Return the @dfn{property list} currently associated with @var{symbol}.
@end deffn
\fsymbol-fset!
+@c snarfed from symbols.c:314
@deffn {Scheme Procedure} symbol-fset! s val
@deffnx {C Function} scm_symbol_fset_x (s, val)
Change the binding of @var{symbol}'s function slot.
@end deffn
\fsymbol-pset!
+@c snarfed from symbols.c:326
@deffn {Scheme Procedure} symbol-pset! s val
@deffnx {C Function} scm_symbol_pset_x (s, val)
Change the binding of @var{symbol}'s property slot.
@end deffn
+\fcall-with-new-thread
+@c snarfed from threads.c:428
+@deffn {Scheme Procedure} call-with-new-thread thunk handler
+@deffnx {C Function} scm_call_with_new_thread (thunk, handler)
+Evaluate @code{(@var{thunk})} in a new thread, and new dynamic context, returning a new thread object representing the thread. If an error occurs during evaluation, call error-thunk, passing it an error code describing the condition. If this happens, the error-thunk is called outside the scope of the new root -- it is called in the same dynamic context in which with-new-thread was evaluated, but not in the callers thread. All the evaluation rules for dynamic roots apply to threads.
+@end deffn
+
+\fyield
+@c snarfed from threads.c:443
+@deffn {Scheme Procedure} yield
+@deffnx {C Function} scm_yield ()
+Move the calling thread to the end of the scheduling queue.
+@end deffn
+
+\fjoin-thread
+@c snarfed from threads.c:453
+@deffn {Scheme Procedure} join-thread thread
+@deffnx {C Function} scm_join_thread (thread)
+Suspend execution of the calling thread until the target @var{thread} terminates, unless the target @var{thread} has already terminated.
+@end deffn
+
+\fmake-fair-mutex
+@c snarfed from threads.c:508
+@deffn {Scheme Procedure} make-fair-mutex
+@deffnx {C Function} scm_make_fair_mutex ()
+Create a new fair mutex object.
+@end deffn
+
+\fmake-fair-condition-variable
+@c snarfed from threads.c:628
+@deffn {Scheme Procedure} make-fair-condition-variable
+@deffnx {C Function} scm_make_fair_condition_variable ()
+Make a new fair condition variable.
+@end deffn
+
+\fmake-mutex
+@c snarfed from threads.c:691
+@deffn {Scheme Procedure} make-mutex
+@deffnx {C Function} scm_make_mutex ()
+Create a new mutex object.
+@end deffn
+
+\flock-mutex
+@c snarfed from threads.c:707
+@deffn {Scheme Procedure} lock-mutex mx
+@deffnx {C Function} scm_lock_mutex (mx)
+Lock @var{mutex}. If the mutex is already locked, the calling thread blocks until the mutex becomes available. The function returns when the calling thread owns the lock on @var{mutex}. Locking a mutex that a thread already owns will succeed right away and will not block the thread. That is, Guile's mutexes are @emph{recursive}.
+@end deffn
+
+\ftry-mutex
+@c snarfed from threads.c:733
+@deffn {Scheme Procedure} try-mutex mx
+@deffnx {C Function} scm_try_mutex (mx)
+Try to lock @var{mutex}. If the mutex is already locked by someone else, return @code{#f}. Else lock the mutex and return @code{#t}.
+@end deffn
+
+\funlock-mutex
+@c snarfed from threads.c:768
+@deffn {Scheme Procedure} unlock-mutex mx
+@deffnx {C Function} scm_unlock_mutex (mx)
+Unlocks @var{mutex} if the calling thread owns the lock on @var{mutex}. Calling unlock-mutex on a mutex not owned by the current thread results in undefined behaviour. Once a mutex has been unlocked, one thread blocked on @var{mutex} is awakened and grabs the mutex lock. Every call to @code{lock-mutex} by this thread must be matched with a call to @code{unlock-mutex}. Only the last call to @code{unlock-mutex} will actually unlock the mutex.
+@end deffn
+
+\fmake-condition-variable
+@c snarfed from threads.c:808
+@deffn {Scheme Procedure} make-condition-variable
+@deffnx {C Function} scm_make_condition_variable ()
+Make a new condition variable.
+@end deffn
+
+\fwait-condition-variable
+@c snarfed from threads.c:827
+@deffn {Scheme Procedure} wait-condition-variable cv mx [t]
+@deffnx {C Function} scm_timed_wait_condition_variable (cv, mx, t)
+Wait until @var{cond-var} has been signalled. While waiting, @var{mutex} is atomically unlocked (as with @code{unlock-mutex}) and is locked again when this function returns. When @var{time} is given, it specifies a point in time where the waiting should be aborted. It can be either a integer as returned by @code{current-time} or a pair as returned by @code{gettimeofday}. When the waiting is aborted the mutex is locked and @code{#f} is returned. When the condition variable is in fact signalled, the mutex is also locked and @code{#t} is returned.
+@end deffn
+
+\fsignal-condition-variable
+@c snarfed from threads.c:884
+@deffn {Scheme Procedure} signal-condition-variable cv
+@deffnx {C Function} scm_signal_condition_variable (cv)
+Wake up one thread that is waiting for @var{cv}
+@end deffn
+
+\fbroadcast-condition-variable
+@c snarfed from threads.c:901
+@deffn {Scheme Procedure} broadcast-condition-variable cv
+@deffnx {C Function} scm_broadcast_condition_variable (cv)
+Wake up all threads that are waiting for @var{cv}.
+@end deffn
+
+\fcurrent-thread
+@c snarfed from threads.c:1103
+@deffn {Scheme Procedure} current-thread
+@deffnx {C Function} scm_current_thread ()
+Return the thread that called this function.
+@end deffn
+
+\fall-threads
+@c snarfed from threads.c:1112
+@deffn {Scheme Procedure} all-threads
+@deffnx {C Function} scm_all_threads ()
+Return a list of all threads.
+@end deffn
+
+\fthread-exited?
+@c snarfed from threads.c:1127
+@deffn {Scheme Procedure} thread-exited? thread
+@deffnx {C Function} scm_thread_exited_p (thread)
+Return @code{#t} iff @var{thread} has exited.
+
+@end deffn
+
\fcatch
+@c snarfed from throw.c:500
@deffn {Scheme Procedure} catch key thunk handler
@deffnx {C Function} scm_catch (key, thunk, handler)
Invoke @var{thunk} in the dynamic context of @var{handler} for
@end deffn
\flazy-catch
+@c snarfed from throw.c:528
@deffn {Scheme Procedure} lazy-catch key thunk handler
@deffnx {C Function} scm_lazy_catch (key, thunk, handler)
This behaves exactly like @code{catch}, except that it does
@end deffn
\fthrow
+@c snarfed from throw.c:561
@deffn {Scheme Procedure} throw key . args
@deffnx {C Function} scm_throw (key, args)
Invoke the catch form matching @var{key}, passing @var{args} to the
@end deffn
\fvalues
+@c snarfed from values.c:53
@deffn {Scheme Procedure} values . args
@deffnx {C Function} scm_values (args)
Delivers all of its arguments to its continuation. Except for
@end deffn
\fmake-variable
+@c snarfed from variable.c:52
@deffn {Scheme Procedure} make-variable init
@deffnx {C Function} scm_make_variable (init)
Return a variable initialized to value @var{init}.
@end deffn
\fmake-undefined-variable
+@c snarfed from variable.c:62
@deffn {Scheme Procedure} make-undefined-variable
@deffnx {C Function} scm_make_undefined_variable ()
Return a variable that is initially unbound.
@end deffn
\fvariable?
+@c snarfed from variable.c:73
@deffn {Scheme Procedure} variable? obj
@deffnx {C Function} scm_variable_p (obj)
Return @code{#t} iff @var{obj} is a variable object, else
@end deffn
\fvariable-ref
+@c snarfed from variable.c:85
@deffn {Scheme Procedure} variable-ref var
@deffnx {C Function} scm_variable_ref (var)
Dereference @var{var} and return its value.
@end deffn
\fvariable-set!
+@c snarfed from variable.c:101
@deffn {Scheme Procedure} variable-set! var val
@deffnx {C Function} scm_variable_set_x (var, val)
Set the value of the variable @var{var} to @var{val}.
@end deffn
\fvariable-bound?
+@c snarfed from variable.c:113
@deffn {Scheme Procedure} variable-bound? var
@deffnx {C Function} scm_variable_bound_p (var)
Return @code{#t} iff @var{var} is bound to a value.
@end deffn
\fvector?
+@c snarfed from vectors.c:35
@deffn {Scheme Procedure} vector? obj
@deffnx {C Function} scm_vector_p (obj)
Return @code{#t} if @var{obj} is a vector, otherwise return
@end deffn
\flist->vector
+@c snarfed from vectors.c:52
@deffn {Scheme Procedure} list->vector
implemented by the C function "scm_vector"
@end deffn
\fvector
+@c snarfed from vectors.c:69
@deffn {Scheme Procedure} vector . l
@deffnx {Scheme Procedure} list->vector l
@deffnx {C Function} scm_vector (l)
@end deffn
\fmake-vector
+@c snarfed from vectors.c:163
@deffn {Scheme Procedure} make-vector k [fill]
@deffnx {C Function} scm_make_vector (k, fill)
Return a newly allocated vector of @var{k} elements. If a
@end deffn
\fvector->list
+@c snarfed from vectors.c:211
@deffn {Scheme Procedure} vector->list v
@deffnx {C Function} scm_vector_to_list (v)
Return a newly allocated list composed of the elements of @var{v}.
@end deffn
\fvector-fill!
+@c snarfed from vectors.c:228
@deffn {Scheme Procedure} vector-fill! v fill
@deffnx {C Function} scm_vector_fill_x (v, fill)
Store @var{fill} in every position of @var{vector}. The value
@end deffn
\fvector-move-left!
+@c snarfed from vectors.c:260
@deffn {Scheme Procedure} vector-move-left! vec1 start1 end1 vec2 start2
@deffnx {C Function} scm_vector_move_left_x (vec1, start1, end1, vec2, start2)
Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
@end deffn
\fvector-move-right!
+@c snarfed from vectors.c:290
@deffn {Scheme Procedure} vector-move-right! vec1 start1 end1 vec2 start2
@deffnx {C Function} scm_vector_move_right_x (vec1, start1, end1, vec2, start2)
Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
@end deffn
\fmajor-version
+@c snarfed from version.c:35
@deffn {Scheme Procedure} major-version
@deffnx {C Function} scm_major_version ()
Return a string containing Guile's major version number.
@end deffn
\fminor-version
+@c snarfed from version.c:48
@deffn {Scheme Procedure} minor-version
@deffnx {C Function} scm_minor_version ()
Return a string containing Guile's minor version number.
@end deffn
\fmicro-version
+@c snarfed from version.c:61
@deffn {Scheme Procedure} micro-version
@deffnx {C Function} scm_micro_version ()
Return a string containing Guile's micro version number.
@end deffn
\fversion
+@c snarfed from version.c:83
@deffn {Scheme Procedure} version
@deffnx {Scheme Procedure} major-version
@deffnx {Scheme Procedure} minor-version
@end lisp
@end deffn
+\feffective-version
+@c snarfed from version.c:113
+@deffn {Scheme Procedure} effective-version
+@deffnx {C Function} scm_effective_version ()
+Return a string describing Guile's effective version number.
+@lisp
+(version) @result{} "1.6.0"
+(effective-version) @result{} "1.6"
+(major-version) @result{} "1"
+(minor-version) @result{} "6"
+(micro-version) @result{} "0"
+@end lisp
+@end deffn
+
\fmake-soft-port
+@c snarfed from vports.c:183
@deffn {Scheme Procedure} make-soft-port pv modes
@deffnx {C Function} scm_make_soft_port (pv, modes)
Return a port capable of receiving or delivering characters as
@end deffn
\fmake-weak-vector
+@c snarfed from weaks.c:117
@deffn {Scheme Procedure} make-weak-vector size [fill]
@deffnx {C Function} scm_make_weak_vector (size, fill)
Return a weak vector with @var{size} elements. If the optional
@end deffn
\flist->weak-vector
+@c snarfed from weaks.c:125
@deffn {Scheme Procedure} list->weak-vector
implemented by the C function "scm_weak_vector"
@end deffn
\fweak-vector
+@c snarfed from weaks.c:133
@deffn {Scheme Procedure} weak-vector . l
@deffnx {Scheme Procedure} list->weak-vector l
@deffnx {C Function} scm_weak_vector (l)
@end deffn
\fweak-vector?
+@c snarfed from weaks.c:164
@deffn {Scheme Procedure} weak-vector? obj
@deffnx {C Function} scm_weak_vector_p (obj)
Return @code{#t} if @var{obj} is a weak vector. Note that all
weak hashes are also weak vectors.
@end deffn
-\fmake-weak-key-hash-table
-@deffn {Scheme Procedure} make-weak-key-hash-table size
-@deffnx {Scheme Procedure} make-weak-value-hash-table size
-@deffnx {Scheme Procedure} make-doubly-weak-hash-table size
-@deffnx {C Function} scm_make_weak_key_hash_table (size)
+\fmake-weak-key-alist-vector
+@c snarfed from weaks.c:182
+@deffn {Scheme Procedure} make-weak-key-alist-vector [size]
+@deffnx {Scheme Procedure} make-weak-value-alist-vector size
+@deffnx {Scheme Procedure} make-doubly-weak-alist-vector size
+@deffnx {C Function} scm_make_weak_key_alist_vector (size)
Return a weak hash table with @var{size} buckets. As with any
hash table, choosing a good size for the table requires some
caution.
would modify regular hash tables. (@pxref{Hash Tables})
@end deffn
-\fmake-weak-value-hash-table
-@deffn {Scheme Procedure} make-weak-value-hash-table size
-@deffnx {C Function} scm_make_weak_value_hash_table (size)
+\fmake-weak-value-alist-vector
+@c snarfed from weaks.c:194
+@deffn {Scheme Procedure} make-weak-value-alist-vector [size]
+@deffnx {C Function} scm_make_weak_value_alist_vector (size)
Return a hash table with weak values with @var{size} buckets.
(@pxref{Hash Tables})
@end deffn
-\fmake-doubly-weak-hash-table
-@deffn {Scheme Procedure} make-doubly-weak-hash-table size
-@deffnx {C Function} scm_make_doubly_weak_hash_table (size)
+\fmake-doubly-weak-alist-vector
+@c snarfed from weaks.c:206
+@deffn {Scheme Procedure} make-doubly-weak-alist-vector size
+@deffnx {C Function} scm_make_doubly_weak_alist_vector (size)
Return a hash table with weak keys and values with @var{size}
buckets. (@pxref{Hash Tables})
@end deffn
-\fweak-key-hash-table?
-@deffn {Scheme Procedure} weak-key-hash-table? obj
-@deffnx {Scheme Procedure} weak-value-hash-table? obj
-@deffnx {Scheme Procedure} doubly-weak-hash-table? obj
-@deffnx {C Function} scm_weak_key_hash_table_p (obj)
+\fweak-key-alist-vector?
+@c snarfed from weaks.c:221
+@deffn {Scheme Procedure} weak-key-alist-vector? obj
+@deffnx {Scheme Procedure} weak-value-alist-vector? obj
+@deffnx {Scheme Procedure} doubly-weak-alist-vector? obj
+@deffnx {C Function} scm_weak_key_alist_vector_p (obj)
Return @code{#t} if @var{obj} is the specified weak hash
table. Note that a doubly weak hash table is neither a weak key
nor a weak value hash table.
@end deffn
-\fweak-value-hash-table?
-@deffn {Scheme Procedure} weak-value-hash-table? obj
-@deffnx {C Function} scm_weak_value_hash_table_p (obj)
+\fweak-value-alist-vector?
+@c snarfed from weaks.c:231
+@deffn {Scheme Procedure} weak-value-alist-vector? obj
+@deffnx {C Function} scm_weak_value_alist_vector_p (obj)
Return @code{#t} if @var{obj} is a weak value hash table.
@end deffn
-\fdoubly-weak-hash-table?
-@deffn {Scheme Procedure} doubly-weak-hash-table? obj
-@deffnx {C Function} scm_doubly_weak_hash_table_p (obj)
+\fdoubly-weak-alist-vector?
+@c snarfed from weaks.c:241
+@deffn {Scheme Procedure} doubly-weak-alist-vector? obj
+@deffnx {C Function} scm_doubly_weak_alist_vector_p (obj)
Return @code{#t} if @var{obj} is a doubly weak hash table.
@end deffn
\fdynamic-link
+@c snarfed from dynl.c:149
@deffn {Scheme Procedure} dynamic-link filename
@deffnx {C Function} scm_dynamic_link (filename)
Find the shared object (shared library) denoted by
@end deffn
\fdynamic-object?
+@c snarfed from dynl.c:168
@deffn {Scheme Procedure} dynamic-object? obj
@deffnx {C Function} scm_dynamic_object_p (obj)
Return @code{#t} if @var{obj} is a dynamic object handle,
@end deffn
\fdynamic-unlink
+@c snarfed from dynl.c:182
@deffn {Scheme Procedure} dynamic-unlink dobj
@deffnx {C Function} scm_dynamic_unlink (dobj)
Unlink a dynamic object from the application, if possible. The
@end deffn
\fdynamic-func
+@c snarfed from dynl.c:207
@deffn {Scheme Procedure} dynamic-func name dobj
@deffnx {C Function} scm_dynamic_func (name, dobj)
Return a ``handle'' for the function @var{name} in the
@end deffn
\fdynamic-call
+@c snarfed from dynl.c:253
@deffn {Scheme Procedure} dynamic-call func dobj
@deffnx {C Function} scm_dynamic_call (func, dobj)
Call a C function in a dynamic object. Two styles of
@end deffn
\fdynamic-args-call
+@c snarfed from dynl.c:285
@deffn {Scheme Procedure} dynamic-args-call func dobj args
@deffnx {C Function} scm_dynamic_args_call (func, dobj, args)
Call the C function indicated by @var{func} and @var{dobj},
@end deffn
\farray-fill!
+@c snarfed from ramap.c:438
@deffn {Scheme Procedure} array-fill! ra fill
@deffnx {C Function} scm_array_fill_x (ra, fill)
Store @var{fill} in every element of @var{array}. The value returned
@end deffn
\farray-copy-in-order!
+@c snarfed from ramap.c:810
@deffn {Scheme Procedure} array-copy-in-order!
implemented by the C function "scm_array_copy_x"
@end deffn
\farray-copy!
+@c snarfed from ramap.c:819
@deffn {Scheme Procedure} array-copy! src dst
@deffnx {Scheme Procedure} array-copy-in-order! src dst
@deffnx {C Function} scm_array_copy_x (src, dst)
@end deffn
\farray-map-in-order!
+@c snarfed from ramap.c:1494
@deffn {Scheme Procedure} array-map-in-order!
implemented by the C function "scm_array_map_x"
@end deffn
\farray-map!
+@c snarfed from ramap.c:1505
@deffn {Scheme Procedure} array-map! ra0 proc . lra
@deffnx {Scheme Procedure} array-map-in-order! ra0 proc . lra
@deffnx {C Function} scm_array_map_x (ra0, proc, lra)
@end deffn
\farray-for-each
+@c snarfed from ramap.c:1651
@deffn {Scheme Procedure} array-for-each proc ra0 . lra
@deffnx {C Function} scm_array_for_each (proc, ra0, lra)
Apply @var{proc} to each tuple of elements of @var{array0} @dots{}
@end deffn
\farray-index-map!
+@c snarfed from ramap.c:1679
@deffn {Scheme Procedure} array-index-map! ra proc
@deffnx {C Function} scm_array_index_map_x (ra, proc)
Apply @var{proc} to the indices of each element of @var{array} in
@end deffn
\funiform-vector-length
+@c snarfed from unif.c:211
@deffn {Scheme Procedure} uniform-vector-length v
@deffnx {C Function} scm_uniform_vector_length (v)
Return the number of elements in @var{uve}.
@end deffn
\farray?
+@c snarfed from unif.c:245
@deffn {Scheme Procedure} array? v [prot]
@deffnx {C Function} scm_array_p (v, prot)
Return @code{#t} if the @var{obj} is an array, and @code{#f} if
@end deffn
\farray-rank
+@c snarfed from unif.c:328
@deffn {Scheme Procedure} array-rank ra
@deffnx {C Function} scm_array_rank (ra)
Return the number of dimensions of @var{obj}. If @var{obj} is
@end deffn
\farray-dimensions
+@c snarfed from unif.c:366
@deffn {Scheme Procedure} array-dimensions ra
@deffnx {C Function} scm_array_dimensions (ra)
@code{Array-dimensions} is similar to @code{array-shape} but replaces
@end deffn
\fshared-array-root
+@c snarfed from unif.c:413
@deffn {Scheme Procedure} shared-array-root ra
@deffnx {C Function} scm_shared_array_root (ra)
Return the root vector of a shared array.
@end deffn
\fshared-array-offset
+@c snarfed from unif.c:424
@deffn {Scheme Procedure} shared-array-offset ra
@deffnx {C Function} scm_shared_array_offset (ra)
Return the root vector index of the first element in the array.
@end deffn
\fshared-array-increments
+@c snarfed from unif.c:435
@deffn {Scheme Procedure} shared-array-increments ra
@deffnx {C Function} scm_shared_array_increments (ra)
For each dimension, return the distance between elements in the root vector.
@end deffn
\fdimensions->uniform-array
+@c snarfed from unif.c:554
@deffn {Scheme Procedure} dimensions->uniform-array dims prot [fill]
@deffnx {Scheme Procedure} make-uniform-vector length prototype [fill]
@deffnx {C Function} scm_dimensions_to_uniform_array (dims, prot, fill)
@end deffn
\fmake-shared-array
+@c snarfed from unif.c:643
@deffn {Scheme Procedure} make-shared-array oldra mapfunc . dims
@deffnx {C Function} scm_make_shared_array (oldra, mapfunc, dims)
@code{make-shared-array} can be used to create shared subarrays of other
@end deffn
\ftranspose-array
+@c snarfed from unif.c:774
@deffn {Scheme Procedure} transpose-array ra . args
@deffnx {C Function} scm_transpose_array (ra, args)
Return an array sharing contents with @var{array}, but with
@end deffn
\fenclose-array
+@c snarfed from unif.c:879
@deffn {Scheme Procedure} enclose-array ra . axes
@deffnx {C Function} scm_enclose_array (ra, axes)
@var{dim0}, @var{dim1} @dots{} should be nonnegative integers less than
@end deffn
\farray-in-bounds?
+@c snarfed from unif.c:966
@deffn {Scheme Procedure} array-in-bounds? v . args
@deffnx {C Function} scm_array_in_bounds_p (v, args)
Return @code{#t} if its arguments would be acceptable to
@end deffn
\farray-ref
+@c snarfed from unif.c:1044
@deffn {Scheme Procedure} array-ref
implemented by the C function "scm_uniform_vector_ref"
@end deffn
\funiform-vector-ref
+@c snarfed from unif.c:1051
@deffn {Scheme Procedure} uniform-vector-ref v args
@deffnx {Scheme Procedure} array-ref v . args
@deffnx {C Function} scm_uniform_vector_ref (v, args)
@end deffn
\funiform-array-set1!
+@c snarfed from unif.c:1219
@deffn {Scheme Procedure} uniform-array-set1!
implemented by the C function "scm_array_set_x"
@end deffn
\farray-set!
+@c snarfed from unif.c:1228
@deffn {Scheme Procedure} array-set! v obj . args
@deffnx {Scheme Procedure} uniform-array-set1! v obj args
@deffnx {C Function} scm_array_set_x (v, obj, args)
@end deffn
\farray-contents
+@c snarfed from unif.c:1335
@deffn {Scheme Procedure} array-contents ra [strict]
@deffnx {C Function} scm_array_contents (ra, strict)
If @var{array} may be @dfn{unrolled} into a one dimensional shared array
@end deffn
\funiform-array-read!
+@c snarfed from unif.c:1449
@deffn {Scheme Procedure} uniform-array-read! ra [port_or_fd [start [end]]]
@deffnx {Scheme Procedure} uniform-vector-read! uve [port-or-fdes] [start] [end]
@deffnx {C Function} scm_uniform_array_read_x (ra, port_or_fd, start, end)
@end deffn
\funiform-array-write
+@c snarfed from unif.c:1632
@deffn {Scheme Procedure} uniform-array-write v [port_or_fd [start [end]]]
@deffnx {Scheme Procedure} uniform-vector-write uve [port-or-fdes] [start] [end]
@deffnx {C Function} scm_uniform_array_write (v, port_or_fd, start, end)
@end deffn
\fbit-count
+@c snarfed from unif.c:1759
@deffn {Scheme Procedure} bit-count b bitvector
@deffnx {C Function} scm_bit_count (b, bitvector)
Return the number of occurrences of the boolean @var{b} in
@end deffn
\fbit-position
+@c snarfed from unif.c:1804
@deffn {Scheme Procedure} bit-position item v k
@deffnx {C Function} scm_bit_position (item, v, k)
-Return the minimum index of an occurrence of @var{bool} in
-@var{bv} which is at least @var{k}. If no @var{bool} occurs
-within the specified range @code{#f} is returned.
+Return the index of the first occurrance of @var{item} in bit
+vector @var{v}, starting from @var{k}. If there is no
+@var{item} entry between @var{k} and the end of
+@var{bitvector}, then return @code{#f}. For example,
+
+@example
+(bit-position #t #*000101 0) @result{} 3
+(bit-position #f #*0001111 3) @result{} #f
+@end example
@end deffn
\fbit-set*!
+@c snarfed from unif.c:1890
@deffn {Scheme Procedure} bit-set*! v kv obj
@deffnx {C Function} scm_bit_set_star_x (v, kv, obj)
-If uve is a bit-vector @var{bv} and uve must be of the same
-length. If @var{bool} is @code{#t}, uve is OR'ed into
-@var{bv}; If @var{bool} is @code{#f}, the inversion of uve is
-AND'ed into @var{bv}.
+Set entries of bit vector @var{v} to @var{obj}, with @var{kv}
+selecting the entries to change. The return value is
+unspecified.
+
+If @var{kv} is a bit vector, then those entries where it has
+@code{#t} are the ones in @var{v} which are set to @var{obj}.
+@var{kv} and @var{v} must be the same length. When @var{obj}
+is @code{#t} it's like @var{kv} is OR'ed into @var{v}. Or when
+@var{obj} is @code{#f} it can be seen as an ANDNOT.
+
+@example
+(define bv #*01000010)
+(bit-set*! bv #*10010001 #t)
+bv
+@result{} #*11010011
+@end example
-If uve is a unsigned long integer vector all the elements of uve
-must be between 0 and the @code{length} of @var{bv}. The bits
-of @var{bv} corresponding to the indexes in uve are set to
-@var{bool}. The return value is unspecified.
+If @var{kv} is a uniform vector of unsigned long integers, then
+they're indexes into @var{v} which are set to @var{obj}.
+
+@example
+(define bv #*01000010)
+(bit-set*! bv #u(5 2 7) #t)
+bv
+@result{} #*01100111
+@end example
@end deffn
\fbit-count*
+@c snarfed from unif.c:1956
@deffn {Scheme Procedure} bit-count* v kv obj
@deffnx {C Function} scm_bit_count_star (v, kv, obj)
-Return
-@lisp
-(bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t).
-@end lisp
-@var{bv} is not modified.
+Return a count of how many entries in bit vector @var{v} are
+equal to @var{obj}, with @var{kv} selecting the entries to
+consider.
+
+If @var{kv} is a bit vector, then those entries where it has
+@code{#t} are the ones in @var{v} which are considered.
+@var{kv} and @var{v} must be the same length.
+
+If @var{kv} is a uniform vector of unsigned long integers, then
+it's the indexes in @var{v} to consider.
+
+For example,
+
+@example
+(bit-count* #*01110111 #*11001101 #t) @result{} 3
+(bit-count* #*01110111 #u(7 0 4) #f) @result{} 2
+@end example
@end deffn
\fbit-invert!
+@c snarfed from unif.c:2021
@deffn {Scheme Procedure} bit-invert! v
@deffnx {C Function} scm_bit_invert_x (v)
-Modify @var{bv} by replacing each element with its negation.
+Modify the bit vector @var{v} by replacing each element with
+its negation.
@end deffn
\farray->list
+@c snarfed from unif.c:2103
@deffn {Scheme Procedure} array->list v
@deffnx {C Function} scm_array_to_list (v)
Return a list consisting of all the elements, in order, of
@end deffn
\flist->uniform-array
+@c snarfed from unif.c:2205
@deffn {Scheme Procedure} list->uniform-array ndim prot lst
@deffnx {Scheme Procedure} list->uniform-vector prot lst
@deffnx {C Function} scm_list_to_uniform_array (ndim, prot, lst)
@end deffn
\farray-prototype
+@c snarfed from unif.c:2562
@deffn {Scheme Procedure} array-prototype ra
@deffnx {C Function} scm_array_prototype (ra)
Return an object that would produce an array of the same type
@end deffn
\fchown
+@c snarfed from filesys.c:220
@deffn {Scheme Procedure} chown object owner group
@deffnx {C Function} scm_chown (object, owner, group)
Change the ownership and group of the file referred to by @var{object} to
@end deffn
\fchmod
+@c snarfed from filesys.c:258
@deffn {Scheme Procedure} chmod object mode
@deffnx {C Function} scm_chmod (object, mode)
Changes the permissions of the file referred to by @var{obj}.
@end deffn
\fumask
+@c snarfed from filesys.c:290
@deffn {Scheme Procedure} umask [mode]
@deffnx {C Function} scm_umask (mode)
If @var{mode} is omitted, returns a decimal number representing the current
@end deffn
\fopen-fdes
+@c snarfed from filesys.c:312
@deffn {Scheme Procedure} open-fdes path flags [mode]
@deffnx {C Function} scm_open_fdes (path, flags, mode)
Similar to @code{open} but return a file descriptor instead of
@end deffn
\fopen
+@c snarfed from filesys.c:353
@deffn {Scheme Procedure} open path flags [mode]
@deffnx {C Function} scm_open (path, flags, mode)
Open the file named by @var{path} for reading and/or writing.
@end deffn
\fclose
+@c snarfed from filesys.c:391
@deffn {Scheme Procedure} close fd_or_port
@deffnx {C Function} scm_close (fd_or_port)
Similar to close-port (@pxref{Closing, close-port}),
@end deffn
\fclose-fdes
+@c snarfed from filesys.c:418
@deffn {Scheme Procedure} close-fdes fd
@deffnx {C Function} scm_close_fdes (fd)
A simple wrapper for the @code{close} system call.
@end deffn
\fstat
+@c snarfed from filesys.c:620
@deffn {Scheme Procedure} stat object
@deffnx {C Function} scm_stat (object)
Return an object containing various information about the file
@end deffn
\flink
+@c snarfed from filesys.c:682
@deffn {Scheme Procedure} link oldpath newpath
@deffnx {C Function} scm_link (oldpath, newpath)
Creates a new name @var{newpath} in the file system for the
@end deffn
\frename-file
+@c snarfed from filesys.c:720
@deffn {Scheme Procedure} rename-file oldname newname
@deffnx {C Function} scm_rename (oldname, newname)
Renames the file specified by @var{oldname} to @var{newname}.
@end deffn
\fdelete-file
+@c snarfed from filesys.c:737
@deffn {Scheme Procedure} delete-file str
@deffnx {C Function} scm_delete_file (str)
Deletes (or "unlinks") the file specified by @var{path}.
@end deffn
\fmkdir
+@c snarfed from filesys.c:754
@deffn {Scheme Procedure} mkdir path [mode]
@deffnx {C Function} scm_mkdir (path, mode)
Create a new directory named by @var{path}. If @var{mode} is omitted
@end deffn
\frmdir
+@c snarfed from filesys.c:781
@deffn {Scheme Procedure} rmdir path
@deffnx {C Function} scm_rmdir (path)
Remove the existing directory named by @var{path}. The directory must
@end deffn
\fdirectory-stream?
+@c snarfed from filesys.c:805
@deffn {Scheme Procedure} directory-stream? obj
@deffnx {C Function} scm_directory_stream_p (obj)
Return a boolean indicating whether @var{object} is a directory
@end deffn
\fopendir
+@c snarfed from filesys.c:816
@deffn {Scheme Procedure} opendir dirname
@deffnx {C Function} scm_opendir (dirname)
Open the directory specified by @var{path} and return a directory
@end deffn
\freaddir
+@c snarfed from filesys.c:837
@deffn {Scheme Procedure} readdir port
@deffnx {C Function} scm_readdir (port)
Return (as a string) the next directory entry from the directory stream
@end deffn
\frewinddir
+@c snarfed from filesys.c:876
@deffn {Scheme Procedure} rewinddir port
@deffnx {C Function} scm_rewinddir (port)
Reset the directory port @var{stream} so that the next call to
@end deffn
\fclosedir
+@c snarfed from filesys.c:893
@deffn {Scheme Procedure} closedir port
@deffnx {C Function} scm_closedir (port)
Close the directory stream @var{stream}.
@end deffn
\fchdir
+@c snarfed from filesys.c:943
@deffn {Scheme Procedure} chdir str
@deffnx {C Function} scm_chdir (str)
Change the current working directory to @var{path}.
@end deffn
\fgetcwd
+@c snarfed from filesys.c:958
@deffn {Scheme Procedure} getcwd
@deffnx {C Function} scm_getcwd ()
Return the name of the current working directory.
@end deffn
\fselect
+@c snarfed from filesys.c:1159
@deffn {Scheme Procedure} select reads writes excepts [secs [usecs]]
@deffnx {C Function} scm_select (reads, writes, excepts, secs, usecs)
This procedure has a variety of uses: waiting for the ability
@end deffn
\ffcntl
+@c snarfed from filesys.c:1297
@deffn {Scheme Procedure} fcntl object cmd [value]
@deffnx {C Function} scm_fcntl (object, cmd, value)
Apply @var{command} to the specified file descriptor or the underlying
@end deffn
\ffsync
+@c snarfed from filesys.c:1329
@deffn {Scheme Procedure} fsync object
@deffnx {C Function} scm_fsync (object)
Copies any unwritten data for the specified output file descriptor to disk.
@end deffn
\fsymlink
+@c snarfed from filesys.c:1354
@deffn {Scheme Procedure} symlink oldpath newpath
@deffnx {C Function} scm_symlink (oldpath, newpath)
Create a symbolic link named @var{path-to} with the value (i.e., pointing to)
@end deffn
\freadlink
+@c snarfed from filesys.c:1373
@deffn {Scheme Procedure} readlink path
@deffnx {C Function} scm_readlink (path)
Return the value of the symbolic link named by @var{path} (a
@end deffn
\flstat
+@c snarfed from filesys.c:1415
@deffn {Scheme Procedure} lstat str
@deffnx {C Function} scm_lstat (str)
Similar to @code{stat}, but does not follow symbolic links, i.e.,
@end deffn
\fcopy-file
+@c snarfed from filesys.c:1438
@deffn {Scheme Procedure} copy-file oldfile newfile
@deffnx {C Function} scm_copy_file (oldfile, newfile)
Copy the file specified by @var{path-from} to @var{path-to}.
@end deffn
\fdirname
+@c snarfed from filesys.c:1501
@deffn {Scheme Procedure} dirname filename
@deffnx {C Function} scm_dirname (filename)
Return the directory name component of the file name
@end deffn
\fbasename
+@c snarfed from filesys.c:1544
@deffn {Scheme Procedure} basename filename [suffix]
@deffnx {C Function} scm_basename (filename, suffix)
Return the base name of the file name @var{filename}. The
@end deffn
\fpipe
+@c snarfed from posix.c:231
@deffn {Scheme Procedure} pipe
@deffnx {C Function} scm_pipe ()
Return a newly created pipe: a pair of ports which are linked
@end deffn
\fgetgroups
+@c snarfed from posix.c:252
@deffn {Scheme Procedure} getgroups
@deffnx {C Function} scm_getgroups ()
Return a vector of integers representing the current
supplementary group IDs.
@end deffn
+\fsetgroups
+@c snarfed from posix.c:285
+@deffn {Scheme Procedure} setgroups group_vec
+@deffnx {C Function} scm_setgroups (group_vec)
+Set the current set of supplementary group IDs to the integers
+in the given vector @var{vec}. The return value is
+unspecified.
+
+Generally only the superuser can set the process group IDs.
+@end deffn
+
\fgetpw
+@c snarfed from posix.c:333
@deffn {Scheme Procedure} getpw [user]
@deffnx {C Function} scm_getpwuid (user)
Look up an entry in the user database. @var{obj} can be an integer,
@end deffn
\fsetpw
+@c snarfed from posix.c:383
@deffn {Scheme Procedure} setpw [arg]
@deffnx {C Function} scm_setpwent (arg)
If called with a true argument, initialize or reset the password data
@end deffn
\fgetgr
+@c snarfed from posix.c:402
@deffn {Scheme Procedure} getgr [name]
@deffnx {C Function} scm_getgrgid (name)
Look up an entry in the group database. @var{obj} can be an integer,
@end deffn
\fsetgr
+@c snarfed from posix.c:438
@deffn {Scheme Procedure} setgr [arg]
@deffnx {C Function} scm_setgrent (arg)
If called with a true argument, initialize or reset the group data
@end deffn
\fkill
+@c snarfed from posix.c:474
@deffn {Scheme Procedure} kill pid sig
@deffnx {C Function} scm_kill (pid, sig)
Sends a signal to the specified process or group of processes.
@end deffn
\fwaitpid
+@c snarfed from posix.c:525
@deffn {Scheme Procedure} waitpid pid [options]
@deffnx {C Function} scm_waitpid (pid, options)
This procedure collects status information from a child process which
@end deffn
\fstatus:exit-val
+@c snarfed from posix.c:551
@deffn {Scheme Procedure} status:exit-val status
@deffnx {C Function} scm_status_exit_val (status)
Return the exit status value, as would be set if a process
@end deffn
\fstatus:term-sig
+@c snarfed from posix.c:569
@deffn {Scheme Procedure} status:term-sig status
@deffnx {C Function} scm_status_term_sig (status)
Return the signal number which terminated the process, if any,
@end deffn
\fstatus:stop-sig
+@c snarfed from posix.c:585
@deffn {Scheme Procedure} status:stop-sig status
@deffnx {C Function} scm_status_stop_sig (status)
Return the signal number which stopped the process, if any,
@end deffn
\fgetppid
+@c snarfed from posix.c:603
@deffn {Scheme Procedure} getppid
@deffnx {C Function} scm_getppid ()
Return an integer representing the process ID of the parent
@end deffn
\fgetuid
+@c snarfed from posix.c:615
@deffn {Scheme Procedure} getuid
@deffnx {C Function} scm_getuid ()
Return an integer representing the current real user ID.
@end deffn
\fgetgid
+@c snarfed from posix.c:626
@deffn {Scheme Procedure} getgid
@deffnx {C Function} scm_getgid ()
Return an integer representing the current real group ID.
@end deffn
\fgeteuid
+@c snarfed from posix.c:640
@deffn {Scheme Procedure} geteuid
@deffnx {C Function} scm_geteuid ()
Return an integer representing the current effective user ID.
@end deffn
\fgetegid
+@c snarfed from posix.c:657
@deffn {Scheme Procedure} getegid
@deffnx {C Function} scm_getegid ()
Return an integer representing the current effective group ID.
@end deffn
\fsetuid
+@c snarfed from posix.c:673
@deffn {Scheme Procedure} setuid id
@deffnx {C Function} scm_setuid (id)
Sets both the real and effective user IDs to the integer @var{id}, provided
@end deffn
\fsetgid
+@c snarfed from posix.c:686
@deffn {Scheme Procedure} setgid id
@deffnx {C Function} scm_setgid (id)
Sets both the real and effective group IDs to the integer @var{id}, provided
@end deffn
\fseteuid
+@c snarfed from posix.c:701
@deffn {Scheme Procedure} seteuid id
@deffnx {C Function} scm_seteuid (id)
Sets the effective user ID to the integer @var{id}, provided the process
@end deffn
\fsetegid
+@c snarfed from posix.c:726
@deffn {Scheme Procedure} setegid id
@deffnx {C Function} scm_setegid (id)
Sets the effective group ID to the integer @var{id}, provided the process
@end deffn
\fgetpgrp
+@c snarfed from posix.c:749
@deffn {Scheme Procedure} getpgrp
@deffnx {C Function} scm_getpgrp ()
Return an integer representing the current process group ID.
@end deffn
\fsetpgid
+@c snarfed from posix.c:767
@deffn {Scheme Procedure} setpgid pid pgid
@deffnx {C Function} scm_setpgid (pid, pgid)
Move the process @var{pid} into the process group @var{pgid}. @var{pid} or
@end deffn
\fsetsid
+@c snarfed from posix.c:784
@deffn {Scheme Procedure} setsid
@deffnx {C Function} scm_setsid ()
Creates a new session. The current process becomes the session leader
@end deffn
\fttyname
+@c snarfed from posix.c:808
@deffn {Scheme Procedure} ttyname port
@deffnx {C Function} scm_ttyname (port)
Return a string with the name of the serial terminal device
@end deffn
\fctermid
+@c snarfed from posix.c:847
@deffn {Scheme Procedure} ctermid
@deffnx {C Function} scm_ctermid ()
Return a string containing the file name of the controlling
@end deffn
\ftcgetpgrp
+@c snarfed from posix.c:871
@deffn {Scheme Procedure} tcgetpgrp port
@deffnx {C Function} scm_tcgetpgrp (port)
Return the process group ID of the foreground process group
@end deffn
\ftcsetpgrp
+@c snarfed from posix.c:895
@deffn {Scheme Procedure} tcsetpgrp port pgid
@deffnx {C Function} scm_tcsetpgrp (port, pgid)
Set the foreground process group ID for the terminal used by the file
@end deffn
\fexecl
+@c snarfed from posix.c:927
@deffn {Scheme Procedure} execl filename . args
@deffnx {C Function} scm_execl (filename, args)
Executes the file named by @var{path} as a new process image.
@end deffn
\fexeclp
+@c snarfed from posix.c:958
@deffn {Scheme Procedure} execlp filename . args
@deffnx {C Function} scm_execlp (filename, args)
Similar to @code{execl}, however if
@end deffn
\fexecle
+@c snarfed from posix.c:992
@deffn {Scheme Procedure} execle filename env . args
@deffnx {C Function} scm_execle (filename, env, args)
Similar to @code{execl}, but the environment of the new process is
@end deffn
\fprimitive-fork
+@c snarfed from posix.c:1028
@deffn {Scheme Procedure} primitive-fork
@deffnx {C Function} scm_fork ()
Creates a new "child" process by duplicating the current "parent" process.
@end deffn
\funame
+@c snarfed from posix.c:1048
@deffn {Scheme Procedure} uname
@deffnx {C Function} scm_uname ()
Return an object with some information about the computer
@end deffn
\fenviron
+@c snarfed from posix.c:1077
@deffn {Scheme Procedure} environ [env]
@deffnx {C Function} scm_environ (env)
If @var{env} is omitted, return the current environment (in the
@end deffn
\ftmpnam
+@c snarfed from posix.c:1110
@deffn {Scheme Procedure} tmpnam
@deffnx {C Function} scm_tmpnam ()
Return a name in the file system that does not match any
@end deffn
\fmkstemp!
+@c snarfed from posix.c:1136
@deffn {Scheme Procedure} mkstemp! tmpl
@deffnx {C Function} scm_mkstemp (tmpl)
Create a new unique file in the file system and returns a new
@end deffn
\futime
+@c snarfed from posix.c:1171
@deffn {Scheme Procedure} utime pathname [actime [modtime]]
@deffnx {C Function} scm_utime (pathname, actime, modtime)
@code{utime} sets the access and modification times for the
@end deffn
\faccess?
+@c snarfed from posix.c:1219
@deffn {Scheme Procedure} access? path how
@deffnx {C Function} scm_access (path, how)
Return @code{#t} if @var{path} corresponds to an existing file
@end deffn
\fgetpid
+@c snarfed from posix.c:1232
@deffn {Scheme Procedure} getpid
@deffnx {C Function} scm_getpid ()
Return an integer representing the current process ID.
@end deffn
\fputenv
+@c snarfed from posix.c:1249
@deffn {Scheme Procedure} putenv str
@deffnx {C Function} scm_putenv (str)
Modifies the environment of the current process, which is
@end deffn
\fsetlocale
+@c snarfed from posix.c:1333
@deffn {Scheme Procedure} setlocale category [locale]
@deffnx {C Function} scm_setlocale (category, locale)
If @var{locale} is omitted, return the current value of the
@end deffn
\fmknod
+@c snarfed from posix.c:1376
@deffn {Scheme Procedure} mknod path type perms dev
@deffnx {C Function} scm_mknod (path, type, perms, dev)
Creates a new special file, such as a file corresponding to a device.
@end deffn
\fnice
+@c snarfed from posix.c:1422
@deffn {Scheme Procedure} nice incr
@deffnx {C Function} scm_nice (incr)
Increment the priority of the current process by @var{incr}. A higher
@end deffn
\fsync
+@c snarfed from posix.c:1436
@deffn {Scheme Procedure} sync
@deffnx {C Function} scm_sync ()
Flush the operating system disk buffers.
@end deffn
\fcrypt
+@c snarfed from posix.c:1467
@deffn {Scheme Procedure} crypt key salt
@deffnx {C Function} scm_crypt (key, salt)
Encrypt @var{key} using @var{salt} as the salt value to the
@end deffn
\fchroot
+@c snarfed from posix.c:1499
@deffn {Scheme Procedure} chroot path
@deffnx {C Function} scm_chroot (path)
Change the root directory to that specified in @var{path}.
@end deffn
\fgetlogin
+@c snarfed from posix.c:1533
@deffn {Scheme Procedure} getlogin
@deffnx {C Function} scm_getlogin ()
Return a string containing the name of the user logged in on
@end deffn
\fcuserid
+@c snarfed from posix.c:1551
@deffn {Scheme Procedure} cuserid
@deffnx {C Function} scm_cuserid ()
Return a string containing a user name associated with the
@end deffn
\fgetpriority
+@c snarfed from posix.c:1577
@deffn {Scheme Procedure} getpriority which who
@deffnx {C Function} scm_getpriority (which, who)
Return the scheduling priority of the process, process group
@end deffn
\fsetpriority
+@c snarfed from posix.c:1611
@deffn {Scheme Procedure} setpriority which who prio
@deffnx {C Function} scm_setpriority (which, who, prio)
Set the scheduling priority of the process, process group
@end deffn
\fgetpass
+@c snarfed from posix.c:1636
@deffn {Scheme Procedure} getpass prompt
@deffnx {C Function} scm_getpass (prompt)
Display @var{prompt} to the standard error output and read
@end deffn
\fflock
+@c snarfed from posix.c:1741
@deffn {Scheme Procedure} flock file operation
@deffnx {C Function} scm_flock (file, operation)
Apply or remove an advisory lock on an open file.
@end deffn
\fsethostname
+@c snarfed from posix.c:1766
@deffn {Scheme Procedure} sethostname name
@deffnx {C Function} scm_sethostname (name)
Set the host name of the current processor to @var{name}. May
@end deffn
\fgethostname
+@c snarfed from posix.c:1784
@deffn {Scheme Procedure} gethostname
@deffnx {C Function} scm_gethostname ()
Return the host name of the current processor.
@end deffn
\fgethost
+@c snarfed from net_db.c:134
@deffn {Scheme Procedure} gethost [host]
@deffnx {Scheme Procedure} gethostbyname hostname
@deffnx {Scheme Procedure} gethostbyaddr address
@end deffn
\fgetnet
+@c snarfed from net_db.c:216
@deffn {Scheme Procedure} getnet [net]
@deffnx {Scheme Procedure} getnetbyname net-name
@deffnx {Scheme Procedure} getnetbyaddr net-number
@end deffn
\fgetproto
+@c snarfed from net_db.c:268
@deffn {Scheme Procedure} getproto [protocol]
@deffnx {Scheme Procedure} getprotobyname name
@deffnx {Scheme Procedure} getprotobynumber number
@end deffn
\fgetserv
+@c snarfed from net_db.c:334
@deffn {Scheme Procedure} getserv [name [protocol]]
@deffnx {Scheme Procedure} getservbyname name protocol
@deffnx {Scheme Procedure} getservbyport port protocol
@end deffn
\fsethost
+@c snarfed from net_db.c:385
@deffn {Scheme Procedure} sethost [stayopen]
@deffnx {C Function} scm_sethost (stayopen)
If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.
@end deffn
\fsetnet
+@c snarfed from net_db.c:401
@deffn {Scheme Procedure} setnet [stayopen]
@deffnx {C Function} scm_setnet (stayopen)
If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.
@end deffn
\fsetproto
+@c snarfed from net_db.c:417
@deffn {Scheme Procedure} setproto [stayopen]
@deffnx {C Function} scm_setproto (stayopen)
If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.
@end deffn
\fsetserv
+@c snarfed from net_db.c:433
@deffn {Scheme Procedure} setserv [stayopen]
@deffnx {C Function} scm_setserv (stayopen)
If @var{stayopen} is omitted, this is equivalent to @code{endservent}.
@end deffn
\fhtons
+@c snarfed from socket.c:80
@deffn {Scheme Procedure} htons value
@deffnx {C Function} scm_htons (value)
Convert a 16 bit quantity from host to network byte ordering.
@end deffn
\fntohs
+@c snarfed from socket.c:91
@deffn {Scheme Procedure} ntohs value
@deffnx {C Function} scm_ntohs (value)
Convert a 16 bit quantity from network to host byte ordering.
@end deffn
\fhtonl
+@c snarfed from socket.c:102
@deffn {Scheme Procedure} htonl value
@deffnx {C Function} scm_htonl (value)
Convert a 32 bit quantity from host to network byte ordering.
@end deffn
\fntohl
+@c snarfed from socket.c:115
@deffn {Scheme Procedure} ntohl value
@deffnx {C Function} scm_ntohl (value)
Convert a 32 bit quantity from network to host byte ordering.
@end deffn
\finet-aton
+@c snarfed from socket.c:135
@deffn {Scheme Procedure} inet-aton address
@deffnx {C Function} scm_inet_aton (address)
Convert an IPv4 Internet address from printable string
@end deffn
\finet-ntoa
+@c snarfed from socket.c:158
@deffn {Scheme Procedure} inet-ntoa inetid
@deffnx {C Function} scm_inet_ntoa (inetid)
Convert an IPv4 Internet address to a printable
@end deffn
\finet-netof
+@c snarfed from socket.c:178
@deffn {Scheme Procedure} inet-netof address
@deffnx {C Function} scm_inet_netof (address)
Return the network number part of the given IPv4
@end deffn
\finet-lnaof
+@c snarfed from socket.c:196
@deffn {Scheme Procedure} inet-lnaof address
@deffnx {C Function} scm_lnaof (address)
Return the local-address-with-network part of the given
@end deffn
\finet-makeaddr
+@c snarfed from socket.c:214
@deffn {Scheme Procedure} inet-makeaddr net lna
@deffnx {C Function} scm_inet_makeaddr (net, lna)
Make an IPv4 Internet address by combining the network number
@end deffn
\finet-pton
+@c snarfed from socket.c:399
@deffn {Scheme Procedure} inet-pton family address
@deffnx {C Function} scm_inet_pton (family, address)
Convert a string containing a printable network address to
@end deffn
\finet-ntop
+@c snarfed from socket.c:437
@deffn {Scheme Procedure} inet-ntop family address
@deffnx {C Function} scm_inet_ntop (family, address)
Convert a network address into a printable string.
@end deffn
\fsocket
+@c snarfed from socket.c:479
@deffn {Scheme Procedure} socket family style proto
@deffnx {C Function} scm_socket (family, style, proto)
Return a new socket port of the type specified by @var{family},
@end deffn
\fsocketpair
+@c snarfed from socket.c:500
@deffn {Scheme Procedure} socketpair family style proto
@deffnx {C Function} scm_socketpair (family, style, proto)
Return a pair of connected (but unnamed) socket ports of the
@end deffn
\fgetsockopt
+@c snarfed from socket.c:525
@deffn {Scheme Procedure} getsockopt sock level optname
@deffnx {C Function} scm_getsockopt (sock, level, optname)
Return the value of a particular socket option for the socket
@end deffn
\fsetsockopt
+@c snarfed from socket.c:593
@deffn {Scheme Procedure} setsockopt sock level optname value
@deffnx {C Function} scm_setsockopt (sock, level, optname, value)
Set the value of a particular socket option for the socket
@end deffn
\fshutdown
+@c snarfed from socket.c:697
@deffn {Scheme Procedure} shutdown sock how
@deffnx {C Function} scm_shutdown (sock, how)
Sockets can be closed simply by using @code{close-port}. The
@end deffn
\fconnect
+@c snarfed from socket.c:842
@deffn {Scheme Procedure} connect sock fam address . args
@deffnx {C Function} scm_connect (sock, fam, address, args)
Initiate a connection from a socket using a specified address
@end deffn
\fbind
+@c snarfed from socket.c:901
@deffn {Scheme Procedure} bind sock fam address . args
@deffnx {C Function} scm_bind (sock, fam, address, args)
Assign an address to the socket port @var{sock}.
@end deffn
\flisten
+@c snarfed from socket.c:934
@deffn {Scheme Procedure} listen sock backlog
@deffnx {C Function} scm_listen (sock, backlog)
Enable @var{sock} to accept connection
@end deffn
\faccept
+@c snarfed from socket.c:1046
@deffn {Scheme Procedure} accept sock
@deffnx {C Function} scm_accept (sock)
Accept a connection on a bound, listening socket.
@end deffn
\fgetsockname
+@c snarfed from socket.c:1073
@deffn {Scheme Procedure} getsockname sock
@deffnx {C Function} scm_getsockname (sock)
Return the address of @var{sock}, in the same form as the
@end deffn
\fgetpeername
+@c snarfed from socket.c:1095
@deffn {Scheme Procedure} getpeername sock
@deffnx {C Function} scm_getpeername (sock)
Return the address that @var{sock}
@end deffn
\frecv!
+@c snarfed from socket.c:1130
@deffn {Scheme Procedure} recv! sock buf [flags]
@deffnx {C Function} scm_recv (sock, buf, flags)
Receive data from a socket port.
@end deffn
\fsend
+@c snarfed from socket.c:1173
@deffn {Scheme Procedure} send sock message [flags]
@deffnx {C Function} scm_send (sock, message, flags)
Transmit the string @var{message} on a socket port @var{sock}.
@end deffn
\frecvfrom!
+@c snarfed from socket.c:1224
@deffn {Scheme Procedure} recvfrom! sock str [flags [start [end]]]
@deffnx {C Function} scm_recvfrom (sock, str, flags, start, end)
Return data from the socket port @var{sock} and also
@end deffn
\fsendto
+@c snarfed from socket.c:1289
@deffn {Scheme Procedure} sendto sock message fam address . args_and_flags
@deffnx {C Function} scm_sendto (sock, message, fam, address, args_and_flags)
Transmit the string @var{message} on the socket port
@end deffn
\fregexp?
+@c snarfed from regex-posix.c:105
@deffn {Scheme Procedure} regexp? obj
@deffnx {C Function} scm_regexp_p (obj)
Return @code{#t} if @var{obj} is a compiled regular expression,
@end deffn
\fmake-regexp
+@c snarfed from regex-posix.c:150
@deffn {Scheme Procedure} make-regexp pat . flags
@deffnx {C Function} scm_make_regexp (pat, flags)
Compile the regular expression described by @var{pat}, and
@end deffn
\fregexp-exec
+@c snarfed from regex-posix.c:216
@deffn {Scheme Procedure} regexp-exec rx str [start [flags]]
@deffnx {C Function} scm_regexp_exec (rx, str, start, flags)
Match the compiled regular expression @var{rx} against
considered the end of a line.
@end table
@end deffn
-
-\fsingle-active-thread?
-@deffn {Scheme Procedure} single-active-thread?
-implemented by the C function "scm_single_thread_p"
-@end deffn
-
-\fyield
-@deffn {Scheme Procedure} yield
-implemented by the C function "scm_yield"
-@end deffn
-
-\fcall-with-new-thread
-@deffn {Scheme Procedure} call-with-new-thread
-implemented by the C function "scm_call_with_new_thread"
-@end deffn
-
-\fcurrent-thread
-@deffn {Scheme Procedure} current-thread
-implemented by the C function "scm_current_thread"
-@end deffn
-
-\fall-threads
-@deffn {Scheme Procedure} all-threads
-implemented by the C function "scm_all_threads"
-@end deffn
-
-\fjoin-thread
-@deffn {Scheme Procedure} join-thread
-implemented by the C function "scm_join_thread"
-@end deffn
-
-\fmake-mutex
-@deffn {Scheme Procedure} make-mutex
-implemented by the C function "scm_make_mutex"
-@end deffn
-
-\flock-mutex
-@deffn {Scheme Procedure} lock-mutex
-implemented by the C function "scm_lock_mutex"
-@end deffn
-
-\funlock-mutex
-@deffn {Scheme Procedure} unlock-mutex
-implemented by the C function "scm_unlock_mutex"
-@end deffn
-
-\fmake-condition-variable
-@deffn {Scheme Procedure} make-condition-variable
-implemented by the C function "scm_make_condition_variable"
-@end deffn
-
-\fwait-condition-variable
-@deffn {Scheme Procedure} wait-condition-variable
-implemented by the C function "scm_wait_condition_variable"
-@end deffn
-
-\fsignal-condition-variable
-@deffn {Scheme Procedure} signal-condition-variable
-implemented by the C function "scm_signal_condition_variable"
-@end deffn
HCoop / bpt / guile.git / commitdiff