-@paragraphindent 0
\facons
-@deffn primitive acons key value alist
-Adds a new key-value pair to @var{alist}. A new pair is
+@c snarfed from alist.c:36
+@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
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned. This
function is @emph{not} destructive; @var{alist} is not modified.
@end deffn
\fsloppy-assq
-@deffn primitive sloppy-assq key alist
+@c snarfed from alist.c:50
+@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.
Recommended only for use in Guile internals.
@end deffn
\fsloppy-assv
-@deffn primitive sloppy-assv key alist
+@c snarfed from alist.c:68
+@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.
Recommended only for use in Guile internals.
@end deffn
\fsloppy-assoc
-@deffn primitive sloppy-assoc key alist
+@c snarfed from alist.c:86
+@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.
Recommended only for use in Guile internals.
@end deffn
\fassq
-@deffn primitive assq key alist
-@deffnx primitive assv key alist
-@deffnx primitive assoc key alist
-Fetches the entry in @var{alist} that is associated with @var{key}. To
+@c snarfed from alist.c:113
+@deffn {Scheme Procedure} assq key alist
+@deffnx {Scheme Procedure} assv key alist
+@deffnx {Scheme Procedure} assoc key alist
+@deffnx {C Function} scm_assq (key, alist)
+Fetch the entry in @var{alist} that is associated with @var{key}. To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}. If @var{key}
cannot be found in @var{alist} (according to whichever equality
-predicate is in use), then @code{#f} is returned. These functions
+predicate is in use), then return @code{#f}. These functions
return the entire alist entry found (i.e. both the key and the value).
@end deffn
\fassv
-@deffn primitive assv key alist
+@c snarfed from alist.c:134
+@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
-@deffn primitive assoc key alist
+@c snarfed from alist.c:155
+@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
-@deffn primitive assq-ref alist key
-@deffnx primitive assv-ref alist key
-@deffnx primitive assoc-ref alist key
+@c snarfed from alist.c:199
+@deffn {Scheme Procedure} assq-ref alist key
+@deffnx {Scheme Procedure} assv-ref alist key
+@deffnx {Scheme Procedure} assoc-ref alist key
+@deffnx {C Function} scm_assq_ref (alist, key)
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned. These
functions are equivalent to
@end deffn
\fassv-ref
-@deffn primitive assv-ref alist key
+@c snarfed from alist.c:216
+@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
-@deffn primitive assoc-ref alist key
+@c snarfed from alist.c:233
+@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!
-@deffn primitive assq-set! alist key val
-@deffnx primitive assv-set! alist key value
-@deffnx primitive assoc-set! alist key value
+@c snarfed from alist.c:262
+@deffn {Scheme Procedure} assq-set! alist key val
+@deffnx {Scheme Procedure} assv-set! alist key value
+@deffnx {Scheme Procedure} assoc-set! alist key value
+@deffnx {C Function} scm_assq_set_x (alist, key, val)
Reassociate @var{key} in @var{alist} with @var{value}: find any existing
@var{alist} entry for @var{key} and associate it with the new
@var{value}. If @var{alist} does not contain an entry for @var{key},
@end deffn
\fassv-set!
-@deffn primitive assv-set! alist key val
+@c snarfed from alist.c:280
+@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!
-@deffn primitive assoc-set! alist key val
+@c snarfed from alist.c:298
+@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!
-@deffn primitive assq-remove! alist key
-@deffnx primitive assv-remove! alist key
-@deffnx primitive assoc-remove! alist key
+@c snarfed from alist.c:322
+@deffn {Scheme Procedure} assq-remove! alist key
+@deffnx {Scheme Procedure} assv-remove! alist key
+@deffnx {Scheme Procedure} assoc-remove! alist key
+@deffnx {C Function} scm_assq_remove_x (alist, key)
Delete the first entry in @var{alist} associated with @var{key}, and return
the resulting alist.
@end deffn
\fassv-remove!
-@deffn primitive assv-remove! alist key
+@c snarfed from alist.c:338
+@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!
-@deffn primitive assoc-remove! alist key
+@c snarfed from alist.c:354
+@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
-@deffn primitive 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.
+@c snarfed from arbiters.c:99
+@deffn {Scheme Procedure} make-arbiter name
+@deffnx {C Function} scm_make_arbiter (name)
+Return an arbiter object, initially unlocked. Currently
+@var{name} is only used for diagnostic output.
@end deffn
\ftry-arbiter
-@deffn primitive try-arbiter arb
-Return @code{#t} and lock the arbiter @var{arb} if the arbiter
-was unlocked. Otherwise, return @code{#f}.
+@c snarfed from arbiters.c:116
+@deffn {Scheme Procedure} try-arbiter arb
+@deffnx {C Function} scm_try_arbiter (arb)
+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
-@deffn primitive release-arbiter arb
-Return @code{#t} and unlock the arbiter @var{arb} if the
-arbiter was locked. Otherwise, return @code{#f}.
+@c snarfed from arbiters.c:142
+@deffn {Scheme Procedure} release-arbiter arb
+@deffnx {C Function} scm_release_arbiter (arb)
+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
-@deffn primitive async thunk
+@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
-\fsystem-async
-@deffn primitive system-async thunk
-Create a new async for the procedure @var{thunk}. Also
-add it to the system's list of active async objects.
-@end deffn
-
\fasync-mark
-@deffn primitive async-mark a
-Mark the async @var{a} for future execution.
-@end deffn
-
-\fsystem-async-mark
-@deffn primitive system-async-mark a
+@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
-@deffn primitive run-asyncs list_of_a
+@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
+@c snarfed from async.c:180
+@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)
+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
-@deffn primitive noop . args
+@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 primitive unmask-signals
+@c snarfed from async.c:268
+@deffn {Scheme Procedure} unmask-signals
+@deffnx {C Function} scm_unmask_signals ()
Unmask signals. The returned value is not specified.
@end deffn
\fmask-signals
-@deffn primitive mask-signals
+@c snarfed from async.c:286
+@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
+of system asyncs by one level for the current thread while
+it is running. Return the value returned by @var{proc}.
+
+@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
+of system asyncs by one level for the current thread while
+it is running. Return the value returned by @var{proc}.
+
+@end deffn
+
\fdisplay-error
-@deffn primitive display-error stack port subr message args rest
+@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}.
@var{stack} is the saved stack for the error, @var{subr} is
-the name of the procedure in which the error occured and
+the name of the procedure in which the error occurred and
@var{message} is the actual error message, which may contain
formatting instructions. These will format the arguments in
the list @var{args} accordingly. @var{rest} is currently
@end deffn
\fdisplay-application
-@deffn primitive display-application frame [port [indent]]
+@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
@var{port}. @var{indent} specifies the indentation of the
output.
@end deffn
\fdisplay-backtrace
-@deffn primitive display-backtrace stack port [first [depth]]
+@c snarfed from backtrace.c:762
+@deffn {Scheme Procedure} display-backtrace stack port [first [depth [highlights]]]
+@deffnx {C Function} scm_display_backtrace_with_highlights (stack, port, first, depth, highlights)
Display a backtrace to the output port @var{port}. @var{stack}
is the stack to take the backtrace from, @var{first} specifies
where in the stack to start and @var{depth} how much frames
to display. Both @var{first} and @var{depth} can be @code{#f},
which means that default values will be used.
+When @var{highlights} is given,
+it should be a list and all members of it are highligthed in
+the backtrace.
@end deffn
\fbacktrace
-@deffn primitive backtrace
+@c snarfed from backtrace.c:798
+@deffn {Scheme Procedure} backtrace [highlights]
+@deffnx {C Function} scm_backtrace_with_highlights (highlights)
Display a backtrace of the stack saved by the last error
-to the current output port.
+to the current output port. When @var{highlights} is given,
+it should be a list and all members of it are highligthed in
+the backtrace.
@end deffn
\fnot
-@deffn primitive not x
+@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?
-@deffn primitive boolean? obj
+@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?
-@deffn primitive char? x
+@c snarfed from chars.c:33
+@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=?
-@deffn primitive char=? x y
+@c snarfed from chars.c:42
+@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<?
-@deffn primitive char<? x y
+@c snarfed from chars.c:55
+@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<=?
-@deffn primitive char<=? x y
+@c snarfed from chars.c:67
+@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>?
-@deffn primitive char>? x y
+@c snarfed from chars.c:79
+@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>=?
-@deffn primitive char>=? x y
+@c snarfed from chars.c:91
+@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=?
-@deffn primitive char-ci=? x y
+@c snarfed from chars.c:103
+@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<?
-@deffn primitive char-ci<? x y
+@c snarfed from chars.c:115
+@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<=?
-@deffn primitive char-ci<=? x y
+@c snarfed from chars.c:127
+@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>?
-@deffn primitive char-ci>? x y
+@c snarfed from chars.c:139
+@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>=?
-@deffn primitive char-ci>=? x y
+@c snarfed from chars.c:151
+@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?
-@deffn primitive char-alphabetic? chr
+@c snarfed from chars.c:163
+@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}.
-Alphabetic means the same thing as the isalpha C library function.
+
@end deffn
\fchar-numeric?
-@deffn primitive char-numeric? chr
+@c snarfed from chars.c:172
+@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}.
-Numeric means the same thing as the isdigit C library function.
+
@end deffn
\fchar-whitespace?
-@deffn primitive char-whitespace? chr
+@c snarfed from chars.c:181
+@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}.
-Whitespace means the same thing as the isspace C library function.
+
@end deffn
\fchar-upper-case?
-@deffn primitive char-upper-case? chr
+@c snarfed from chars.c:192
+@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}.
-Uppercase means the same thing as the isupper C library function.
+
@end deffn
\fchar-lower-case?
-@deffn primitive char-lower-case? chr
+@c snarfed from chars.c:202
+@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}.
-Lowercase means the same thing as the islower C library function.
+
@end deffn
\fchar-is-both?
-@deffn primitive char-is-both? chr
+@c snarfed from chars.c:213
+@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}.
-Uppercase and lowercase are as defined by the isupper and islower
-C library functions.
+
@end deffn
\fchar->integer
-@deffn primitive char->integer chr
+@c snarfed from chars.c:228
+@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
ASCII sequence.
@end deffn
\finteger->char
-@deffn primitive integer->char n
+@c snarfed from chars.c:240
+@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
-@deffn primitive char-upcase chr
+@c snarfed from chars.c:250
+@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
-@deffn primitive char-downcase chr
+@c snarfed from chars.c:261
+@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
-@deffn primitive debug-options-interface [setting]
+@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
this procedure directly, use the procedures @code{debug-enable},
-@code{debug-disable}, @code{debug-set!} and @var{debug-options}.
+@code{debug-disable}, @code{debug-set!} and @code{debug-options}.
@end deffn
\fwith-traps
-@deffn primitive with-traps thunk
+@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?
-@deffn primitive memoized? obj
+@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 primitive 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
-@deffn primitive memoized-environment m
+@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
-@deffn primitive procedure-name proc
+@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
-@deffn primitive procedure-source proc
+@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
-@deffn primitive procedure-environment proc
+@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
-@deffn primitive local-eval exp [env]
+@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,
it is the environment in which to evaluate @var{exp}. Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
@end deffn
\fdebug-object?
-@deffn primitive debug-object? obj
+@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
+\fissue-deprecation-warning
+@c snarfed from deprecation.c:99
+@deffn {Scheme Procedure} issue-deprecation-warning . msgs
+@deffnx {C Function} scm_issue_deprecation_warning (msgs)
+Output @var{msgs} to @code{(current-error-port)} when this is the first call to @code{issue-deprecation-warning} with this specific @var{msgs}. Do nothing otherwise. The argument @var{msgs} should be a list of strings; they are printed in turn, each one followed by a newline.
+@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
+
+\fsubstring-move-left!
+@c snarfed from deprecated.c:69
+@deffn {Scheme Procedure} substring-move-left!
+implemented by the C function "scm_substring_move_x"
+@end deffn
+
+\fsubstring-move-right!
+@c snarfed from deprecated.c:71
+@deffn {Scheme Procedure} substring-move-right!
+implemented by the C function "scm_substring_move_x"
+@end deffn
+
+\fc-registered-modules
+@c snarfed from deprecated.c:174
+@deffn {Scheme Procedure} c-registered-modules
+@deffnx {C Function} scm_registered_modules ()
+Return a list of the object code modules that have been imported into
+the current Guile process. Each element of the list is a pair whose
+car is the name of the module, and whose cdr is the function handle
+for that module's initializer function. The name is the string that
+has been passed to scm_register_module_xxx.
+@end deffn
+
+\fc-clear-registered-modules
+@c snarfed from deprecated.c:195
+@deffn {Scheme Procedure} c-clear-registered-modules
+@deffnx {C Function} scm_clear_registered_modules ()
+Destroy the list of modules registered with the current Guile process.
+The return value is unspecified. @strong{Warning:} this function does
+not actually unlink or deallocate these modules, but only destroys the
+records of which modules have been loaded. It should therefore be used
+only by module bookkeeping operations.
+@end deffn
+
+\fclose-all-ports-except
+@c snarfed from deprecated.c:338
+@deffn {Scheme Procedure} close-all-ports-except . ports
+@deffnx {C Function} scm_close_all_ports_except (ports)
+[DEPRECATED] Close all open file ports used by the interpreter
+except for those supplied as arguments. This procedure
+was intended to be used before an exec call to close file descriptors
+which are not needed in the new process. However it has the
+undesirable side effect of flushing buffers, so it's deprecated.
+Use port-for-each instead.
+@end deffn
+
+\fvariable-set-name-hint!
+@c snarfed from deprecated.c:355
+@deffn {Scheme Procedure} variable-set-name-hint! var hint
+@deffnx {C Function} scm_variable_set_name_hint (var, hint)
+Do not use this function.
+@end deffn
+
+\fbuiltin-variable
+@c snarfed from deprecated.c:368
+@deffn {Scheme Procedure} builtin-variable name
+@deffnx {C Function} scm_builtin_variable (name)
+Do not use this function.
+@end deffn
+
+\fsloppy-memq
+@c snarfed from deprecated.c:442
+@deffn {Scheme Procedure} sloppy-memq x lst
+@deffnx {C Function} scm_sloppy_memq (x, lst)
+This procedure behaves like @code{memq}, but does no type or error checking.
+Its use is recommended only in writing Guile internals,
+not for high-level Scheme programs.
+@end deffn
+
+\fsloppy-memv
+@c snarfed from deprecated.c:462
+@deffn {Scheme Procedure} sloppy-memv x lst
+@deffnx {C Function} scm_sloppy_memv (x, lst)
+This procedure behaves like @code{memv}, but does no type or error checking.
+Its use is recommended only in writing Guile internals,
+not for high-level Scheme programs.
+@end deffn
+
+\fsloppy-member
+@c snarfed from deprecated.c:482
+@deffn {Scheme Procedure} sloppy-member x lst
+@deffnx {C Function} scm_sloppy_member (x, lst)
+This procedure behaves like @code{member}, but does no type or error checking.
+Its use is recommended only in writing Guile internals,
+not for high-level Scheme programs.
+@end deffn
+
+\fread-and-eval!
+@c snarfed from deprecated.c:504
+@deffn {Scheme Procedure} read-and-eval! [port]
+@deffnx {C Function} scm_read_and_eval_x (port)
+Read a form from @var{port} (standard input by default), and evaluate it
+(memoizing it in the process) in the top-level environment. If no data
+is left to be read from @var{port}, an @code{end-of-file} error is
+signalled.
+@end deffn
+
+\fstring->obarray-symbol
+@c snarfed from deprecated.c:794
+@deffn {Scheme Procedure} string->obarray-symbol o s [softp]
+@deffnx {C Function} scm_string_to_obarray_symbol (o, s, softp)
+Intern a new symbol in @var{obarray}, a symbol table, with name
+@var{string}.
+
+If @var{obarray} is @code{#f}, use the default system symbol table. If
+@var{obarray} is @code{#t}, the symbol should not be interned in any
+symbol table; merely return the pair (@var{symbol}
+. @var{#<undefined>}).
+
+The @var{soft?} argument determines whether new symbol table entries
+should be created when the specified symbol is not already present in
+@var{obarray}. If @var{soft?} is specified and is a true value, then
+new entries should not be added for symbols not already present in the
+table; instead, simply return @code{#f}.
+@end deffn
+
+\fintern-symbol
+@c snarfed from deprecated.c:832
+@deffn {Scheme Procedure} intern-symbol o s
+@deffnx {C Function} scm_intern_symbol (o, s)
+Add a new symbol to @var{obarray} with name @var{string}, bound to an
+unspecified initial value. The symbol table is not modified if a symbol
+with this name is already present.
+@end deffn
+
+\funintern-symbol
+@c snarfed from deprecated.c:874
+@deffn {Scheme Procedure} unintern-symbol o s
+@deffnx {C Function} scm_unintern_symbol (o, s)
+Remove the symbol with name @var{string} from @var{obarray}. This
+function returns @code{#t} if the symbol was present and @code{#f}
+otherwise.
+@end deffn
+
+\fsymbol-binding
+@c snarfed from deprecated.c:919
+@deffn {Scheme Procedure} symbol-binding o s
+@deffnx {C Function} scm_symbol_binding (o, s)
+Look up in @var{obarray} the symbol whose name is @var{string}, and
+return the value to which it is bound. If @var{obarray} is @code{#f},
+use the global symbol table. If @var{string} is not interned in
+@var{obarray}, an error is signalled.
+@end deffn
+
+\fsymbol-bound?
+@c snarfed from deprecated.c:972
+@deffn {Scheme Procedure} symbol-bound? o s
+@deffnx {C Function} scm_symbol_bound_p (o, s)
+Return @code{#t} if @var{obarray} contains a symbol with name
+@var{string} bound to a defined value. This differs from
+@var{symbol-interned?} in that the mere mention of a symbol
+usually causes it to be interned; @code{symbol-bound?}
+determines whether a symbol has been given any meaningful
+value.
+@end deffn
+
+\fsymbol-set!
+@c snarfed from deprecated.c:999
+@deffn {Scheme Procedure} symbol-set! o s v
+@deffnx {C Function} scm_symbol_set_x (o, s, v)
+Find the symbol in @var{obarray} whose name is @var{string}, and rebind
+it to @var{value}. An error is signalled if @var{string} is not present
+in @var{obarray}.
+@end deffn
+
+\fgentemp
+@c snarfed from deprecated.c:1032
+@deffn {Scheme Procedure} gentemp [prefix [obarray]]
+@deffnx {C Function} scm_gentemp (prefix, obarray)
+Create a new symbol with a name unique in an obarray.
+The name is constructed from an optional string @var{prefix}
+and a counter value. The default prefix is @code{t}. The
+@var{obarray} is specified as a second optional argument.
+Default is the system obarray where all normal symbols are
+interned. The counter is increased by 1 at each
+call. There is no provision for resetting the counter.
+@end deffn
+
\fdynamic-link
-@deffn primitive dynamic-link filename
-Open the dynamic library called @var{filename}. A library
-handle representing the opened library is returned; this handle
-should be used as the @var{dobj} argument to the following
-functions.
+@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
+@var{filename} and link it into the running Guile
+application. The returned
+scheme object is a ``handle'' for the library which can
+be passed to @code{dynamic-func}, @code{dynamic-call} etc.
+
+Searching for object files is system dependent. Normally,
+if @var{filename} does have an explicit directory it will
+be searched for in locations
+such as @file{/usr/lib} and @file{/usr/local/lib}.
@end deffn
\fdynamic-object?
-@deffn primitive dynamic-object? obj
-Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
-otherwise.
+@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,
+or @code{#f} otherwise.
@end deffn
\fdynamic-unlink
-@deffn primitive dynamic-unlink dobj
-Unlink the indicated object file from the application. The
-argument @var{dobj} must have been obtained by a call to
-@code{dynamic-link}. After @code{dynamic-unlink} has been
-called on @var{dobj}, its content is no longer accessible.
+@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
+object must have been linked by @code{dynamic-link}, with
+@var{dobj} the corresponding handle. After this procedure
+is called, the handle can no longer be used to access the
+object.
@end deffn
\fdynamic-func
-@deffn primitive dynamic-func name dobj
-Search the dynamic object @var{dobj} for the C function
-indicated by the string @var{name} and return some Scheme
-handle that can later be used with @code{dynamic-call} to
-actually call the function.
+@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
+shared object referred to by @var{dobj}. The handle
+can be passed to @code{dynamic-call} to actually
+call the function.
-Regardless whether your C compiler prepends an underscore @samp{_} to
-the global names in a program, you should @strong{not} include this
-underscore in @var{function}. Guile knows whether the underscore is
-needed or not and will add it when necessary.
+Regardless whether your C compiler prepends an underscore
+@samp{_} to the global names in a program, you should
+@strong{not} include this underscore in @var{name}
+since it will be added automatically when necessary.
@end deffn
\fdynamic-call
-@deffn primitive dynamic-call func dobj
-Call the C function indicated by @var{func} and @var{dobj}.
-The function is passed no arguments and its return value is
-ignored. When @var{function} is something returned by
-@code{dynamic-func}, call that function and ignore @var{dobj}.
-When @var{func} is a string , look it up in @var{dynobj}; this
-is equivalent to
+@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
+invocation are supported:
+
+@itemize @bullet
+@item @var{func} can be a function handle returned by
+@code{dynamic-func}. In this case @var{dobj} is
+ignored
+@item @var{func} can be a string with the name of the
+function to call, with @var{dobj} the handle of the
+dynamic object in which to find the function.
+This is equivalent to
@smallexample
-(dynamic-call (dynamic-func @var{func} @var{dobj} #f))
+
+(dynamic-call (dynamic-func @var{func} @var{dobj}) #f)
@end smallexample
+@end itemize
-Interrupts are deferred while the C function is executing (with
-@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
+In either case, the function is passed no arguments
+and its return value is ignored.
@end deffn
\fdynamic-args-call
-@deffn primitive dynamic-args-call func dobj args
+@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},
just like @code{dynamic-call}, but pass it some arguments and
return its return value. The C function is expected to take
@end deffn
\fdynamic-wind
-@deffn primitive dynamic-wind in_guard thunk out_guard
+@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.
@var{in_guard} is called, then @var{thunk}, then
@var{out_guard}.
@end deffn
\fenvironment?
-@deffn primitive environment? obj
+@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}
otherwise.
@end deffn
\fenvironment-bound?
-@deffn primitive environment-bound? env sym
+@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
@code{#f} otherwise.
@end deffn
\fenvironment-ref
-@deffn primitive environment-ref env sym
+@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
@var{env}. If @var{sym} is unbound in @var{env}, signal an
@code{environment:unbound} error.
@end deffn
\fenvironment-fold
-@deffn primitive environment-fold env proc init
+@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
value.
For each binding in @var{env}, apply @var{proc} to the symbol
@end deffn
\fenvironment-define
-@deffn primitive environment-define env sym val
+@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
@var{env}. If @var{sym} is already bound to another location
in @var{env} and the binding is mutable, that binding is
@end deffn
\fenvironment-undefine
-@deffn primitive environment-undefine env sym
+@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}
is unbound in @var{env}, do nothing. The return value is
unspecified.
@end deffn
\fenvironment-set!
-@deffn primitive environment-set! env sym val
+@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
location's value to @var{val}. The return value is
unspecified.
@end deffn
\fenvironment-cell
-@deffn primitive environment-cell env sym for_write
+@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
@code{#f} if the binding does not live in a value cell.
The argument @var{for-write} indicates whether the caller
@end deffn
\fenvironment-observe
-@deffn primitive environment-observe env proc
+@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
@var{env}.
This function returns an object, token, which you can pass to
@end deffn
\fenvironment-observe-weak
-@deffn primitive environment-observe-weak env proc
+@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
the reference @var{env} retains to @var{proc} is a weak
reference. This means that, if there are no other live,
@end deffn
\fenvironment-unobserve
-@deffn primitive environment-unobserve token
+@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
@var{token}. The return value is unspecified.
If a call @code{(environment-observe env proc)} returns
@end deffn
\fmake-leaf-environment
-@deffn primitive make-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.
All bindings and locations created in the new environment
will be mutable.
@end deffn
\fleaf-environment?
-@deffn primitive leaf-environment? object
+@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}
otherwise.
@end deffn
\fmake-eval-environment
-@deffn primitive make-eval-environment local imported
+@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
union of the bindings in the environments @var{local} and
@var{imported}, with bindings from @var{local} taking
@end deffn
\feval-environment?
-@deffn primitive eval-environment? object
+@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}
otherwise.
@end deffn
\feval-environment-local
-@deffn primitive eval-environment-local env
+@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!
-@deffn primitive eval-environment-set-local! env 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
-@deffn primitive eval-environment-imported env
+@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!
-@deffn primitive eval-environment-set-imported! env 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
-@deffn primitive make-import-environment imports conflict_proc
+@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
of the bindings from the environments in @var{imports};
@var{imports} must be a list of environments. That is,
@end deffn
\fimport-environment?
-@deffn primitive import-environment? object
+@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
@code{#f} otherwise.
@end deffn
\fimport-environment-imports
-@deffn primitive import-environment-imports env
+@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
environment @var{env}.
@end deffn
\fimport-environment-set-imports!
-@deffn primitive import-environment-set-imports! env 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
@var{imports}, and check for conflicts.
@end deffn
\fmake-export-environment
-@deffn primitive make-export-environment private signature
+@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
bindings in private whose symbols are present in
@var{signature}. The @var{private} argument must be an
@end deffn
\fexport-environment?
-@deffn primitive export-environment? object
+@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
@code{#f} otherwise.
@end deffn
\fexport-environment-private
-@deffn primitive export-environment-private env
+@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!
-@deffn primitive export-environment-set-private! env 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
-@deffn primitive export-environment-signature env
+@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!
-@deffn primitive export-environment-set-signature! env 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?
-@deffn primitive eq? x y
+@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
capable of discerning distinctions finer than those detectable by
@end deffn
\feqv?
-@deffn primitive eqv? x y
+@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
regarded as the same object. This relation is left slightly open to
@end deffn
\fequal?
-@deffn primitive equal? x y
+@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,
vectors, and strings, applying @code{eqv?} on other objects such as
@end deffn
\fscm-error
-@deffn primitive scm-error key subr message args data
+@c snarfed from error.c:83
+@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
naming the procedure associated with the error, or @code{#f}.
@var{message} is the error message string, possibly containing
@code{#f} depending on @var{key}: if @var{key} is
@code{system-error} then it should be a list containing the
Unix @code{errno} value; If @var{key} is @code{signal} then it
-should be a list containing the Unix signal number; otherwise
+should be a list containing the Unix signal number; If
+@var{key} is @code{out-of-range} or @code{wrong-type-arg},
+it is a list containing the bad value; otherwise
it will usually be @code{#f}.
@end deffn
\fstrerror
-@deffn primitive strerror err
+@c snarfed from error.c:130
+@deffn {Scheme Procedure} strerror err
+@deffnx {C Function} scm_strerror (err)
Return the Unix error message corresponding to @var{err}, which
must be an integer value.
@end deffn
\fapply:nconc2last
-@deffn primitive apply:nconc2last lst
+@c snarfed from eval.c:4690
+@deffn {Scheme Procedure} apply:nconc2last lst
+@deffnx {C Function} scm_nconc2last (lst)
Given a list (@var{arg1} @dots{} @var{args}), this function
conses the @var{arg1} @dots{} arguments onto the front of
@var{args}, and returns the resulting list. Note that
@end deffn
\fforce
-@deffn primitive force x
+@c snarfed from eval.c:5600
+@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?
-@deffn primitive promise? obj
+@c snarfed from eval.c:5623
+@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
(@pxref{Delayed evaluation,,,r5rs.info,The Revised^5 Report on Scheme}).
@end deffn
\fcons-source
-@deffn primitive cons-source xorig x y
+@c snarfed from eval.c:5635
+@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}.
Any source properties associated with @var{xorig} are also associated
with the new pair.
@end deffn
\fcopy-tree
-@deffn primitive copy-tree obj
+@c snarfed from eval.c:5792
+@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
-@deffn primitive primitive-eval exp
+@c snarfed from eval.c:5878
+@deffn {Scheme Procedure} primitive-eval exp
+@deffnx {C Function} scm_primitive_eval (exp)
Evaluate @var{exp} in the top-level environment specified by
the current module.
@end deffn
\feval
-@deffn primitive eval exp module
+@c snarfed from eval.c:5947
+@deffn {Scheme Procedure} eval exp module
+@deffnx {C Function} scm_eval (exp, module)
Evaluate @var{exp}, a list representing a Scheme expression,
in the top-level environment specified by @var{module}.
-While @var{exp} is evaluated (using @var{primitive-eval}),
+While @var{exp} is evaluated (using @code{primitive-eval}),
@var{module} is made the current module. The current module
is reset to its previous value when @var{eval} returns.
@end deffn
\feval-options-interface
-@deffn primitive eval-options-interface [setting]
+@c snarfed from eval.c:3090
+@deffn {Scheme Procedure} eval-options-interface [setting]
+@deffnx {C Function} scm_eval_options_interface (setting)
Option interface for the evaluation options. Instead of using
this procedure directly, use the procedures @code{eval-enable},
-@code{eval-disable}, @code{eval-set!} and @var{eval-options}.
+@code{eval-disable}, @code{eval-set!} and @code{eval-options}.
@end deffn
\fevaluator-traps-interface
-@deffn primitive evaluator-traps-interface [setting]
+@c snarfed from eval.c:3108
+@deffn {Scheme Procedure} evaluator-traps-interface [setting]
+@deffnx {C Function} scm_evaluator_traps (setting)
Option interface for the evaluator trap options.
@end deffn
\fdefined?
-@deffn primitive defined? sym [env]
+@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
-@deffn primitive map-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
-@deffn primitive load-extension lib init
+@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.
When there is no pre-registered function for LIB/INIT, this is
equivalent to
@end deffn
\fprogram-arguments
-@deffn primitive program-arguments
-@deffnx procedure command-line
+@c snarfed from feature.c:56
+@deffn {Scheme Procedure} program-arguments
+@deffnx {Scheme Procedure} command-line
+@deffnx {C Function} scm_program_arguments ()
Return the list of command line arguments passed to Guile, as a list of
strings. The list includes the invoked program name, which is usually
@code{"guile"}, but excludes switches and parameters for command line
@end deffn
\fmake-fluid
-@deffn primitive make-fluid
+@c snarfed from fluids.c:100
+@deffn {Scheme Procedure} make-fluid
+@deffnx {C Function} scm_make_fluid ()
Return a newly created fluid.
Fluids are objects of a certain type (a smob) that can hold one SCM
value per dynamic root. That is, modifications to this value are
@end deffn
\ffluid?
-@deffn primitive fluid? obj
+@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
@code{#f}.
@end deffn
\ffluid-ref
-@deffn primitive fluid-ref fluid
+@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
dynamic root. If @var{fluid} has not been set, then return
@code{#f}.
@end deffn
\ffluid-set!
-@deffn primitive fluid-set! fluid value
+@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*
-@deffn primitive with-fluids* fluids values thunk
+@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}.
@var{fluids} must be a list of fluids and @var{values} must be the same
number of their values to be applied. Each substitution is done
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
-@deffn primitive setvbuf port mode [size]
+@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:
@table @code
@item _IONBF
@end deffn
\ffile-port?
-@deffn primitive file-port? obj
+@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
-@deffn primitive open-file filename mode
+@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
representing that file. The attributes of the port are
determined by the @var{mode} string. The way in which this is
requested, @code{open-file} throws an exception.
@end deffn
+\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
-@deffn primitive gc-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
use of storage.
+
@end deffn
\fobject-address
-@deffn primitive object-address obj
+@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
returned by this function for @var{obj}
@end deffn
\fgc
-@deffn primitive gc
+@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
no longer accessible.
@end deffn
\f%compute-slots
-@deffn primitive %compute-slots class
+@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
class @var{class}, i. e. the slots of @var{class} and of all of
its superclasses.
@end deffn
\fget-keyword
-@deffn primitive get-keyword key l default_value
+@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
the list @var{l}. The list @var{l} has to consist of an even
number of elements, where, starting with the first, every
@end deffn
\f%initialize-object
-@deffn primitive %initialize-object obj initargs
+@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
@var{initargs}.
@end deffn
\f%prep-layout!
-@deffn primitive %prep-layout! class
+@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!
-@deffn primitive %inherit-magic! class dsupers
+@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?
-@deffn primitive instance? obj
+@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
-@deffn primitive class-name obj
+@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
-@deffn primitive class-direct-supers obj
+@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
-@deffn primitive class-direct-slots obj
+@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
-@deffn primitive class-direct-subclasses obj
+@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
-@deffn primitive class-direct-methods obj
+@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
-@deffn primitive class-precedence-list obj
+@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
-@deffn primitive class-slots obj
+@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
-@deffn primitive class-environment obj
+@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
-@deffn primitive generic-function-name obj
+@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
-@deffn primitive generic-function-methods obj
+@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
-@deffn primitive method-generic-function obj
-Return the generic function fot the method @var{obj}.
+@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
-@deffn primitive method-specializers obj
+@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
-@deffn primitive method-procedure obj
+@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
-@deffn primitive accessor-method-slot-definition obj
+@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
-@deffn primitive %tag-body 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
-@deffn primitive make-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?
-@deffn primitive unbound? obj
+@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
-@deffn primitive assert-bound value obj
+@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
@var{slot-unbound} method of @var{obj} if it is not.
@end deffn
\f@@assert-bound-ref
-@deffn primitive @@assert-bound-ref obj index
+@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
the value from @var{obj}.
@end deffn
\f%fast-slot-ref
-@deffn primitive %fast-slot-ref obj index
+@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!
-@deffn primitive %fast-slot-set! obj index value
+@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
@var{value}.
@end deffn
\fslot-ref-using-class
-@deffn primitive slot-ref-using-class class obj slot_name
+@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!
-@deffn primitive slot-set-using-class! class obj slot_name value
+@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?
-@deffn primitive slot-bound-using-class? class obj slot_name
+@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?
-@deffn primitive slot-exists-using-class? class obj slot_name
+@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
-@deffn primitive slot-ref obj slot_name
+@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
@var{slot_name}.
@end deffn
\fslot-set!
-@deffn primitive slot-set! obj slot_name value
+@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?
-@deffn primitive slot-bound? obj slot_name
+@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}
is bound.
@end deffn
\fslot-exists?
-@deffn primitive slot-exists? obj slot_name
+@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
-@deffn primitive %allocate-instance class initargs
+@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
from the arguments @var{initargs}.
@end deffn
\f%set-object-setter!
-@deffn primitive %set-object-setter! obj 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
-@deffn primitive %modify-instance old new
+@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
-@deffn primitive %modify-class old new
+@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
-@deffn primitive %invalidate-class 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!
-@deffn primitive %invalidate-method-cache! gf
+@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?
-@deffn primitive generic-capability? proc
+@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!
-@deffn primitive enable-primitive-generic! . subrs
+@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
-@deffn primitive primitive-generic-generic subr
+@c snarfed from goops.c:1701
+@deffn {Scheme Procedure} primitive-generic-generic subr
+@deffnx {C Function} scm_primitive_generic_generic (subr)
@end deffn
\fmake
-@deffn primitive make . args
+@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
all necessary initialization information.
@end deffn
\ffind-method
-@deffn primitive find-method . l
+@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?
-@deffn primitive %method-more-specific? m1 m2 targs
+@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
-@deffn primitive %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
on the C level which depends on the loaded GOOPS modules.
@end deffn
\fmake-guardian
-@deffn primitive make-guardian [greedy_p]
+@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.
A guardian protects a set of objects from garbage collection,
allowing a program to apply cleanup or other actions.
@end deffn
\fguardian-destroyed?
-@deffn primitive guardian-destroyed? guardian
+@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?
-@deffn primitive guardian-greedy? guardian
+@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!
-@deffn primitive destroy-guardian! 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
objects in it or get any objects from it. It also unguards any
objects guarded by @var{guardian}.
@end deffn
\fhashq
-@deffn primitive hashq key size
+@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
lookups in a hashtable of size @var{size}, where @code{eq?} is
used as the equality predicate. The function returns an
@end deffn
\fhashv
-@deffn primitive hashv key size
+@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
lookups in a hashtable of size @var{size}, where @code{eqv?} is
used as the equality predicate. The function returns an
@end deffn
\fhash
-@deffn primitive hash key size
+@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
lookups in a hashtable of size @var{size}, where @code{equal?}
is used as the equality predicate. The function returns an
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
-@deffn primitive hashq-get-handle table key
+@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
hash table @var{table}. If @var{table} does not hold an
associated value for @var{key}, @code{#f} is returned.
@end deffn
\fhashq-create-handle!
-@deffn primitive hashq-create-handle! table key init
+@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.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
@end deffn
\fhashq-ref
-@deffn primitive hashq-ref table key [dflt]
+@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
value (if any) associated with it. If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument
@end deffn
\fhashq-set!
-@deffn primitive hashq-set! table key val
+@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
store @var{value} there. Uses @code{eq?} for equality testing.
@end deffn
\fhashq-remove!
-@deffn primitive hashq-remove! table key
+@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
@var{table}. Uses @code{eq?} for equality tests.
@end deffn
\fhashv-get-handle
-@deffn primitive hashv-get-handle table key
+@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
hash table @var{table}. If @var{table} does not hold an
associated value for @var{key}, @code{#f} is returned.
@end deffn
\fhashv-create-handle!
-@deffn primitive hashv-create-handle! table key init
+@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.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
@end deffn
\fhashv-ref
-@deffn primitive hashv-ref table key [dflt]
+@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
value (if any) associated with it. If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument
@end deffn
\fhashv-set!
-@deffn primitive hashv-set! table key val
+@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
store @var{value} there. Uses @code{eqv?} for equality testing.
@end deffn
\fhashv-remove!
-@deffn primitive hashv-remove! table key
+@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
@var{table}. Uses @code{eqv?} for equality tests.
@end deffn
\fhash-get-handle
-@deffn primitive hash-get-handle table key
+@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
hash table @var{table}. If @var{table} does not hold an
associated value for @var{key}, @code{#f} is returned.
@end deffn
\fhash-create-handle!
-@deffn primitive hash-create-handle! table key init
+@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.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
@end deffn
\fhash-ref
-@deffn primitive hash-ref table key [dflt]
+@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
value (if any) associated with it. If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument
@end deffn
\fhash-set!
-@deffn primitive hash-set! table key val
+@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
store @var{value} there. Uses @code{equal?} for equality
testing.
@end deffn
\fhash-remove!
-@deffn primitive hash-remove! table key
+@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
@var{table}. Uses @code{equal?} for equality tests.
@end deffn
\fhashx-get-handle
-@deffn primitive hashx-get-handle hash assoc table key
+@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
@code{-get-handle} function, but uses @var{hash} as a hash
function and @var{assoc} to compare keys. @code{hash} must be
@end deffn
\fhashx-create-handle!
-@deffn primitive hashx-create-handle! hash assoc table key init
+@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
@code{-create-handle} function, but uses @var{hash} as a hash
function and @var{assoc} to compare keys. @code{hash} must be
@end deffn
\fhashx-ref
-@deffn primitive hashx-ref hash assoc table key [dflt]
+@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}
function, but uses @var{hash} as a hash function and
@var{assoc} to compare keys. @code{hash} must be a function
@end deffn
\fhashx-set!
-@deffn primitive hashx-set! hash assoc table key val
+@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!}
function, but uses @var{hash} as a hash function and
@var{assoc} to compare keys. @code{hash} must be a function
@end deffn
\fhash-fold
-@deffn primitive hash-fold proc init table
+@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.
Accumulates and returns a result by applying PROC successively.
The arguments to PROC are "(key value prior-result)" where key
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
-@deffn primitive make-hook [n_args]
+@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}.
@var{n_args} defaults to zero. The returned value is a hook
object to be used with the other hook procedures.
@end deffn
\fhook?
-@deffn primitive hook? x
+@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?
-@deffn primitive hook-empty? hook
+@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}
otherwise.
@end deffn
\fadd-hook!
-@deffn primitive add-hook! hook proc [append_p]
+@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
procedure is added to the end if @var{append_p} is true,
otherwise it is added to the front. The return value of this
@end deffn
\fremove-hook!
-@deffn primitive remove-hook! hook proc
+@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
return value of this procedure is not specified.
@end deffn
\freset-hook!
-@deffn primitive reset-hook! 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
value of this procedure is not specified.
@end deffn
\frun-hook
-@deffn primitive run-hook hook . args
+@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
@var{args}. The order of the procedure application is first to
last. The return value of this procedure is not specified.
@end deffn
\fhook->list
-@deffn primitive hook->list hook
+@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
+\fgettext
+@c snarfed from i18n.c:90
+@deffn {Scheme Procedure} gettext msgid [domain [category]]
+@deffnx {C Function} scm_gettext (msgid, domain, category)
+Return the translation of @var{msgid} in the message domain @var{domain}. @var{domain} is optional and defaults to the domain set through (textdomain). @var{category} is optional and defaults to LC_MESSAGES.
+@end deffn
+
+\fngettext
+@c snarfed from i18n.c:146
+@deffn {Scheme Procedure} ngettext msgid msgid_plural n [domain [category]]
+@deffnx {C Function} scm_ngettext (msgid, msgid_plural, n, domain, category)
+Return the translation of @var{msgid}/@var{msgid_plural} in the message domain @var{domain}, with the plural form being chosen appropriately for the number @var{n}. @var{domain} is optional and defaults to the domain set through (textdomain). @var{category} is optional and defaults to LC_MESSAGES.
+@end deffn
+
+\ftextdomain
+@c snarfed from i18n.c:209
+@deffn {Scheme Procedure} textdomain [domainname]
+@deffnx {C Function} scm_textdomain (domainname)
+If optional parameter @var{domainname} is supplied, set the textdomain. Return the textdomain.
+@end deffn
+
+\fbindtextdomain
+@c snarfed from i18n.c:241
+@deffn {Scheme Procedure} bindtextdomain domainname [directory]
+@deffnx {C Function} scm_bindtextdomain (domainname, directory)
+If optional parameter @var{directory} is supplied, set message catalogs to directory @var{directory}. Return the directory bound to @var{domainname}.
+@end deffn
+
+\fbind-textdomain-codeset
+@c snarfed from i18n.c:280
+@deffn {Scheme Procedure} bind-textdomain-codeset domainname [encoding]
+@deffnx {C Function} scm_bind_textdomain_codeset (domainname, encoding)
+If optional parameter @var{encoding} is supplied, set encoding for message catalogs of @var{domainname}. Return the encoding of @var{domainname}.
+@end deffn
+
\fftell
-@deffn primitive ftell fd_port
+@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
@var{fd/port}, measured from the beginning. Equivalent to:
@end deffn
\fredirect-port
-@deffn primitive redirect-port old new
+@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
descriptor from @var{old-port} into @var{new-port}. The
current file descriptor in @var{new-port} will be closed.
@end deffn
\fdup->fdes
-@deffn primitive dup->fdes fd_or_port [fd]
+@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
designated by @var{fd_or_port}, which must be either an open
file port or a file descriptor.
@end deffn
\fdup2
-@deffn primitive dup2 oldfd newfd
+@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.
Copies the file descriptor @var{oldfd} to descriptor
number @var{newfd}, replacing the previous meaning
@end deffn
\ffileno
-@deffn primitive fileno port
+@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
not change its revealed count.
@end deffn
\fisatty?
-@deffn primitive isatty? port
+@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
device, otherwise @code{#f}.
@end deffn
\ffdopen
-@deffn primitive fdopen fdes modes
+@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}.
Modes are given by the string @var{modes}. The revealed count
of the port is initialized to zero. The modes string is the
@end deffn
\fprimitive-move->fdes
-@deffn primitive primitive-move->fdes port fd
+@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
value @var{fdes} without changing the revealed count of @var{port}.
Any other ports already using this descriptor will be automatically
@end deffn
\ffdes->ports
-@deffn primitive fdes->ports fd
+@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
underlying file descriptor, without changing their revealed
counts.
@end deffn
\fmake-keyword-from-dash-symbol
-@deffn primitive make-keyword-from-dash-symbol 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?
-@deffn primitive keyword? obj
+@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
@code{#f}.
@end deffn
\fkeyword-dash-symbol
-@deffn primitive keyword-dash-symbol keyword
+@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}.
This is the inverse of @code{make-keyword-from-dash-symbol}.
@end deffn
-\fnil-cons
-@deffn primitive nil-cons x y
-Create a new cons cell with @var{x} as the car and @var{y} as
-the cdr, but convert @var{y} to Scheme's end-of-list if it is
-a LISP nil.
-@end deffn
-
-\fnil-car
-@deffn primitive nil-car x
-Return the car of @var{x}, but convert it to LISP nil if it
-is Scheme's end-of-list.
-@end deffn
-
-\fnil-cdr
-@deffn primitive nil-cdr x
-Return the cdr of @var{x}, but convert it to LISP nil if it
-is Scheme's end-of-list.
-@end deffn
-
-\fnull
-@deffn primitive null x
-Return LISP's @code{t} if @var{x} is nil in the LISP sense,
-return LISP's nil otherwise.
-@end deffn
-
-\fnil-eq
-@deffn primitive nil-eq x y
-Compare @var{x} and @var{y} and return LISP's t if they are
-@code{eq?}, return LISP's nil otherwise.
-@end deffn
-
\flist
-@deffn primitive list . objs
+@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
@code{list}.
@end deffn
\fcons*
-@deffn primitive cons* arg . rest
+@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
constructed list, returning @code{(cons @var{arg1} (cons
@var{arg2} (cons @dots{} @var{argn})))}. Requires at least one
@end deffn
\fnull?
-@deffn primitive null? x
+@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?
-@deffn primitive list? x
+@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
-@deffn primitive length lst
+@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
-@deffn primitive append . args
+@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
arguments.
@lisp
@end deffn
\fappend!
-@deffn primitive append! . lists
+@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
-@deffn primitive last-pair lst
-Return a pointer to the last pair in @var{lst}, signalling an error if
+@c snarfed from list.c:291
+@deffn {Scheme Procedure} last-pair lst
+@deffnx {C Function} scm_last_pair (lst)
+Return the last pair in @var{lst}, signalling an error if
@var{lst} is circular.
@end deffn
\freverse
-@deffn primitive reverse lst
+@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
in reverse order.
@end deffn
\freverse!
-@deffn primitive reverse! lst [new_tail]
+@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
-@deffn primitive list-ref list k
+@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!
-@deffn primitive list-set! list k val
+@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
-@deffn primitive list-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
-@deffn primitive list-tail lst k
-@deffnx primitive list-cdr-ref lst k
+@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)
Return the "tail" of @var{lst} beginning with its @var{k}th element.
The first element of the list is considered to be element 0.
@end deffn
\flist-cdr-set!
-@deffn primitive list-cdr-set! list k val
+@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
-@deffn primitive list-head lst k
+@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
return it.
@end deffn
\flist-copy
-@deffn primitive list-copy lst
+@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
-@deffn primitive memq x lst
+@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?}
to @var{x} where the sublists of @var{lst} are the non-empty
lists returned by @code{(list-tail @var{lst} @var{k})} for
@end deffn
\fmemv
-@deffn primitive memv x lst
+@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?}
to @var{x} where the sublists of @var{lst} are the non-empty
lists returned by @code{(list-tail @var{lst} @var{k})} for
@end deffn
\fmember
-@deffn primitive member x lst
+@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
@code{equal?} to @var{x} where the sublists of @var{lst} are
the non-empty lists returned by @code{(list-tail @var{lst}
@end deffn
\fdelq!
-@deffn primitive delq! item lst
-@deffnx primitive delv! item lst
-@deffnx primitive delete! item lst
+@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!
-@deffn primitive delv! item lst
+@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
@code{eqv?} to @var{item}.
@end deffn
\fdelete!
-@deffn primitive delete! item lst
+@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
@code{equal?} to @var{item}.
@end deffn
\fdelq
-@deffn primitive delq item lst
+@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
@code{eq?} to @var{item} removed. This procedure mirrors
@code{memq}: @code{delq} compares elements of @var{lst} against
@end deffn
\fdelv
-@deffn primitive delv item lst
+@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
@code{eqv?} to @var{item} removed. This procedure mirrors
@code{memv}: @code{delv} compares elements of @var{lst} against
@end deffn
\fdelete
-@deffn primitive delete item lst
+@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
@code{equal?} to @var{item} removed. This procedure mirrors
@code{member}: @code{delete} compares elements of @var{lst}
@end deffn
\fdelq1!
-@deffn primitive delq1! item lst
+@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
@var{item} from @var{lst}. Tests for equality using
@code{eq?}. See also @code{delv1!} and @code{delete1!}.
@end deffn
\fdelv1!
-@deffn primitive delv1! item lst
+@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
@var{item} from @var{lst}. Tests for equality using
@code{eqv?}. See also @code{delq1!} and @code{delete1!}.
@end deffn
\fdelete1!
-@deffn primitive delete1! item lst
+@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
@var{item} from @var{lst}. Tests for equality using
@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
-@deffn primitive primitive-load filename
+@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
the top-level environment. The load paths are not searched;
@var{filename} must either be a full pathname or be a pathname
@end deffn
\f%package-data-dir
-@deffn primitive %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
libraries are kept. On most Unix systems, this will be
@samp{/usr/local/share/guile}.
@end deffn
\f%library-dir
-@deffn primitive %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.
E.g., may return "/usr/share/guile/1.3.5".
@end deffn
\f%site-dir
-@deffn primitive %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.
E.g., may return "/usr/share/guile/site".
@end deffn
\fparse-path
-@deffn primitive parse-path path [tail]
+@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
string, into a list and return the resulting list with
@var{tail} appended. If @var{path} is @code{#f}, @var{tail}
@end deffn
\fsearch-path
-@deffn primitive search-path path filename [extensions]
+@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
@var{filename}. The file must be readable, and not a directory.
If we find one, return its full filename; otherwise, return
@end deffn
\f%search-load-path
-@deffn primitive %search-load-path filename
+@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},
which must be readable by the current user. If @var{filename}
is found in the list of paths to search or is an absolute
@end deffn
\fprimitive-load-path
-@deffn primitive primitive-load-path filename
+@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
load it into the top-level environment. If @var{filename} is a
relative pathname and is not found in the list of search paths,
an error is signalled.
@end deffn
-\fprocedure->syntax
-@deffn primitive procedure->syntax code
+\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
-appears as the first symbol in an expression, returns the
+appears as the first symbol in an expression, evaluates the
result of applying @var{code} to the expression and the
environment.
+
+@code{procedure->memoizing-macro} is the same as
+@code{procedure->macro}, except that the expression returned by
+@var{code} replaces the original macro expression in the memoized
+form of the containing code.
@end deffn
-\fprocedure->macro
-@deffn primitive procedure->macro code
+\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, evaluates the
+appears as the first symbol in an expression, returns the
result of applying @var{code} to the expression and the
-environment. The value returned from @var{code} which has been
-passed to @code{procedure->memoizing-macro} replaces the form
-passed to @var{code}. 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
+environment.
@end deffn
-\fprocedure->memoizing-macro
-@deffn primitive procedure->memoizing-macro code
+\fprocedure->macro
+@c snarfed from macros.c:146
+@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{proc} to the expression and the
-environment. The value returned from @var{proc} which has been
-passed to @code{procedure->memoizing-macro} replaces the form
-passed to @var{proc}. For example:
+result of applying @var{code} to the expression and the
+environment. For example:
@lisp
(define trace
@end deffn
\fmacro?
-@deffn primitive macro? obj
+@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
syntax transformer.
@end deffn
\fmacro-type
-@deffn primitive macro-type m
+@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
@code{macro!}, depending on whether @var{m} is a syntax
-tranformer, a regular macro, or a memoizing macro,
+transformer, a regular macro, or a memoizing macro,
respectively. If @var{m} is not a macro, @code{#f} is
returned.
@end deffn
\fmacro-name
-@deffn primitive macro-name m
+@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
-@deffn primitive macro-transformer m
+@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
-@deffn primitive current-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
-@deffn primitive set-current-module 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
the previous current module.
@end deffn
\finteraction-environment
-@deffn primitive interaction-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
implementation--defined bindings, typically a superset of those
listed in the report. The intent is that this procedure will
@end deffn
\fenv-module
-@deffn primitive env-module env
+@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
-@deffn primitive standard-eval-closure module
+@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
-@deffn primitive standard-interface-eval-closure module
+@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
-@deffn primitive %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?
-@deffn primitive exact? x
+@c snarfed from numbers.c:460
+@deffn {Scheme Procedure} exact? x
+@deffnx {C Function} scm_exact_p (x)
Return @code{#t} if @var{x} is an exact number, @code{#f}
otherwise.
@end deffn
\fodd?
-@deffn primitive odd? n
+@c snarfed from numbers.c:479
+@deffn {Scheme Procedure} odd? n
+@deffnx {C Function} scm_odd_p (n)
Return @code{#t} if @var{n} is an odd number, @code{#f}
otherwise.
@end deffn
\feven?
-@deffn primitive even? n
+@c snarfed from numbers.c:514
+@deffn {Scheme Procedure} even? n
+@deffnx {C Function} scm_even_p (n)
Return @code{#t} if @var{n} is an even number, @code{#f}
otherwise.
@end deffn
+\finf?
+@c snarfed from numbers.c:548
+@deffn {Scheme Procedure} inf? x
+@deffnx {C Function} scm_inf_p (x)
+Return @code{#t} if @var{x} is either @samp{+inf.0}
+or @samp{-inf.0}, @code{#f} otherwise.
+@end deffn
+
+\fnan?
+@c snarfed from numbers.c:564
+@deffn {Scheme Procedure} nan? n
+@deffnx {C Function} scm_nan_p (n)
+Return @code{#t} if @var{n} is a NaN, @code{#f}
+otherwise.
+@end deffn
+
+\finf
+@c snarfed from numbers.c:634
+@deffn {Scheme Procedure} inf
+@deffnx {C Function} scm_inf ()
+Return Inf.
+@end deffn
+
+\fnan
+@c snarfed from numbers.c:649
+@deffn {Scheme Procedure} nan
+@deffnx {C Function} scm_nan ()
+Return NaN.
+@end deffn
+
+\fabs
+@c snarfed from numbers.c:665
+@deffn {Scheme Procedure} abs x
+@deffnx {C Function} scm_abs (x)
+Return the absolute value of @var{x}.
+@end deffn
+
\flogand
-@deffn primitive logand n1 n2
+@c snarfed from numbers.c:1200
+@deffn {Scheme Procedure} logand n1 n2
Return the bitwise AND of the integer arguments.
@lisp
@end deffn
\flogior
-@deffn primitive logior n1 n2
+@c snarfed from numbers.c:1276
+@deffn {Scheme Procedure} logior n1 n2
Return the bitwise OR of the integer arguments.
@lisp
@end deffn
\flogxor
-@deffn primitive logxor n1 n2
+@c snarfed from numbers.c:1352
+@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.
@lisp
@end deffn
\flogtest
-@deffn primitive logtest j k
+@c snarfed from numbers.c:1423
+@deffn {Scheme Procedure} logtest j k
+@deffnx {C Function} scm_logtest (j, k)
@lisp
(logtest j k) @equiv{} (not (zero? (logand j k)))
@end deffn
\flogbit?
-@deffn primitive logbit? index j
+@c snarfed from numbers.c:1494
+@deffn {Scheme Procedure} logbit? index j
+@deffnx {C Function} scm_logbit_p (index, j)
@lisp
(logbit? index j) @equiv{} (logtest (integer-expt 2 index) j)
@end deffn
\flognot
-@deffn primitive lognot n
-Return the integer which is the 2s-complement of the integer
+@c snarfed from numbers.c:1528
+@deffn {Scheme Procedure} lognot n
+@deffnx {C Function} scm_lognot (n)
+Return the integer which is the ones-complement of the integer
argument.
@lisp
@end lisp
@end deffn
+\fmodulo-expt
+@c snarfed from numbers.c:1573
+@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
-@deffn primitive integer-expt n k
-Return @var{n} raised to the non-negative integer exponent
+@c snarfed from numbers.c:1678
+@deffn {Scheme Procedure} integer-expt n k
+@deffnx {C Function} scm_integer_expt (n, k)
+Return @var{n} raised to the exact integer exponent
@var{k}.
@lisp
@end deffn
\fash
-@deffn primitive 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.
-
-Formally, the function returns an integer equivalent to
-@code{(inexact->exact (floor (* @var{n} (expt 2 @var{cnt}))))}.
+@c snarfed from numbers.c:1768
+@deffn {Scheme Procedure} ash n cnt
+@deffnx {C Function} scm_ash (n, cnt)
+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.)
+
+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
-@deffn primitive bit-extract n start end
+@c snarfed from numbers.c:1808
+@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)
through @var{end} (exclusive) bits of @var{n}. The
@var{start}th bit becomes the 0-th bit in the result.
@end deffn
\flogcount
-@deffn primitive logcount n
+@c snarfed from numbers.c:1887
+@deffn {Scheme Procedure} logcount n
+@deffnx {C Function} scm_logcount (n)
Return the number of bits in integer @var{n}. If integer is
positive, the 1-bits in its binary representation are counted.
If negative, the 0-bits in its two's-complement binary
@end deffn
\finteger-length
-@deffn primitive integer-length n
-Return the number of bits neccessary to represent @var{n}.
+@c snarfed from numbers.c:1935
+@deffn {Scheme Procedure} integer-length n
+@deffnx {C Function} scm_integer_length (n)
+Return the number of bits necessary to represent @var{n}.
@lisp
(integer-length #b10101010)
@end deffn
\fnumber->string
-@deffn primitive number->string n [radix]
+@c snarfed from numbers.c:2258
+@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
number @var{n} in the given @var{radix}. If @var{n} is
inexact, a radix of 10 will be used.
@end deffn
\fstring->number
-@deffn primitive string->number string [radix]
+@c snarfed from numbers.c:2941
+@deffn {Scheme Procedure} string->number string [radix]
+@deffnx {C Function} scm_string_to_number (string, radix)
Return a number of the maximally precise representation
expressed by the given @var{string}. @var{radix} must be an
exact integer, either 2, 8, 10, or 16. If supplied, @var{radix}
@end deffn
\fnumber?
-@deffn primitive number?
-implemented by the C function "scm_number_p"
+@c snarfed from numbers.c:3004
+@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?
-@deffn primitive complex? x
+@c snarfed from numbers.c:3017
+@deffn {Scheme Procedure} complex? x
+@deffnx {C Function} scm_complex_p (x)
Return @code{#t} if @var{x} is a complex number, @code{#f}
-else. Note that the sets of real, rational and integer
+otherwise. Note that the sets of real, rational and integer
values form subsets of the set of complex numbers, i. e. the
predicate will also be fulfilled if @var{x} is a real,
rational or integer number.
@end deffn
\freal?
-@deffn primitive real?
-implemented by the C function "scm_real_p"
+@c snarfed from numbers.c:3030
+@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?
-@deffn primitive rational? x
+@c snarfed from numbers.c:3043
+@deffn {Scheme Procedure} rational? x
+@deffnx {C Function} scm_rational_p (x)
Return @code{#t} if @var{x} is a rational number, @code{#f}
-else. Note that the set of integer values forms a subset of
+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?
-@deffn primitive integer? x
+@c snarfed from numbers.c:3066
+@deffn {Scheme Procedure} integer? x
+@deffnx {C Function} scm_integer_p (x)
Return @code{#t} if @var{x} is an integer number, @code{#f}
else.
@end deffn
\finexact?
-@deffn primitive inexact? x
+@c snarfed from numbers.c:3092
+@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:4939
+@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:4955
+@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:4981
+@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:5012
+@deffn {Scheme Procedure} ceiling x
+@deffnx {C Function} scm_ceiling (x)
+Round the number @var{x} towards infinity.
+@end deffn
+
\f$expt
-@deffn primitive $expt x y
+@c snarfed from numbers.c:5121
+@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
procedure does not accept complex arguments.
@end deffn
\f$atan2
-@deffn primitive $atan2 x y
+@c snarfed from numbers.c:5137
+@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
@var{y}. This is similar to calculating the arc tangent of
@var{x} / @var{y}, except that the signs of both arguments
@end deffn
\fmake-rectangular
-@deffn primitive make-rectangular real imaginary
+@c snarfed from numbers.c:5165
+@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
@var{imaginary} parts.
@end deffn
\fmake-polar
-@deffn primitive make-polar x y
+@c snarfed from numbers.c:5189
+@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
-@deffn primitive inexact->exact z
+@c snarfed from numbers.c:5392
+@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:5429
+@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
-@deffn primitive class-of x
+@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?
-@deffn primitive entity? obj
+@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?
-@deffn primitive operator? obj
+@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?
-@deffn primitive valid-object-procedure? proc
+@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!
-@deffn primitive set-object-procedure! obj proc
+@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}.
@var{obj} must be either an entity or an operator.
@end deffn
\fmake-class-object
-@deffn primitive make-class-object metaclass layout
+@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
slot layout specified by @var{layout}.
@end deffn
\fmake-subclass-object
-@deffn primitive make-subclass-object class layout
+@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
specified by @var{layout}.
@end deffn
\fobject-properties
-@deffn primitive object-properties obj
-@deffnx primitive procedure-properties obj
+@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!
-@deffn primitive set-object-properties! obj alist
-@deffnx primitive set-procedure-properties! obj alist
+@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
-@deffn primitive object-property obj key
-@deffnx primitive procedure-property obj key
+@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!
-@deffn primitive set-object-property! obj key value
-@deffnx primitive set-procedure-property! obj key value
+@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}
to @var{value}.
@end deffn
\fcons
-@deffn primitive cons x y
+@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
cdr is @var{y}. The pair is guaranteed to be different (in the
sense of @code{eq?}) from every previously existing object.
@end deffn
\fpair?
-@deffn primitive pair? x
+@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
@code{#f}.
@end deffn
\fset-car!
-@deffn primitive set-car! pair value
+@c snarfed from pairs.c:120
+@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
by @code{set-car!} is unspecified.
@end deffn
\fset-cdr!
-@deffn primitive set-cdr! pair value
+@c snarfed from pairs.c:133
+@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
by @code{set-cdr!} is unspecified.
@end deffn
\fchar-ready?
-@deffn primitive char-ready? [port]
+@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}
and return @code{#f} otherwise. If @code{char-ready?} returns
@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
-@deffn primitive drain-input port
+@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
to the way that force-output clears the output buffer. The
contents of the buffers are returned as a single string, e.g.,
@end deffn
\fcurrent-input-port
-@deffn primitive current-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
by many input procedures. Initially, @code{current-input-port}
returns the @dfn{standard input} in Unix and C terminology.
@end deffn
\fcurrent-output-port
-@deffn primitive current-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
by many output procedures. Initially,
@code{current-output-port} returns the @dfn{standard output} in
@end deffn
\fcurrent-error-port
-@deffn primitive current-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
@dfn{standard error} in Unix and C terminology).
@end deffn
\fcurrent-load-port
-@deffn primitive current-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.
The load port is used internally by @code{primitive-load}.
@end deffn
\fset-current-input-port
-@deffn primitive set-current-input-port port
-@deffnx primitive set-current-output-port port
-@deffnx primitive set-current-error-port 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
+@deffnx {C Function} scm_set_current_input_port (port)
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
@end deffn
\fset-current-output-port
-@deffn primitive set-current-output-port 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
-@deffn primitive set-current-error-port 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
-@deffn primitive port-revealed port
+@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!
-@deffn primitive set-port-revealed! port rcount
+@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.
The return value is unspecified.
@end deffn
\fport-mode
-@deffn primitive port-mode port
+@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}.
These will not necessarily be identical to the modes used when
the port was opened, since modes such as "append" which are
@end deffn
\fclose-port
-@deffn primitive close-port 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
successfully closes a port or @code{#f} if it was already
closed. An exception may be raised if an error occurs, for
@end deffn
\fclose-input-port
-@deffn primitive close-input-port 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
the file has already been closed. An exception may be raised if an
error occurs. The value returned is unspecified.
@end deffn
\fclose-output-port
-@deffn primitive close-output-port 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
the file has already been closed. An exception may be raised if an
error occurs. The value returned is unspecified.
@end deffn
\fport-for-each
-@deffn primitive port-for-each proc
+@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
in turn. The return value is unspecified. More specifically,
@var{proc} is applied exactly once to every port that exists
@end deffn
\finput-port?
-@deffn primitive input-port? x
+@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
@code{#f}. Any object satisfying this predicate also satisfies
@code{port?}.
@end deffn
\foutput-port?
-@deffn primitive output-port? x
+@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
@code{#f}. Any object satisfying this predicate also satisfies
@code{port?}.
@end deffn
\fport?
-@deffn primitive port? x
+@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.
Equivalent to @code{(or (input-port? @var{x}) (output-port?
@var{x}))}.
@end deffn
\fport-closed?
-@deffn primitive port-closed? port
+@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
open.
@end deffn
\feof-object?
-@deffn primitive eof-object? x
+@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
return @code{#f}.
@end deffn
\fforce-output
-@deffn primitive force-output [port]
+@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}
is omitted. The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
@end deffn
\fflush-all-ports
-@deffn primitive flush-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
all open output ports. The return value is unspecified.
@end deffn
\fread-char
-@deffn primitive read-char [port]
+@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
@var{port} to point to the following character. If no more
characters are available, the end-of-file object is returned.
@end deffn
\fpeek-char
-@deffn primitive peek-char [port]
+@c snarfed from ports.c:1297
+@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
-@deffn primitive unread-char cobj [port]
+@c snarfed from ports.c:1320
+@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
next read operation. If called multiple times, the unread characters
will be read again in last-in first-out order. If @var{port} is
@end deffn
\funread-string
-@deffn primitive unread-string str port
+@c snarfed from ports.c:1343
+@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
read in subsequent read operations. If called multiple times, the
unread characters will be read again in last-in first-out order. If
@end deffn
\fseek
-@deffn primitive seek fd_port offset whence
+@c snarfed from ports.c:1382
+@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
@var{offset}, which is interpreted according to the value of
@var{whence}.
@end deffn
\ftruncate-file
-@deffn primitive truncate-file object [length]
+@c snarfed from ports.c:1440
+@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
-@deffn primitive port-line port
+@c snarfed from ports.c:1500
+@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!
-@deffn primitive set-port-line! port line
-Set the current line number for @var{port} to @var{line}.
+@c snarfed from ports.c:1512
+@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}. The
+first line of a file is 0.
@end deffn
\fport-column
-@deffn primitive port-column port
-@deffnx primitive port-line 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
+@c snarfed from ports.c:1531
+@deffn {Scheme Procedure} port-column port
+@deffnx {C Function} scm_port_column (port)
+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!
-@deffn primitive set-port-column! port column
-@deffnx primitive set-port-line! port line
-Set the current column or line number of @var{port}, using the
-current input port if none is specified.
+@c snarfed from ports.c:1543
+@deffn {Scheme Procedure} set-port-column! port column
+@deffnx {C Function} scm_set_port_column_x (port, column)
+Set the current column of @var{port}. Before reading the first
+character on a line the column should be 0.
@end deffn
\fport-filename
-@deffn primitive port-filename port
+@c snarfed from ports.c:1557
+@deffn {Scheme Procedure} port-filename port
+@deffnx {C Function} scm_port_filename (port)
Return the filename associated with @var{port}. This function returns
the strings "standard input", "standard output" and "standard error"
when called on the current input, output and error ports respectively.
@end deffn
\fset-port-filename!
-@deffn primitive set-port-filename! port filename
+@c snarfed from ports.c:1571
+@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
port if none is specified. Note that this does not change the port's
source of data, but only the value that is returned by
@end deffn
\f%make-void-port
-@deffn primitive %make-void-port mode
+@c snarfed from ports.c:1665
+@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
-/dev/null. The @var{mode} argument
+@file{/dev/null}. The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
@end deffn
\fprint-options-interface
-@deffn primitive print-options-interface [setting]
+@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
this procedure directly, use the procedures
@code{print-enable}, @code{print-disable}, @code{print-set!}
@end deffn
\fsimple-format
-@deffn primitive simple-format destination message . args
+@c snarfed from print.c:932
+@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
the current output port.
@var{message} can contain @code{~A} (was @code{%s}) and
@end deffn
\fnewline
-@deffn primitive newline [port]
+@c snarfed from print.c:1022
+@deffn {Scheme Procedure} newline [port]
+@deffnx {C Function} scm_newline (port)
Send a newline to @var{port}.
+If @var{port} is omitted, send to the current output port.
@end deffn
\fwrite-char
-@deffn primitive write-char chr [port]
+@c snarfed from print.c:1037
+@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 primitive port-with-print-state port pstate
+@c snarfed from print.c:1091
+@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
-@deffn primitive get-print-state port
+@c snarfed from print.c:1104
+@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}
has no associated print state, @code{#f} is returned.
@end deffn
\fprocedure-properties
-@deffn primitive procedure-properties proc
+@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!
-@deffn primitive set-procedure-properties! proc new_val
+@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
-@deffn primitive procedure-property p k
+@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!
-@deffn primitive set-procedure-property! p k v
+@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
@var{value}.
@end deffn
\fprocedure?
-@deffn primitive procedure? obj
+@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?
-@deffn primitive closure? obj
+@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?
-@deffn primitive thunk? obj
+@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
-@deffn primitive procedure-documentation proc
+@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
convention, if a procedure contains more than one expression and the
first expression is a string constant, that string is assumed to contain
@end deffn
\fprocedure-with-setter?
-@deffn primitive procedure-with-setter? obj
+@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
associated setter procedure.
@end deffn
\fmake-procedure-with-setter
-@deffn primitive make-procedure-with-setter procedure 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
with the associated setter @var{setter}.
@end deffn
\fprocedure
-@deffn primitive procedure proc
+@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
procedure with setter, or an operator struct.
@end deffn
\fprimitive-make-property
-@deffn primitive primitive-make-property not_found_proc
+@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
@code{primitive-property-ref} and @code{primitive-property-set!}.
See @code{primitive-property-ref} for the significance of
@end deffn
\fprimitive-property-ref
-@deffn primitive 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}.
+@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}, 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!
-@deffn primitive primitive-property-set! prop obj val
-Associate @var{code} with @var{prop} and @var{obj}.
+@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)
+Set the property @var{prop} of @var{obj} to @var{val}.
@end deffn
\fprimitive-property-del!
-@deffn primitive primitive-property-del! prop obj
+@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
-@deffn primitive random n [state]
-Return a number in [0,N).
+@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).
Accepts a positive integer or real n and returns a
number of the same type between zero (inclusive) and
@end deffn
\fcopy-random-state
-@deffn primitive copy-random-state [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
-@deffn primitive seed->random-state seed
+@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
-@deffn primitive random:uniform [state]
+@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
[0,1).
@end deffn
\frandom:normal
-@deffn primitive random:normal [state]
+@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
distribution used has mean 0 and standard deviation 1. For a
normal distribution with mean m and standard deviation d use
@end deffn
\frandom:solid-sphere!
-@deffn primitive random:solid-sphere! v [state]
+@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
the sum of whose squares is less than 1.0.
Thinking of vect as coordinates in space of
@end deffn
\frandom:hollow-sphere!
-@deffn primitive random:hollow-sphere! v [state]
+@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
the sum of whose squares is equal to 1.0.
Thinking of vect as coordinates in space of
@end deffn
\frandom:normal-vector!
-@deffn primitive random:normal-vector! v [state]
+@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
independent and standard normally distributed
(i.e., with mean 0 and variance 1).
@end deffn
\frandom:exp
-@deffn primitive random:exp [state]
+@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
1. For an exponential distribution with mean u use (* u
(random:exp)).
@end deffn
\f%read-delimited!
-@deffn primitive %read-delimited! delims str gobble [port [start [end]]]
+@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
characters in the @var{delims} string is encountered. If
@var{gobble} is true, discard the delimiter character;
@end deffn
\f%read-line
-@deffn primitive %read-line [port]
+@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
necessary. The newline terminator (if any) is removed from the string,
and a pair consisting of the line and its delimiter is returned. The
@end deffn
\fwrite-line
-@deffn primitive write-line obj [port]
+@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
@var{port} is not specified, @code{(current-output-port)} is
used. This function is equivalent to:
@end deffn
\fread-options-interface
-@deffn primitive read-options-interface [setting]
+@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
this procedure directly, use the procedures @code{read-enable},
-@code{read-disable}, @code{read-set!} and @var{read-options}.
+@code{read-disable}, @code{read-set!} and @code{read-options}.
@end deffn
\fread
-@deffn primitive read [port]
+@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
the current input port if @var{port} is not specified.
Any whitespace before the next token is discarded.
@end deffn
\fread-hash-extend
-@deffn primitive read-hash-extend chr proc
+@c snarfed from read.c:868
+@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
starting with the character sequence @code{#} and @var{chr}.
@var{proc} will be called with two arguments: the character
@end deffn
\fcall-with-dynamic-root
-@deffn primitive call-with-dynamic-root thunk handler
+@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.
If an error occurs during evaluation, apply @var{handler} to the
@end deffn
\fdynamic-root
-@deffn primitive dynamic-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.
These objects are only useful for comparison using @code{eq?}.
@end deffn
\fread-string!/partial
-@deffn primitive read-string!/partial str [port_or_fdes [start [end]]]
+@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
string @var{str}. A port must have an underlying file
descriptor --- a so-called fport. This procedure is
@end deffn
\fwrite-string/partial
-@deffn primitive write-string/partial str [port_or_fdes [start [end]]]
+@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
descriptor. A port must have an underlying file descriptor
--- a so-called fport. This procedure is
@end deffn
\fsigaction
-@deffn primitive sigaction signum [handler [flags]]
+@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.
@var{signum} is the signal number, which can be specified using the value
of variables such as @code{SIGINT}.
-If @var{action} is omitted, @code{sigaction} returns a pair: the
+If @var{handler} is omitted, @code{sigaction} returns a pair: the
CAR is the current
signal hander, which will be either an integer with the value @code{SIG_DFL}
(default action) or @code{SIG_IGN} (ignore), or the Scheme procedure which
handles the signal, or @code{#f} if a non-Scheme procedure handles the
signal. The CDR contains the current @code{sigaction} flags for the handler.
-If @var{action} is provided, it is installed as the new handler for
-@var{signum}. @var{action} can be a Scheme procedure taking one
+If @var{handler} is provided, it is installed as the new handler for
+@var{signum}. @var{handler} can be a Scheme procedure taking one
argument, or the value of @code{SIG_DFL} (default action) or
@code{SIG_IGN} (ignore), or @code{#f} to restore whatever signal handler
-was installed before @code{sigaction} was first used. Flags can
-optionally be specified for the new handler (@code{SA_RESTART} will
+was installed before @code{sigaction} was first used. When
+a scheme procedure has been specified, that procedure will run
+in the given @var{thread}. When no thread has been given, the
+thread that made this call to @code{sigaction} is used.
+Flags can optionally be specified for the new handler (@code{SA_RESTART} will
always be added if it's available and the system is using restartable
system calls.) The return value is a pair with information about the
old handler as described above.
@end deffn
\frestore-signals
-@deffn primitive restore-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
@code{sigaction} was made. The return value is unspecified.
@end deffn
\falarm
-@deffn primitive alarm i
+@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
number of seconds (an integer). It's advisable to install a signal
handler for
@end deffn
\fsetitimer
-@deffn primitive setitimer which_timer interval_seconds interval_microseconds value_seconds value_microseconds
+@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
@var{interval_seconds}, @var{interval_microseconds},
@var{value_seconds}, and @var{value_microseconds} values.
@end deffn
\fgetitimer
-@deffn primitive getitimer which_timer
+@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}
Errors are handled as described in the guile info pages under ``POSIX
Interface Conventions''.
@end deffn
\fpause
-@deffn primitive pause
+@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
action is to either terminate the current process or invoke a
handler procedure. The return value is unspecified.
@end deffn
\fsleep
-@deffn primitive sleep i
+@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
arrives. The return value is zero if the time elapses or the number
of seconds remaining otherwise.
@end deffn
\fusleep
-@deffn primitive usleep i
-Sleep for I microseconds. @code{usleep} is not available on
-all platforms.
+@c snarfed from scmsigs.c:610
+@deffn {Scheme Procedure} usleep i
+@deffnx {C Function} scm_usleep (i)
+Sleep for @var{i} microseconds.
@end deffn
\fraise
-@deffn primitive raise sig
+@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
@var{sig} is as described for the kill procedure.
@end deffn
\fsystem
-@deffn primitive system [cmd]
+@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
-@deffn primitive getenv nam
+@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
value is @code{#f} unless a string of the form @code{NAME=VALUE} is
found, in which case the string @code{VALUE} is returned.
@end deffn
\fprimitive-exit
-@deffn primitive primitive-exit [status]
+@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.
This is would typically be useful after a fork. The exit status
is @var{status} if supplied, otherwise zero.
@end deffn
\frestricted-vector-sort!
-@deffn primitive restricted-vector-sort! vec less startpos endpos
+@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
the vector elements. @var{startpos} and @var{endpos} delimit
the range of the vector which gets sorted. The return value
@end deffn
\fsorted?
-@deffn primitive sorted? items less
+@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
for all 1 <= i <= m, the predicate @var{less} returns true when
applied to all elements i - 1 and i
@end deffn
\fmerge
-@deffn primitive merge alist blist less
-Takes two lists @var{alist} and @var{blist} such that
-@code{(sorted? alist less?)} and @code{(sorted? blist less?)} and
-returns a new list in which the elements of @var{alist} and
+@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.
+Given two lists @var{alist} and @var{blist}, such that
+@code{(sorted? alist less?)} and @code{(sorted? blist less?)},
+return a new list in which the elements of @var{alist} and
@var{blist} have been stably interleaved so that
@code{(sorted? (merge alist blist less?) less?)}.
Note: this does _not_ accept vectors.
@end deffn
\fmerge!
-@deffn primitive merge! alist blist less
+@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
@code{(sorted? alist less?)} and @code{(sorted? blist less?)} and
returns a new list in which the elements of @var{alist} and
@end deffn
\fsort!
-@deffn primitive sort! items less
+@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
vector. @var{less} is used for comparing the sequence
elements. The sorting is destructive, that means that the
@end deffn
\fsort
-@deffn primitive sort items less
+@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
vector. @var{less} is used for comparing the sequence
elements. This is not a stable sort.
@end deffn
\fstable-sort!
-@deffn primitive stable-sort! items less
+@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
vector. @var{less} is used for comparing the sequence elements.
The sorting is destructive, that means that the input sequence
@end deffn
\fstable-sort
-@deffn primitive stable-sort items less
+@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
vector. @var{less} is used for comparing the sequence elements.
This is a stable sort.
@end deffn
\fsort-list!
-@deffn primitive sort-list! items less
+@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
list elements. The sorting is destructive, that means that the
input list is modified to produce the sorted result.
@end deffn
\fsort-list
-@deffn primitive sort-list items less
+@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
list elements. This is a stable sort.
@end deffn
\fsource-properties
-@deffn primitive source-properties obj
+@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!
-@deffn primitive set-source-properties! obj plist
+@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
list for @var{obj}.
@end deffn
\fsource-property
-@deffn primitive source-property obj key
+@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
@var{obj}'s source property list.
@end deffn
\fset-source-property!
-@deffn primitive set-source-property! obj key datum
+@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
@var{key} to @var{datum}. Normally, the key will be a symbol.
@end deffn
\fstack?
-@deffn primitive stack? obj
+@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
-@deffn primitive make-stack obj . args
+@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
evaluation stack is used for creating the stack frames,
otherwise the frames are taken from @var{obj} (which must be
@end deffn
\fstack-id
-@deffn primitive stack-id stack
+@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
-@deffn primitive stack-ref stack index
+@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
-@deffn primitive stack-length stack
+@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?
-@deffn primitive frame? obj
+@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
-@deffn primitive last-stack-frame obj
+@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
last stack frame for @var{obj}. @var{obj} must be either a
debug object or a continuation.
@end deffn
\fframe-number
-@deffn primitive frame-number frame
+@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
-@deffn primitive frame-source frame
+@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
-@deffn primitive frame-procedure frame
+@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
procedure is associated with @var{frame}.
@end deffn
\fframe-arguments
-@deffn primitive frame-arguments frame
+@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
-@deffn primitive frame-previous frame
+@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
@var{frame} is the first frame in its stack.
@end deffn
\fframe-next
-@deffn primitive frame-next frame
+@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
@var{frame} is the last frame in its stack.
@end deffn
\fframe-real?
-@deffn primitive frame-real? frame
+@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?
-@deffn primitive frame-procedure? frame
+@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?
-@deffn primitive frame-evaluating-args? frame
+@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?
-@deffn primitive frame-overflow? frame
+@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
-@deffn primitive get-internal-real-time
+@c snarfed from stime.c:132
+@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
started.
@end deffn
\ftimes
-@deffn primitive times
+@c snarfed from stime.c:179
+@deffn {Scheme Procedure} times
+@deffnx {C Function} scm_times ()
Return an object with information about real and processor
time. The following procedures accept such an object as an
argument and return a selected component:
@end deffn
\fget-internal-run-time
-@deffn primitive get-internal-run-time
+@c snarfed from stime.c:211
+@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
interpreter. Both @emph{system} and @emph{user} time are
included but subprocesses are not.
@end deffn
\fcurrent-time
-@deffn primitive current-time
+@c snarfed from stime.c:228
+@deffn {Scheme Procedure} current-time
+@deffnx {C Function} scm_current_time ()
Return the number of seconds since 1970-01-01 00:00:00 UTC,
excluding leap seconds.
@end deffn
\fgettimeofday
-@deffn primitive gettimeofday
+@c snarfed from stime.c:247
+@deffn {Scheme Procedure} gettimeofday
+@deffnx {C Function} scm_gettimeofday ()
Return a pair containing the number of seconds and microseconds
since 1970-01-01 00:00:00 UTC, excluding leap seconds. Note:
whether true microsecond resolution is available depends on the
@end deffn
\flocaltime
-@deffn primitive localtime time [zone]
+@c snarfed from stime.c:363
+@deffn {Scheme Procedure} localtime time [zone]
+@deffnx {C Function} scm_localtime (time, zone)
Return an object representing the broken down components of
@var{time}, an integer like the one returned by
@code{current-time}. The time zone for the calculation is
@end deffn
\fgmtime
-@deffn primitive gmtime time
+@c snarfed from stime.c:448
+@deffn {Scheme Procedure} gmtime time
+@deffnx {C Function} scm_gmtime (time)
Return an object representing the broken down components of
@var{time}, an integer like the one returned by
@code{current-time}. The values are calculated for UTC.
@end deffn
\fmktime
-@deffn primitive mktime sbd_time [zone]
+@c snarfed from stime.c:526
+@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}
is an optional time zone specifier (otherwise the TZ environment variable
or the system default is used).
@end deffn
\ftzset
-@deffn primitive tzset
+@c snarfed from stime.c:611
+@deffn {Scheme Procedure} tzset
+@deffnx {C Function} scm_tzset ()
Initialize the timezone from the TZ environment variable
or the system default. It's not usually necessary to call this procedure
since it's done automatically by other procedures that depend on the
@end deffn
\fstrftime
-@deffn primitive strftime format stime
+@c snarfed from stime.c:628
+@deffn {Scheme Procedure} strftime format stime
+@deffnx {C Function} scm_strftime (format, stime)
Formats a time specification @var{time} using @var{template}. @var{time}
is an object with time components in the form returned by @code{localtime}
or @code{gmtime}. @var{template} is a string which can include formatting
@end deffn
\fstrptime
-@deffn primitive strptime format string
+@c snarfed from stime.c:726
+@deffn {Scheme Procedure} strptime format string
+@deffnx {C Function} scm_strptime (format, string)
Performs the reverse action to @code{strftime}, parsing
@var{string} according to the specification supplied in
@var{template}. The interpretation of month and day names is
@end deffn
\fstring?
-@deffn primitive string? obj
-Return @code{#t} iff @var{obj} is a string, else returns
-@code{#f}.
+@c snarfed from strings.c:526
+@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
-@deffn primitive list->string
+@c snarfed from strings.c:534
+@deffn {Scheme Procedure} list->string
implemented by the C function "scm_string"
@end deffn
\fstring
-@deffn primitive string . chrs
-@deffnx primitive list->string chrs
+@c snarfed from strings.c:540
+@deffn {Scheme Procedure} string . chrs
+@deffnx {Scheme Procedure} list->string chrs
+@deffnx {C Function} scm_string (chrs)
Return a newly allocated string composed of the arguments,
@var{chrs}.
@end deffn
\fmake-string
-@deffn primitive make-string k [chr]
+@c snarfed from strings.c:578
+@deffn {Scheme Procedure} make-string k [chr]
+@deffnx {C Function} scm_make_string (k, chr)
Return a newly allocated string of
length @var{k}. If @var{chr} is given, then all elements of
the string are initialized to @var{chr}, otherwise the contents
@end deffn
\fstring-length
-@deffn primitive string-length string
+@c snarfed from strings.c:604
+@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
-@deffn primitive string-ref str k
+@c snarfed from strings.c:623
+@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
indexing. @var{k} must be a valid index of @var{str}.
@end deffn
\fstring-set!
-@deffn primitive string-set! str k chr
+@c snarfed from strings.c:646
+@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
an unspecified value. @var{k} must be a valid index of
@var{str}.
@end deffn
\fsubstring
-@deffn primitive substring str start [end]
+@c snarfed from strings.c:682
+@deffn {Scheme Procedure} substring str start [end]
+@deffnx {C Function} scm_substring (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/read-only
+@c snarfed from strings.c:708
+@deffn {Scheme Procedure} substring/read-only str start [end]
+@deffnx {C Function} scm_substring_read_only (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}).
+
+The returned string is read-only.
+
+@end deffn
+
+\fsubstring/copy
+@c snarfed from strings.c:731
+@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).
0 <= @var{start} <= @var{end} <= (string-length @var{str}).
@end deffn
+\fsubstring/shared
+@c snarfed from strings.c:755
+@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
-@deffn primitive string-append . args
+@c snarfed from strings.c:774
+@deffn {Scheme Procedure} string-append . args
+@deffnx {C Function} scm_string_append (args)
Return a newly allocated string whose characters form the
concatenation of the given strings, @var{args}.
@end deffn
-\fstring-index
-@deffn primitive string-index str chr [frm [to]]
-Return the index of the first occurrence of @var{chr} in
-@var{str}. The optional integer arguments @var{frm} and
-@var{to} limit the search to a portion of the string. This
-procedure essentially implements the @code{index} or
-@code{strchr} functions from the C library.
-
+\fstring-null?
+@c snarfed from srfi-13.c:62
+@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
+@code{#f} otherwise.
@lisp
-(string-index "weiner" #\e)
-@result{} 1
+(string-null? "") @result{} #t
+y @result{} "foo"
+(string-null? y) @result{} #f
+@end lisp
+@end deffn
-(string-index "weiner" #\e 2)
-@result{} 4
+\fstring-any
+@c snarfed from srfi-13.c:90
+@deffn {Scheme Procedure} string-any char_pred s [start [end]]
+@deffnx {C Function} scm_string_any (char_pred, s, start, end)
+Check if the predicate @var{pred} is true for any character in
+the string @var{s}.
-(string-index "weiner" #\e 2 4)
-@result{} #f
-@end lisp
+Calls to @var{pred} are made from left to right across @var{s}.
+When it returns true (ie.@: non-@code{#f}), that return value
+is the return from @code{string-any}.
+
+The SRFI-13 specification requires that the call to @var{pred}
+on the last character of @var{s} (assuming that point is
+reached) be a tail call, but currently in Guile this is not the
+case.
@end deffn
-\fstring-rindex
-@deffn primitive string-rindex str chr [frm [to]]
-Like @code{string-index}, but search from the right of the
-string rather than from the left. This procedure essentially
-implements the @code{rindex} or @code{strrchr} functions from
-the C library.
+\fstring-every
+@c snarfed from srfi-13.c:153
+@deffn {Scheme Procedure} string-every char_pred s [start [end]]
+@deffnx {C Function} scm_string_every (char_pred, s, start, end)
+Check if the predicate @var{pred} is true for every character
+in the string @var{s}.
-@lisp
-(string-rindex "weiner" #\e)
-@result{} 4
+Calls to @var{pred} are made from left to right across @var{s}.
+If the predicate is true for every character then the return
+value from the last @var{pred} call is the return from
+@code{string-every}.
-(string-rindex "weiner" #\e 2 4)
-@result{} #f
+If there are no characters in @var{s} (ie.@: @var{start} equals
+@var{end}) then the return is @code{#t}.
-(string-rindex "weiner" #\e 2 5)
-@result{} 4
-@end lisp
+The SRFI-13 specification requires that the call to @var{pred}
+on the last character of @var{s} (assuming that point is
+reached) be a tail call, but currently in Guile this is not the
+case.
@end deffn
-\fsubstring-move-left!
-@deffn primitive substring-move-left!
-implemented by the C function "scm_substring_move_x"
+\fstring-tabulate
+@c snarfed from srfi-13.c:209
+@deffn {Scheme Procedure} string-tabulate proc len
+@deffnx {C Function} scm_string_tabulate (proc, len)
+@var{proc} is an integer->char procedure. Construct a string
+of size @var{len} by applying @var{proc} to each index to
+produce the corresponding string element. The order in which
+@var{proc} is applied to the indices is not specified.
@end deffn
-\fsubstring-move-right!
-@deffn primitive substring-move-right!
-implemented by the C function "scm_substring_move_x"
+\fstring->list
+@c snarfed from srfi-13.c:241
+@deffn {Scheme Procedure} string->list str [start [end]]
+@deffnx {C Function} scm_substring_to_list (str, start, end)
+Convert the string @var{str} into a list of characters.
+@end deffn
+
+\freverse-list->string
+@c snarfed from srfi-13.c:280
+@deffn {Scheme Procedure} reverse-list->string chrs
+@deffnx {C Function} scm_reverse_list_to_string (chrs)
+An efficient implementation of @code{(compose string->list
+reverse)}:
+
+@smalllisp
+(reverse-list->string '(#\a #\B #\c)) @result{} "cBa"
+@end smalllisp
+@end deffn
+
+\fstring-join
+@c snarfed from srfi-13.c:347
+@deffn {Scheme Procedure} string-join ls [delimiter [grammar]]
+@deffnx {C Function} scm_string_join (ls, delimiter, grammar)
+Append the string in the string list @var{ls}, using the string
+@var{delim} as a delimiter between the elements of @var{ls}.
+@var{grammar} is a symbol which specifies how the delimiter is
+placed between the strings, and defaults to the symbol
+@code{infix}.
+
+@table @code
+@item infix
+Insert the separator between list elements. An empty string
+will produce an empty list.
+@item string-infix
+Like @code{infix}, but will raise an error if given the empty
+list.
+@item suffix
+Insert the separator after every list element.
+@item prefix
+Insert the separator before each list element.
+@end table
+@end deffn
+
+\fstring-copy
+@c snarfed from srfi-13.c:481
+@deffn {Scheme Procedure} string-copy str [start [end]]
+@deffnx {C Function} scm_srfi13_substring_copy (str, start, end)
+Return a freshly allocated copy of the string @var{str}. If
+given, @var{start} and @var{end} delimit the portion of
+@var{str} which is copied.
+@end deffn
+
+\fstring-copy!
+@c snarfed from srfi-13.c:508
+@deffn {Scheme Procedure} string-copy! target tstart s [start [end]]
+@deffnx {C Function} scm_string_copy_x (target, tstart, s, start, end)
+Copy the sequence of characters from index range [@var{start},
+@var{end}) in string @var{s} to string @var{target}, beginning
+at index @var{tstart}. The characters are copied left-to-right
+or right-to-left as needed -- the copy is guaranteed to work,
+even if @var{target} and @var{s} are the same string. It is an
+error if the copy operation runs off the end of the target
+string.
@end deffn
\fsubstring-move!
-@deffn primitive substring-move! str1 start1 end1 str2 start2
-@deffnx primitive substring-move-left! str1 start1 end1 str2 start2
-@deffnx primitive substring-move-right! str1 start1 end1 str2 start2
+@c snarfed from srfi-13.c:538
+@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}
into @var{str2} beginning at position @var{start2}.
-@code{substring-move-right!} begins copying from the rightmost character
-and moves left, and @code{substring-move-left!} copies from the leftmost
-character moving right.
-
-It is useful to have two functions that copy in different directions so
-that substrings can be copied back and forth within a single string. If
-you wish to copy text from the left-hand side of a string to the
-right-hand side of the same string, and the source and destination
-overlap, you must be careful to copy the rightmost characters of the
-text first, to avoid clobbering your data. Hence, when @var{str1} and
-@var{str2} are the same string, you should use
-@code{substring-move-right!} when moving text from left to right, and
-@code{substring-move-left!} otherwise. If @code{str1} and @samp{str2}
-are different strings, it does not matter which function you use.
-@end deffn
-
-\fsubstring-fill!
-@deffn primitive substring-fill! str start end fill
-Change every character in @var{str} between @var{start} and
-@var{end} to @var{fill}.
+@var{str1} and @var{str2} can be the same string.
+@end deffn
-@lisp
-(define y "abcdefg")
-(substring-fill! y 1 3 #\r)
-y
-@result{} "arrdefg"
-@end lisp
+\fstring-take
+@c snarfed from srfi-13.c:547
+@deffn {Scheme Procedure} string-take s n
+@deffnx {C Function} scm_string_take (s, n)
+Return the @var{n} first characters of @var{s}.
@end deffn
-\fstring-null?
-@deffn primitive string-null? str
-Return @code{#t} if @var{str}'s length is zero, and
-@code{#f} otherwise.
-@lisp
-(string-null? "") @result{} #t
-y @result{} "foo"
-(string-null? y) @result{} #f
-@end lisp
+\fstring-drop
+@c snarfed from srfi-13.c:557
+@deffn {Scheme Procedure} string-drop s n
+@deffnx {C Function} scm_string_drop (s, n)
+Return all but the first @var{n} characters of @var{s}.
@end deffn
-\fstring->list
-@deffn primitive string->list str
-Return a newly allocated list of the characters that make up
-the given string @var{str}. @code{string->list} and
-@code{list->string} are inverses as far as @samp{equal?} is
-concerned.
+\fstring-take-right
+@c snarfed from srfi-13.c:567
+@deffn {Scheme Procedure} string-take-right s n
+@deffnx {C Function} scm_string_take_right (s, n)
+Return the @var{n} last characters of @var{s}.
@end deffn
-\fstring-copy
-@deffn primitive string-copy str
-Return a newly allocated copy of the given @var{string}.
+\fstring-drop-right
+@c snarfed from srfi-13.c:579
+@deffn {Scheme Procedure} string-drop-right s n
+@deffnx {C Function} scm_string_drop_right (s, n)
+Return all but the last @var{n} characters of @var{s}.
+@end deffn
+
+\fstring-pad
+@c snarfed from srfi-13.c:594
+@deffn {Scheme Procedure} string-pad s len [chr [start [end]]]
+@deffnx {C Function} scm_string_pad (s, len, chr, start, end)
+Take that characters from @var{start} to @var{end} from the
+string @var{s} and return a new string, right-padded by the
+character @var{chr} to length @var{len}. If the resulting
+string is longer than @var{len}, it is truncated on the right.
+@end deffn
+
+\fstring-pad-right
+@c snarfed from srfi-13.c:634
+@deffn {Scheme Procedure} string-pad-right s len [chr [start [end]]]
+@deffnx {C Function} scm_string_pad_right (s, len, chr, start, end)
+Take that characters from @var{start} to @var{end} from the
+string @var{s} and return a new string, left-padded by the
+character @var{chr} to length @var{len}. If the resulting
+string is longer than @var{len}, it is truncated on the left.
+@end deffn
+
+\fstring-trim
+@c snarfed from srfi-13.c:687
+@deffn {Scheme Procedure} string-trim s [char_pred [start [end]]]
+@deffnx {C Function} scm_string_trim (s, char_pred, start, end)
+Trim @var{s} by skipping over all characters on the left
+that satisfy the parameter @var{char_pred}:
+
+@itemize @bullet
+@item
+if it is the character @var{ch}, characters equal to
+@var{ch} are trimmed,
+
+@item
+if it is a procedure @var{pred} characters that
+satisfy @var{pred} are trimmed,
+
+@item
+if it is a character set, characters in that set are trimmed.
+@end itemize
+
+If called without a @var{char_pred} argument, all whitespace is
+trimmed.
+@end deffn
+
+\fstring-trim-right
+@c snarfed from srfi-13.c:763
+@deffn {Scheme Procedure} string-trim-right s [char_pred [start [end]]]
+@deffnx {C Function} scm_string_trim_right (s, char_pred, start, end)
+Trim @var{s} by skipping over all characters on the rightt
+that satisfy the parameter @var{char_pred}:
+
+@itemize @bullet
+@item
+if it is the character @var{ch}, characters equal to @var{ch}
+are trimmed,
+
+@item
+if it is a procedure @var{pred} characters that satisfy
+@var{pred} are trimmed,
+
+@item
+if it is a character sets, all characters in that set are
+trimmed.
+@end itemize
+
+If called without a @var{char_pred} argument, all whitespace is
+trimmed.
+@end deffn
+
+\fstring-trim-both
+@c snarfed from srfi-13.c:839
+@deffn {Scheme Procedure} string-trim-both s [char_pred [start [end]]]
+@deffnx {C Function} scm_string_trim_both (s, char_pred, start, end)
+Trim @var{s} by skipping over all characters on both sides of
+the string that satisfy the parameter @var{char_pred}:
+
+@itemize @bullet
+@item
+if it is the character @var{ch}, characters equal to @var{ch}
+are trimmed,
+
+@item
+if it is a procedure @var{pred} characters that satisfy
+@var{pred} are trimmed,
+
+@item
+if it is a character set, the characters in the set are
+trimmed.
+@end itemize
+
+If called without a @var{char_pred} argument, all whitespace is
+trimmed.
@end deffn
\fstring-fill!
-@deffn primitive string-fill! str chr
-Store @var{char} in every element of the given @var{string} and
-return an unspecified value.
+@c snarfed from srfi-13.c:926
+@deffn {Scheme Procedure} string-fill! str chr [start [end]]
+@deffnx {C Function} scm_substring_fill_x (str, chr, start, end)
+Stores @var{chr} in every element of the given @var{str} and
+returns an unspecified value.
+@end deffn
+
+\fstring-compare
+@c snarfed from srfi-13.c:978
+@deffn {Scheme Procedure} string-compare s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_compare (s1, s2, proc_lt, proc_eq, proc_gt, start1, end1, start2, end2)
+Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
+mismatch index, depending upon whether @var{s1} is less than,
+equal to, or greater than @var{s2}. The mismatch index is the
+largest index @var{i} such that for every 0 <= @var{j} <
+@var{i}, @var{s1}[@var{j}] = @var{s2}[@var{j}] -- that is,
+@var{i} is the first position that does not match.
+@end deffn
+
+\fstring-compare-ci
+@c snarfed from srfi-13.c:1032
+@deffn {Scheme Procedure} string-compare-ci s1 s2 proc_lt proc_eq proc_gt [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_compare_ci (s1, s2, proc_lt, proc_eq, proc_gt, start1, end1, start2, end2)
+Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
+mismatch index, depending upon whether @var{s1} is less than,
+equal to, or greater than @var{s2}. The mismatch index is the
+largest index @var{i} such that for every 0 <= @var{j} <
+@var{i}, @var{s1}[@var{j}] = @var{s2}[@var{j}] -- that is,
+@var{i} is the first position that does not match. The
+character comparison is done case-insensitively.
+@end deffn
+
+\fstring=
+@c snarfed from srfi-13.c:1083
+@deffn {Scheme Procedure} string= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_eq (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
+value otherwise.
+@end deffn
+
+\fstring<>
+@c snarfed from srfi-13.c:1122
+@deffn {Scheme Procedure} string<> s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_neq (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} and @var{s2} are equal, a true
+value otherwise.
+@end deffn
+
+\fstring<
+@c snarfed from srfi-13.c:1165
+@deffn {Scheme Procedure} string< s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_lt (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
+true value otherwise.
+@end deffn
+
+\fstring>
+@c snarfed from srfi-13.c:1208
+@deffn {Scheme Procedure} string> s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_gt (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
+true value otherwise.
+@end deffn
+
+\fstring<=
+@c snarfed from srfi-13.c:1251
+@deffn {Scheme Procedure} string<= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_le (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is greater to @var{s2}, a true
+value otherwise.
+@end deffn
+
+\fstring>=
+@c snarfed from srfi-13.c:1294
+@deffn {Scheme Procedure} string>= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ge (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is less to @var{s2}, a true value
+otherwise.
+@end deffn
+
+\fstring-ci=
+@c snarfed from srfi-13.c:1338
+@deffn {Scheme Procedure} string-ci= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_eq (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
+value otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-ci<>
+@c snarfed from srfi-13.c:1382
+@deffn {Scheme Procedure} string-ci<> s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_neq (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} and @var{s2} are equal, a true
+value otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-ci<
+@c snarfed from srfi-13.c:1426
+@deffn {Scheme Procedure} string-ci< s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_lt (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
+true value otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-ci>
+@c snarfed from srfi-13.c:1470
+@deffn {Scheme Procedure} string-ci> s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_gt (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
+true value otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-ci<=
+@c snarfed from srfi-13.c:1514
+@deffn {Scheme Procedure} string-ci<= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_le (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is greater to @var{s2}, a true
+value otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-ci>=
+@c snarfed from srfi-13.c:1558
+@deffn {Scheme Procedure} string-ci>= s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_ci_ge (s1, s2, start1, end1, start2, end2)
+Return @code{#f} if @var{s1} is less to @var{s2}, a true value
+otherwise. The character comparison is done
+case-insensitively.
+@end deffn
+
+\fstring-hash
+@c snarfed from srfi-13.c:1603
+@deffn {Scheme Procedure} string-hash s [bound [start [end]]]
+@deffnx {C Function} scm_substring_hash (s, bound, start, end)
+Compute a hash value for @var{S}. the optional argument @var{bound} is a non-negative exact integer specifying the range of the hash function. A positive value restricts the return value to the range [0,bound).
+@end deffn
+
+\fstring-hash-ci
+@c snarfed from srfi-13.c:1620
+@deffn {Scheme Procedure} string-hash-ci s [bound [start [end]]]
+@deffnx {C Function} scm_substring_hash_ci (s, bound, start, end)
+Compute a hash value for @var{S}. the optional argument @var{bound} is a non-negative exact integer specifying the range of the hash function. A positive value restricts the return value to the range [0,bound).
+@end deffn
+
+\fstring-prefix-length
+@c snarfed from srfi-13.c:1632
+@deffn {Scheme Procedure} string-prefix-length s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_prefix_length (s1, s2, start1, end1, start2, end2)
+Return the length of the longest common prefix of the two
+strings.
+@end deffn
+
+\fstring-prefix-length-ci
+@c snarfed from srfi-13.c:1664
+@deffn {Scheme Procedure} string-prefix-length-ci s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_prefix_length_ci (s1, s2, start1, end1, start2, end2)
+Return the length of the longest common prefix of the two
+strings, ignoring character case.
+@end deffn
+
+\fstring-suffix-length
+@c snarfed from srfi-13.c:1696
+@deffn {Scheme Procedure} string-suffix-length s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_suffix_length (s1, s2, start1, end1, start2, end2)
+Return the length of the longest common suffix of the two
+strings.
+@end deffn
+
+\fstring-suffix-length-ci
+@c snarfed from srfi-13.c:1728
+@deffn {Scheme Procedure} string-suffix-length-ci s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_suffix_length_ci (s1, s2, start1, end1, start2, end2)
+Return the length of the longest common suffix of the two
+strings, ignoring character case.
+@end deffn
+
+\fstring-prefix?
+@c snarfed from srfi-13.c:1759
+@deffn {Scheme Procedure} string-prefix? s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_prefix_p (s1, s2, start1, end1, start2, end2)
+Is @var{s1} a prefix of @var{s2}?
+@end deffn
+
+\fstring-prefix-ci?
+@c snarfed from srfi-13.c:1791
+@deffn {Scheme Procedure} string-prefix-ci? s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_prefix_ci_p (s1, s2, start1, end1, start2, end2)
+Is @var{s1} a prefix of @var{s2}, ignoring character case?
+@end deffn
+
+\fstring-suffix?
+@c snarfed from srfi-13.c:1823
+@deffn {Scheme Procedure} string-suffix? s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_suffix_p (s1, s2, start1, end1, start2, end2)
+Is @var{s1} a suffix of @var{s2}?
+@end deffn
+
+\fstring-suffix-ci?
+@c snarfed from srfi-13.c:1855
+@deffn {Scheme Procedure} string-suffix-ci? s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_suffix_ci_p (s1, s2, start1, end1, start2, end2)
+Is @var{s1} a suffix of @var{s2}, ignoring character case?
+@end deffn
+
+\fstring-index
+@c snarfed from srfi-13.c:1899
+@deffn {Scheme Procedure} string-index s char_pred [start [end]]
+@deffnx {C Function} scm_string_index (s, char_pred, start, end)
+Search through the string @var{s} from left to right, returning
+the index of the first occurence of a character which
+
+@itemize @bullet
+@item
+equals @var{char_pred}, if it is character,
+
+@item
+satisifies the predicate @var{char_pred}, if it is a procedure,
+
+@item
+is in the set @var{char_pred}, if it is a character set.
+@end itemize
+@end deffn
+
+\fstring-index-right
+@c snarfed from srfi-13.c:1964
+@deffn {Scheme Procedure} string-index-right s char_pred [start [end]]
+@deffnx {C Function} scm_string_index_right (s, char_pred, start, end)
+Search through the string @var{s} from right to left, returning
+the index of the last occurence of a character which
+
+@itemize @bullet
+@item
+equals @var{char_pred}, if it is character,
+
+@item
+satisifies the predicate @var{char_pred}, if it is a procedure,
+
+@item
+is in the set if @var{char_pred} is a character set.
+@end itemize
+@end deffn
+
+\fstring-rindex
+@c snarfed from srfi-13.c:2029
+@deffn {Scheme Procedure} string-rindex s char_pred [start [end]]
+@deffnx {C Function} scm_string_rindex (s, char_pred, start, end)
+Search through the string @var{s} from right to left, returning
+the index of the last occurence of a character which
+
+@itemize @bullet
+@item
+equals @var{char_pred}, if it is character,
+
+@item
+satisifies the predicate @var{char_pred}, if it is a procedure,
+
+@item
+is in the set if @var{char_pred} is a character set.
+@end itemize
+@end deffn
+
+\fstring-skip
+@c snarfed from srfi-13.c:2051
+@deffn {Scheme Procedure} string-skip s char_pred [start [end]]
+@deffnx {C Function} scm_string_skip (s, char_pred, start, end)
+Search through the string @var{s} from left to right, returning
+the index of the first occurence of a character which
+
+@itemize @bullet
+@item
+does not equal @var{char_pred}, if it is character,
+
+@item
+does not satisify the predicate @var{char_pred}, if it is a
+procedure,
+
+@item
+is not in the set if @var{char_pred} is a character set.
+@end itemize
+@end deffn
+
+\fstring-skip-right
+@c snarfed from srfi-13.c:2118
+@deffn {Scheme Procedure} string-skip-right s char_pred [start [end]]
+@deffnx {C Function} scm_string_skip_right (s, char_pred, start, end)
+Search through the string @var{s} from right to left, returning
+the index of the last occurence of a character which
+
+@itemize @bullet
+@item
+does not equal @var{char_pred}, if it is character,
+
+@item
+does not satisfy the predicate @var{char_pred}, if it is a
+procedure,
+
+@item
+is not in the set if @var{char_pred} is a character set.
+@end itemize
+@end deffn
+
+\fstring-count
+@c snarfed from srfi-13.c:2185
+@deffn {Scheme Procedure} string-count s char_pred [start [end]]
+@deffnx {C Function} scm_string_count (s, char_pred, start, end)
+Return the count of the number of characters in the string
+@var{s} which
+
+@itemize @bullet
+@item
+equals @var{char_pred}, if it is character,
+
+@item
+satisifies the predicate @var{char_pred}, if it is a procedure.
+
+@item
+is in the set @var{char_pred}, if it is a character set.
+@end itemize
+@end deffn
+
+\fstring-contains
+@c snarfed from srfi-13.c:2242
+@deffn {Scheme Procedure} string-contains s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_contains (s1, s2, start1, end1, start2, end2)
+Does string @var{s1} contain string @var{s2}? Return the index
+in @var{s1} where @var{s2} occurs as a substring, or false.
+The optional start/end indices restrict the operation to the
+indicated substrings.
+@end deffn
+
+\fstring-contains-ci
+@c snarfed from srfi-13.c:2289
+@deffn {Scheme Procedure} string-contains-ci s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_contains_ci (s1, s2, start1, end1, start2, end2)
+Does string @var{s1} contain string @var{s2}? Return the index
+in @var{s1} where @var{s2} occurs as a substring, or false.
+The optional start/end indices restrict the operation to the
+indicated substrings. Character comparison is done
+case-insensitively.
@end deffn
\fstring-upcase!
-@deffn primitive string-upcase! str
-Destructively upcase every character in @var{str} and return
-@var{str}.
+@c snarfed from srfi-13.c:2354
+@deffn {Scheme Procedure} string-upcase! str [start [end]]
+@deffnx {C Function} scm_substring_upcase_x (str, start, end)
+Destructively upcase every character in @code{str}.
+
@lisp
-y @result{} "arrdefg"
-(string-upcase! y) @result{} "ARRDEFG"
-y @result{} "ARRDEFG"
+(string-upcase! y)
+@result{} "ARRDEFG"
+y
+@result{} "ARRDEFG"
@end lisp
@end deffn
\fstring-upcase
-@deffn primitive string-upcase str
-Return a freshly allocated string containing the characters of
-@var{str} in upper case.
+@c snarfed from srfi-13.c:2375
+@deffn {Scheme Procedure} string-upcase str [start [end]]
+@deffnx {C Function} scm_substring_upcase (str, start, end)
+Upcase every character in @code{str}.
@end deffn
\fstring-downcase!
-@deffn primitive string-downcase! str
-Destructively downcase every character in @var{str} and return
-@var{str}.
+@c snarfed from srfi-13.c:2422
+@deffn {Scheme Procedure} string-downcase! str [start [end]]
+@deffnx {C Function} scm_substring_downcase_x (str, start, end)
+Destructively downcase every character in @var{str}.
+
@lisp
-y @result{} "ARRDEFG"
-(string-downcase! y) @result{} "arrdefg"
-y @result{} "arrdefg"
+y
+@result{} "ARRDEFG"
+(string-downcase! y)
+@result{} "arrdefg"
+y
+@result{} "arrdefg"
@end lisp
@end deffn
\fstring-downcase
-@deffn primitive string-downcase str
-Return a freshly allocation string containing the characters in
-@var{str} in lower case.
+@c snarfed from srfi-13.c:2443
+@deffn {Scheme Procedure} string-downcase str [start [end]]
+@deffnx {C Function} scm_substring_downcase (str, start, end)
+Downcase every character in @var{str}.
+@end deffn
+
+\fstring-titlecase!
+@c snarfed from srfi-13.c:2499
+@deffn {Scheme Procedure} string-titlecase! str [start [end]]
+@deffnx {C Function} scm_string_titlecase_x (str, start, end)
+Destructively titlecase every first character in a word in
+@var{str}.
+@end deffn
+
+\fstring-titlecase
+@c snarfed from srfi-13.c:2515
+@deffn {Scheme Procedure} string-titlecase str [start [end]]
+@deffnx {C Function} scm_string_titlecase (str, start, end)
+Titlecase every first character in a word in @var{str}.
@end deffn
\fstring-capitalize!
-@deffn primitive string-capitalize! str
+@c snarfed from srfi-13.c:2537
+@deffn {Scheme Procedure} string-capitalize! str
+@deffnx {C Function} scm_string_capitalize_x (str)
Upcase the first character of every word in @var{str}
destructively and return @var{str}.
@end deffn
\fstring-capitalize
-@deffn primitive string-capitalize str
+@c snarfed from srfi-13.c:2549
+@deffn {Scheme Procedure} string-capitalize str
+@deffnx {C Function} scm_string_capitalize (str)
Return a freshly allocated string with the characters in
@var{str}, where the first character of every word is
capitalized.
@end deffn
+\fstring-reverse
+@c snarfed from srfi-13.c:2583
+@deffn {Scheme Procedure} string-reverse str [start [end]]
+@deffnx {C Function} scm_string_reverse (str, start, end)
+Reverse the string @var{str}. The optional arguments
+@var{start} and @var{end} delimit the region of @var{str} to
+operate on.
+@end deffn
+
+\fstring-reverse!
+@c snarfed from srfi-13.c:2608
+@deffn {Scheme Procedure} string-reverse! str [start [end]]
+@deffnx {C Function} scm_string_reverse_x (str, start, end)
+Reverse the string @var{str} in-place. The optional arguments
+@var{start} and @var{end} delimit the region of @var{str} to
+operate on. The return value is unspecified.
+@end deffn
+
+\fstring-append/shared
+@c snarfed from srfi-13.c:2630
+@deffn {Scheme Procedure} string-append/shared . ls
+@deffnx {C Function} scm_string_append_shared (ls)
+Like @code{string-append}, but the result may share memory
+with the argument strings.
+@end deffn
+
+\fstring-concatenate
+@c snarfed from srfi-13.c:2651
+@deffn {Scheme Procedure} string-concatenate ls
+@deffnx {C Function} scm_string_concatenate (ls)
+Append the elements of @var{ls} (which must be strings)
+together into a single string. Guaranteed to return a freshly
+allocated string.
+@end deffn
+
+\fstring-concatenate-reverse
+@c snarfed from srfi-13.c:2673
+@deffn {Scheme Procedure} string-concatenate-reverse ls [final_string [end]]
+@deffnx {C Function} scm_string_concatenate_reverse (ls, final_string, end)
+Without optional arguments, this procedure is equivalent to
+
+@smalllisp
+(string-concatenate (reverse ls))
+@end smalllisp
+
+If the optional argument @var{final_string} is specified, it is
+consed onto the beginning to @var{ls} before performing the
+list-reverse and string-concatenate operations. If @var{end}
+is given, only the characters of @var{final_string} up to index
+@var{end} are used.
+
+Guaranteed to return a freshly allocated string.
+@end deffn
+
+\fstring-concatenate/shared
+@c snarfed from srfi-13.c:2690
+@deffn {Scheme Procedure} string-concatenate/shared ls
+@deffnx {C Function} scm_string_concatenate_shared (ls)
+Like @code{string-concatenate}, but the result may share memory
+with the strings in the list @var{ls}.
+@end deffn
+
+\fstring-concatenate-reverse/shared
+@c snarfed from srfi-13.c:2701
+@deffn {Scheme Procedure} string-concatenate-reverse/shared ls [final_string [end]]
+@deffnx {C Function} scm_string_concatenate_reverse_shared (ls, final_string, end)
+Like @code{string-concatenate-reverse}, but the result may
+share memory with the the strings in the @var{ls} arguments.
+@end deffn
+
+\fstring-map
+@c snarfed from srfi-13.c:2714
+@deffn {Scheme Procedure} string-map proc s [start [end]]
+@deffnx {C Function} scm_string_map (proc, s, start, end)
+@var{proc} is a char->char procedure, it is mapped over
+@var{s}. The order in which the procedure is applied to the
+string elements is not specified.
+@end deffn
+
+\fstring-map!
+@c snarfed from srfi-13.c:2744
+@deffn {Scheme Procedure} string-map! proc s [start [end]]
+@deffnx {C Function} scm_string_map_x (proc, s, start, end)
+@var{proc} is a char->char procedure, it is mapped over
+@var{s}. The order in which the procedure is applied to the
+string elements is not specified. The string @var{s} is
+modified in-place, the return value is not specified.
+@end deffn
+
+\fstring-fold
+@c snarfed from srfi-13.c:2771
+@deffn {Scheme Procedure} string-fold kons knil s [start [end]]
+@deffnx {C Function} scm_string_fold (kons, knil, s, start, end)
+Fold @var{kons} over the characters of @var{s}, with @var{knil}
+as the terminating element, from left to right. @var{kons}
+must expect two arguments: The actual character and the last
+result of @var{kons}' application.
+@end deffn
+
+\fstring-fold-right
+@c snarfed from srfi-13.c:2802
+@deffn {Scheme Procedure} string-fold-right kons knil s [start [end]]
+@deffnx {C Function} scm_string_fold_right (kons, knil, s, start, end)
+Fold @var{kons} over the characters of @var{s}, with @var{knil}
+as the terminating element, from right to left. @var{kons}
+must expect two arguments: The actual character and the last
+result of @var{kons}' application.
+@end deffn
+
+\fstring-unfold
+@c snarfed from srfi-13.c:2847
+@deffn {Scheme Procedure} string-unfold p f g seed [base [make_final]]
+@deffnx {C Function} scm_string_unfold (p, f, g, seed, base, make_final)
+@itemize @bullet
+@item @var{g} is used to generate a series of @emph{seed}
+values from the initial @var{seed}: @var{seed}, (@var{g}
+@var{seed}), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
+@dots{}
+@item @var{p} tells us when to stop -- when it returns true
+when applied to one of these seed values.
+@item @var{f} maps each seed value to the corresponding
+character in the result string. These chars are assembled
+into the string in a left-to-right order.
+@item @var{base} is the optional initial/leftmost portion
+of the constructed string; it default to the empty
+string.
+@item @var{make_final} is applied to the terminal seed
+value (on which @var{p} returns true) to produce
+the final/rightmost portion of the constructed string.
+It defaults to @code{(lambda (x) )}.
+@end itemize
+@end deffn
+
+\fstring-unfold-right
+@c snarfed from srfi-13.c:2910
+@deffn {Scheme Procedure} string-unfold-right p f g seed [base [make_final]]
+@deffnx {C Function} scm_string_unfold_right (p, f, g, seed, base, make_final)
+@itemize @bullet
+@item @var{g} is used to generate a series of @emph{seed}
+values from the initial @var{seed}: @var{seed}, (@var{g}
+@var{seed}), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
+@dots{}
+@item @var{p} tells us when to stop -- when it returns true
+when applied to one of these seed values.
+@item @var{f} maps each seed value to the corresponding
+character in the result string. These chars are assembled
+into the string in a right-to-left order.
+@item @var{base} is the optional initial/rightmost portion
+of the constructed string; it default to the empty
+string.
+@item @var{make_final} is applied to the terminal seed
+value (on which @var{p} returns true) to produce
+the final/leftmost portion of the constructed string.
+It defaults to @code{(lambda (x) )}.
+@end itemize
+@end deffn
+
+\fstring-for-each
+@c snarfed from srfi-13.c:2957
+@deffn {Scheme Procedure} string-for-each proc s [start [end]]
+@deffnx {C Function} scm_string_for_each (proc, s, start, end)
+@var{proc} is mapped over @var{s} in left-to-right order. The
+return value is not specified.
+@end deffn
+
+\fstring-for-each-index
+@c snarfed from srfi-13.c:2983
+@deffn {Scheme Procedure} string-for-each-index proc s [start [end]]
+@deffnx {C Function} scm_string_for_each_index (proc, s, start, end)
+@var{proc} is mapped over @var{s} in left-to-right order. The
+return value is not specified.
+@end deffn
+
+\fxsubstring
+@c snarfed from srfi-13.c:3015
+@deffn {Scheme Procedure} xsubstring s from [to [start [end]]]
+@deffnx {C Function} scm_xsubstring (s, from, to, start, end)
+This is the @emph{extended substring} procedure that implements
+replicated copying of a substring of some string.
+
+@var{s} is a string, @var{start} and @var{end} are optional
+arguments that demarcate a substring of @var{s}, defaulting to
+0 and the length of @var{s}. Replicate this substring up and
+down index space, in both the positive and negative directions.
+@code{xsubstring} returns the substring of this string
+beginning at index @var{from}, and ending at @var{to}, which
+defaults to @var{from} + (@var{end} - @var{start}).
+@end deffn
+
+\fstring-xcopy!
+@c snarfed from srfi-13.c:3062
+@deffn {Scheme Procedure} string-xcopy! target tstart s sfrom [sto [start [end]]]
+@deffnx {C Function} scm_string_xcopy_x (target, tstart, s, sfrom, sto, start, end)
+Exactly the same as @code{xsubstring}, but the extracted text
+is written into the string @var{target} starting at index
+@var{tstart}. The operation is not defined if @code{(eq?
+@var{target} @var{s})} or these arguments share storage -- you
+cannot copy a string on top of itself.
+@end deffn
+
+\fstring-replace
+@c snarfed from srfi-13.c:3112
+@deffn {Scheme Procedure} string-replace s1 s2 [start1 [end1 [start2 [end2]]]]
+@deffnx {C Function} scm_string_replace (s1, s2, start1, end1, start2, end2)
+Return the string @var{s1}, but with the characters
+@var{start1} @dots{} @var{end1} replaced by the characters
+@var{start2} @dots{} @var{end2} from @var{s2}.
+@end deffn
+
+\fstring-tokenize
+@c snarfed from srfi-13.c:3149
+@deffn {Scheme Procedure} string-tokenize s [token_set [start [end]]]
+@deffnx {C Function} scm_string_tokenize (s, token_set, start, end)
+Split the string @var{s} into a list of substrings, where each
+substring is a maximal non-empty contiguous sequence of
+characters from the character set @var{token_set}, which
+defaults to @code{char-set:graphic}.
+If @var{start} or @var{end} indices are provided, they restrict
+@code{string-tokenize} to operating on the indicated substring
+of @var{s}.
+@end deffn
+
\fstring-split
-@deffn primitive string-split str chr
+@c snarfed from srfi-13.c:3215
+@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
by appearances of the character @var{chr}. Note that an empty substring
between separator characters will result in an empty string in the
result list.
@lisp
-(string-split "root:x:0:0:root:/root:/bin/bash" #:)
+(string-split "root:x:0:0:root:/root:/bin/bash" #\:)
@result{}
("root" "x" "0" "0" "root" "/root" "/bin/bash")
-(string-split "::" #:)
+(string-split "::" #\:)
@result{}
("" "" "")
-(string-split "" #:)
+(string-split "" #\:)
@result{}
("")
@end lisp
@end deffn
-\fstring-ci->symbol
-@deffn primitive string-ci->symbol str
-Return the symbol whose name is @var{str}. @var{str} is
-converted to lowercase before the conversion is done, if Guile
-is currently reading symbols case--insensitively.
+\fstring-filter
+@c snarfed from srfi-13.c:3253
+@deffn {Scheme Procedure} string-filter s char_pred [start [end]]
+@deffnx {C Function} scm_string_filter (s, char_pred, start, end)
+Filter the string @var{s}, retaining only those characters that
+satisfy the @var{char_pred} argument. If the argument is a
+procedure, it is applied to each character as a predicate, if
+it is a character, it is tested for equality and if it is a
+character set, it is tested for membership.
+@end deffn
+
+\fstring-delete
+@c snarfed from srfi-13.c:3325
+@deffn {Scheme Procedure} string-delete s char_pred [start [end]]
+@deffnx {C Function} scm_string_delete (s, char_pred, start, end)
+Filter the string @var{s}, retaining only those characters that
+do not satisfy the @var{char_pred} argument. If the argument
+is a procedure, it is applied to each character as a predicate,
+if it is a character, it is tested for equality and if it is a
+character set, it is tested for membership.
+@end deffn
+
+\fchar-set?
+@c snarfed from srfi-14.c:85
+@deffn {Scheme Procedure} char-set? obj
+@deffnx {C Function} scm_char_set_p (obj)
+Return @code{#t} if @var{obj} is a character set, @code{#f}
+otherwise.
+@end deffn
+
+\fchar-set=
+@c snarfed from srfi-14.c:95
+@deffn {Scheme Procedure} char-set= . char_sets
+@deffnx {C Function} scm_char_set_eq (char_sets)
+Return @code{#t} if all given character sets are equal.
+@end deffn
+
+\fchar-set<=
+@c snarfed from srfi-14.c:125
+@deffn {Scheme Procedure} char-set<= . char_sets
+@deffnx {C Function} scm_char_set_leq (char_sets)
+Return @code{#t} if every character set @var{cs}i is a subset
+of character set @var{cs}i+1.
+@end deffn
+
+\fchar-set-hash
+@c snarfed from srfi-14.c:163
+@deffn {Scheme Procedure} char-set-hash cs [bound]
+@deffnx {C Function} scm_char_set_hash (cs, bound)
+Compute a hash value for the character set @var{cs}. If
+@var{bound} is given and non-zero, it restricts the
+returned value to the range 0 @dots{} @var{bound - 1}.
+@end deffn
+
+\fchar-set-cursor
+@c snarfed from srfi-14.c:196
+@deffn {Scheme Procedure} char-set-cursor cs
+@deffnx {C Function} scm_char_set_cursor (cs)
+Return a cursor into the character set @var{cs}.
+@end deffn
+
+\fchar-set-ref
+@c snarfed from srfi-14.c:216
+@deffn {Scheme Procedure} char-set-ref cs cursor
+@deffnx {C Function} scm_char_set_ref (cs, cursor)
+Return the character at the current cursor position
+@var{cursor} in the character set @var{cs}. It is an error to
+pass a cursor for which @code{end-of-char-set?} returns true.
+@end deffn
+
+\fchar-set-cursor-next
+@c snarfed from srfi-14.c:233
+@deffn {Scheme Procedure} char-set-cursor-next cs cursor
+@deffnx {C Function} scm_char_set_cursor_next (cs, cursor)
+Advance the character set cursor @var{cursor} to the next
+character in the character set @var{cs}. It is an error if the
+cursor given satisfies @code{end-of-char-set?}.
+@end deffn
+
+\fend-of-char-set?
+@c snarfed from srfi-14.c:254
+@deffn {Scheme Procedure} end-of-char-set? cursor
+@deffnx {C Function} scm_end_of_char_set_p (cursor)
+Return @code{#t} if @var{cursor} has reached the end of a
+character set, @code{#f} otherwise.
+@end deffn
+
+\fchar-set-fold
+@c snarfed from srfi-14.c:266
+@deffn {Scheme Procedure} char-set-fold kons knil cs
+@deffnx {C Function} scm_char_set_fold (kons, knil, cs)
+Fold the procedure @var{kons} over the character set @var{cs},
+initializing it with @var{knil}.
+@end deffn
+
+\fchar-set-unfold
+@c snarfed from srfi-14.c:296
+@deffn {Scheme Procedure} char-set-unfold p f g seed [base_cs]
+@deffnx {C Function} scm_char_set_unfold (p, f, g, seed, base_cs)
+This is a fundamental constructor for character sets.
+@itemize @bullet
+@item @var{g} is used to generate a series of ``seed'' values
+from the initial seed: @var{seed}, (@var{g} @var{seed}),
+(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
+@item @var{p} tells us when to stop -- when it returns true
+when applied to one of the seed values.
+@item @var{f} maps each seed value to a character. These
+characters are added to the base character set @var{base_cs} to
+form the result; @var{base_cs} defaults to the empty set.
+@end itemize
+@end deffn
+
+\fchar-set-unfold!
+@c snarfed from srfi-14.c:340
+@deffn {Scheme Procedure} char-set-unfold! p f g seed base_cs
+@deffnx {C Function} scm_char_set_unfold_x (p, f, g, seed, base_cs)
+This is a fundamental constructor for character sets.
+@itemize @bullet
+@item @var{g} is used to generate a series of ``seed'' values
+from the initial seed: @var{seed}, (@var{g} @var{seed}),
+(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
+@item @var{p} tells us when to stop -- when it returns true
+when applied to one of the seed values.
+@item @var{f} maps each seed value to a character. These
+characters are added to the base character set @var{base_cs} to
+form the result; @var{base_cs} defaults to the empty set.
+@end itemize
+@end deffn
+
+\fchar-set-for-each
+@c snarfed from srfi-14.c:369
+@deffn {Scheme Procedure} char-set-for-each proc cs
+@deffnx {C Function} scm_char_set_for_each (proc, cs)
+Apply @var{proc} to every character in the character set
+@var{cs}. The return value is not specified.
+@end deffn
+
+\fchar-set-map
+@c snarfed from srfi-14.c:388
+@deffn {Scheme Procedure} char-set-map proc cs
+@deffnx {C Function} scm_char_set_map (proc, cs)
+Map the procedure @var{proc} over every character in @var{cs}.
+@var{proc} must be a character -> character procedure.
+@end deffn
+
+\fchar-set-copy
+@c snarfed from srfi-14.c:414
+@deffn {Scheme Procedure} char-set-copy cs
+@deffnx {C Function} scm_char_set_copy (cs)
+Return a newly allocated character set containing all
+characters in @var{cs}.
+@end deffn
+
+\fchar-set
+@c snarfed from srfi-14.c:434
+@deffn {Scheme Procedure} char-set . rest
+@deffnx {C Function} scm_char_set (rest)
+Return a character set containing all given characters.
+@end deffn
+
+\flist->char-set
+@c snarfed from srfi-14.c:462
+@deffn {Scheme Procedure} list->char-set list [base_cs]
+@deffnx {C Function} scm_list_to_char_set (list, base_cs)
+Convert the character list @var{list} to a character set. If
+the character set @var{base_cs} is given, the character in this
+set are also included in the result.
+@end deffn
+
+\flist->char-set!
+@c snarfed from srfi-14.c:496
+@deffn {Scheme Procedure} list->char-set! list base_cs
+@deffnx {C Function} scm_list_to_char_set_x (list, base_cs)
+Convert the character list @var{list} to a character set. The
+characters are added to @var{base_cs} and @var{base_cs} is
+returned.
+@end deffn
+
+\fstring->char-set
+@c snarfed from srfi-14.c:523
+@deffn {Scheme Procedure} string->char-set str [base_cs]
+@deffnx {C Function} scm_string_to_char_set (str, base_cs)
+Convert the string @var{str} to a character set. If the
+character set @var{base_cs} is given, the characters in this
+set are also included in the result.
+@end deffn
+
+\fstring->char-set!
+@c snarfed from srfi-14.c:557
+@deffn {Scheme Procedure} string->char-set! str base_cs
+@deffnx {C Function} scm_string_to_char_set_x (str, base_cs)
+Convert the string @var{str} to a character set. The
+characters from the string are added to @var{base_cs}, and
+@var{base_cs} is returned.
+@end deffn
+
+\fchar-set-filter
+@c snarfed from srfi-14.c:584
+@deffn {Scheme Procedure} char-set-filter pred cs [base_cs]
+@deffnx {C Function} scm_char_set_filter (pred, cs, base_cs)
+Return a character set containing every character from @var{cs}
+so that it satisfies @var{pred}. If provided, the characters
+from @var{base_cs} are added to the result.
+@end deffn
+
+\fchar-set-filter!
+@c snarfed from srfi-14.c:620
+@deffn {Scheme Procedure} char-set-filter! pred cs base_cs
+@deffnx {C Function} scm_char_set_filter_x (pred, cs, base_cs)
+Return a character set containing every character from @var{cs}
+so that it satisfies @var{pred}. The characters are added to
+@var{base_cs} and @var{base_cs} is returned.
+@end deffn
+
+\fucs-range->char-set
+@c snarfed from srfi-14.c:658
+@deffn {Scheme Procedure} ucs-range->char-set lower upper [error [base_cs]]
+@deffnx {C Function} scm_ucs_range_to_char_set (lower, upper, error, base_cs)
+Return a character set containing all characters whose
+character codes lie in the half-open range
+[@var{lower},@var{upper}).
+
+If @var{error} is a true value, an error is signalled if the
+specified range contains characters which are not contained in
+the implemented character range. If @var{error} is @code{#f},
+these characters are silently left out of the resultung
+character set.
+
+The characters in @var{base_cs} are added to the result, if
+given.
+@end deffn
+
+\fucs-range->char-set!
+@c snarfed from srfi-14.c:711
+@deffn {Scheme Procedure} ucs-range->char-set! lower upper error base_cs
+@deffnx {C Function} scm_ucs_range_to_char_set_x (lower, upper, error, base_cs)
+Return a character set containing all characters whose
+character codes lie in the half-open range
+[@var{lower},@var{upper}).
+
+If @var{error} is a true value, an error is signalled if the
+specified range contains characters which are not contained in
+the implemented character range. If @var{error} is @code{#f},
+these characters are silently left out of the resultung
+character set.
+
+The characters are added to @var{base_cs} and @var{base_cs} is
+returned.
+@end deffn
+
+\f->char-set
+@c snarfed from srfi-14.c:741
+@deffn {Scheme Procedure} ->char-set x
+@deffnx {C Function} scm_to_char_set (x)
+Coerces x into a char-set. @var{x} may be a string, character or char-set. A string is converted to the set of its constituent characters; a character is converted to a singleton set; a char-set is returned as-is.
+@end deffn
+
+\fchar-set-size
+@c snarfed from srfi-14.c:757
+@deffn {Scheme Procedure} char-set-size cs
+@deffnx {C Function} scm_char_set_size (cs)
+Return the number of elements in character set @var{cs}.
+@end deffn
+
+\fchar-set-count
+@c snarfed from srfi-14.c:774
+@deffn {Scheme Procedure} char-set-count pred cs
+@deffnx {C Function} scm_char_set_count (pred, cs)
+Return the number of the elements int the character set
+@var{cs} which satisfy the predicate @var{pred}.
+@end deffn
+
+\fchar-set->list
+@c snarfed from srfi-14.c:797
+@deffn {Scheme Procedure} char-set->list cs
+@deffnx {C Function} scm_char_set_to_list (cs)
+Return a list containing the elements of the character set
+@var{cs}.
+@end deffn
+
+\fchar-set->string
+@c snarfed from srfi-14.c:816
+@deffn {Scheme Procedure} char-set->string cs
+@deffnx {C Function} scm_char_set_to_string (cs)
+Return a string containing the elements of the character set
+@var{cs}. The order in which the characters are placed in the
+string is not defined.
+@end deffn
+
+\fchar-set-contains?
+@c snarfed from srfi-14.c:841
+@deffn {Scheme Procedure} char-set-contains? cs ch
+@deffnx {C Function} scm_char_set_contains_p (cs, ch)
+Return @code{#t} iff the character @var{ch} is contained in the
+character set @var{cs}.
+@end deffn
+
+\fchar-set-every
+@c snarfed from srfi-14.c:854
+@deffn {Scheme Procedure} char-set-every pred cs
+@deffnx {C Function} scm_char_set_every (pred, cs)
+Return a true value if every character in the character set
+@var{cs} satisfies the predicate @var{pred}.
+@end deffn
+
+\fchar-set-any
+@c snarfed from srfi-14.c:878
+@deffn {Scheme Procedure} char-set-any pred cs
+@deffnx {C Function} scm_char_set_any (pred, cs)
+Return a true value if any character in the character set
+@var{cs} satisfies the predicate @var{pred}.
+@end deffn
+
+\fchar-set-adjoin
+@c snarfed from srfi-14.c:901
+@deffn {Scheme Procedure} char-set-adjoin cs . rest
+@deffnx {C Function} scm_char_set_adjoin (cs, rest)
+Add all character arguments to the first argument, which must
+be a character set.
+@end deffn
+
+\fchar-set-delete
+@c snarfed from srfi-14.c:929
+@deffn {Scheme Procedure} char-set-delete cs . rest
+@deffnx {C Function} scm_char_set_delete (cs, rest)
+Delete all character arguments from the first argument, which
+must be a character set.
+@end deffn
+
+\fchar-set-adjoin!
+@c snarfed from srfi-14.c:957
+@deffn {Scheme Procedure} char-set-adjoin! cs . rest
+@deffnx {C Function} scm_char_set_adjoin_x (cs, rest)
+Add all character arguments to the first argument, which must
+be a character set.
+@end deffn
+
+\fchar-set-delete!
+@c snarfed from srfi-14.c:984
+@deffn {Scheme Procedure} char-set-delete! cs . rest
+@deffnx {C Function} scm_char_set_delete_x (cs, rest)
+Delete all character arguments from the first argument, which
+must be a character set.
+@end deffn
+
+\fchar-set-complement
+@c snarfed from srfi-14.c:1010
+@deffn {Scheme Procedure} char-set-complement cs
+@deffnx {C Function} scm_char_set_complement (cs)
+Return the complement of the character set @var{cs}.
+@end deffn
+
+\fchar-set-union
+@c snarfed from srfi-14.c:1031
+@deffn {Scheme Procedure} char-set-union . rest
+@deffnx {C Function} scm_char_set_union (rest)
+Return the union of all argument character sets.
+@end deffn
+
+\fchar-set-intersection
+@c snarfed from srfi-14.c:1060
+@deffn {Scheme Procedure} char-set-intersection . rest
+@deffnx {C Function} scm_char_set_intersection (rest)
+Return the intersection of all argument character sets.
+@end deffn
+
+\fchar-set-difference
+@c snarfed from srfi-14.c:1100
+@deffn {Scheme Procedure} char-set-difference cs1 . rest
+@deffnx {C Function} scm_char_set_difference (cs1, rest)
+Return the difference of all argument character sets.
+@end deffn
+
+\fchar-set-xor
+@c snarfed from srfi-14.c:1130
+@deffn {Scheme Procedure} char-set-xor . rest
+@deffnx {C Function} scm_char_set_xor (rest)
+Return the exclusive-or of all argument character sets.
+@end deffn
+
+\fchar-set-diff+intersection
+@c snarfed from srfi-14.c:1171
+@deffn {Scheme Procedure} char-set-diff+intersection cs1 . rest
+@deffnx {C Function} scm_char_set_diff_plus_intersection (cs1, rest)
+Return the difference and the intersection of all argument
+character sets.
+@end deffn
+
+\fchar-set-complement!
+@c snarfed from srfi-14.c:1209
+@deffn {Scheme Procedure} char-set-complement! cs
+@deffnx {C Function} scm_char_set_complement_x (cs)
+Return the complement of the character set @var{cs}.
+@end deffn
+
+\fchar-set-union!
+@c snarfed from srfi-14.c:1226
+@deffn {Scheme Procedure} char-set-union! cs1 . rest
+@deffnx {C Function} scm_char_set_union_x (cs1, rest)
+Return the union of all argument character sets.
+@end deffn
+
+\fchar-set-intersection!
+@c snarfed from srfi-14.c:1254
+@deffn {Scheme Procedure} char-set-intersection! cs1 . rest
+@deffnx {C Function} scm_char_set_intersection_x (cs1, rest)
+Return the intersection of all argument character sets.
+@end deffn
+
+\fchar-set-difference!
+@c snarfed from srfi-14.c:1282
+@deffn {Scheme Procedure} char-set-difference! cs1 . rest
+@deffnx {C Function} scm_char_set_difference_x (cs1, rest)
+Return the difference of all argument character sets.
+@end deffn
+
+\fchar-set-xor!
+@c snarfed from srfi-14.c:1310
+@deffn {Scheme Procedure} char-set-xor! cs1 . rest
+@deffnx {C Function} scm_char_set_xor_x (cs1, rest)
+Return the exclusive-or of all argument character sets.
+@end deffn
+
+\fchar-set-diff+intersection!
+@c snarfed from srfi-14.c:1349
+@deffn {Scheme Procedure} char-set-diff+intersection! cs1 cs2 . rest
+@deffnx {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2, rest)
+Return the difference and the intersection of all argument
+character sets.
@end deffn
\fstring=?
-@deffn primitive string=? s1 s2
+@c snarfed from strorder.c:50
+@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
the same positions, otherwise return @code{#f}.
@end deffn
\fstring-ci=?
-@deffn primitive string-ci=? s1 s2
+@c snarfed from strorder.c:62
+@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
characters match (ignoring case) at each position; otherwise
@end deffn
\fstring<?
-@deffn primitive string<? s1 s2
+@c snarfed from strorder.c:72
+@deffn {Scheme Procedure} string<? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically less than @var{s2}.
@end deffn
\fstring<=?
-@deffn primitive string<=? s1 s2
+@c snarfed from strorder.c:82
+@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>?
-@deffn primitive string>? s1 s2
+@c snarfed from strorder.c:92
+@deffn {Scheme Procedure} string>? s1 s2
Lexicographic ordering predicate; return @code{#t} if @var{s1}
is lexicographically greater than @var{s2}.
@end deffn
\fstring>=?
-@deffn primitive string>=? s1 s2
+@c snarfed from strorder.c:102
+@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<?
-@deffn primitive string-ci<? s1 s2
+@c snarfed from strorder.c:113
+@deffn {Scheme Procedure} string-ci<? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than @var{s2}
regardless of case.
@end deffn
\fstring-ci<=?
-@deffn primitive string-ci<=? s1 s2
+@c snarfed from strorder.c:124
+@deffn {Scheme Procedure} string-ci<=? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically less than or equal
to @var{s2} regardless of case.
@end deffn
\fstring-ci>?
-@deffn primitive string-ci>? s1 s2
+@c snarfed from strorder.c:135
+@deffn {Scheme Procedure} string-ci>? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than
@var{s2} regardless of case.
@end deffn
\fstring-ci>=?
-@deffn primitive string-ci>=? s1 s2
+@c snarfed from strorder.c:146
+@deffn {Scheme Procedure} string-ci>=? s1 s2
Case insensitive lexicographic ordering predicate; return
@code{#t} if @var{s1} is lexicographically greater than or
equal to @var{s2} regardless of case.
@end deffn
\fobject->string
-@deffn primitive object->string obj [printer]
+@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}.
Printing function can be specified by the optional second
argument @var{printer} (default: @code{write}).
@end deffn
\fcall-with-output-string
-@deffn primitive call-with-output-string proc
+@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
port. When the function returns, the string composed of the characters
written into the port is returned.
@end deffn
\fcall-with-input-string
-@deffn primitive call-with-input-string string proc
+@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
created input port from which @var{string}'s contents may be
read. The value yielded by the @var{proc} is returned.
@end deffn
\fopen-input-string
-@deffn primitive open-input-string str
+@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
from the string. The port can be closed by
@code{close-input-port}, though its storage will be reclaimed
@end deffn
\fopen-output-string
-@deffn primitive open-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
retrieval by @code{get-output-string}. The port can be closed
by the procedure @code{close-output-port}, though its storage
@end deffn
\fget-output-string
-@deffn primitive get-output-string port
+@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},
return a string consisting of the characters that have been
output to the port so far.
@end deffn
\feval-string
-@deffn primitive eval-string 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
form or forms, and return whatever value they produce.
-Evaluation takes place in the environment returned by the
-procedure @code{interaction-environment}.
+Evaluation takes place in the given module, or the current
+module when no module is given.
+While the code is evaluated, the given module is made the
+current one. The current module is restored when this
+procedure returns.
@end deffn
\fmake-struct-layout
-@deffn primitive make-struct-layout fields
+@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.
@var{fields} must be a string made up of pairs of characters
@end deffn
\fstruct?
-@deffn primitive struct? x
+@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
@code{#f}.
@end deffn
\fstruct-vtable?
-@deffn primitive struct-vtable? x
+@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
-@deffn primitive make-struct vtable tail_array_size . init
+@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.
@var{type} must be a vtable structure (@pxref{Vtables}).
@end deffn
\fmake-vtable-vtable
-@deffn primitive make-vtable-vtable user_fields tail_array_size . init
+@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.
@var{user-fields} is a string describing user defined fields of the
@end deffn
\fstruct-ref
-@deffn primitive struct-ref handle pos
-@deffnx primitive struct-set! struct n value
+@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)
Access (or modify) the @var{n}th field of @var{struct}.
If the field is of type 'p', then it can be set to an arbitrary value.
@end deffn
\fstruct-set!
-@deffn primitive struct-set! handle pos val
+@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}
to @var{val}. Signal an error if the slot can not be written
to.
@end deffn
\fstruct-vtable
-@deffn primitive struct-vtable handle
+@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
-@deffn primitive struct-vtable-tag handle
+@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
-@deffn primitive struct-vtable-name vtable
+@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!
-@deffn primitive set-struct-vtable-name! 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?
-@deffn primitive symbol? obj
+@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
@code{#f}.
@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
+@code{#f}.
+@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
-@deffn primitive symbol->string s
+@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
part of an object returned as the value of a literal expression
(section @pxref{Literal expressions,,,r5rs, The Revised^5
@end deffn
\fstring->symbol
-@deffn primitive string->symbol string
+@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
can create symbols with names containing special characters or
letters in the non-standard case, but it is usually a bad idea
@end lisp
@end deffn
+\fstring-ci->symbol
+@c snarfed from symbols.c:252
+@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
+converted to lowercase before the conversion is done, if Guile
+is currently reading symbols case-insensitively.
+@end deffn
+
\fgensym
-@deffn primitive gensym [prefix]
+@c snarfed from symbols.c:269
+@deffn {Scheme Procedure} gensym [prefix]
+@deffnx {C Function} scm_gensym (prefix)
Create a new symbol with a name constructed from a prefix and
a counter value. The string @var{prefix} can be specified as
-an optional argument. Default prefix is @code{g}. The counter
+an optional argument. Default prefix is @code{ g}. The counter
is increased by 1 at each call. There is no provision for
resetting the counter.
@end deffn
\fsymbol-hash
-@deffn primitive symbol-hash symbol
+@c snarfed from symbols.c:295
+@deffn {Scheme Procedure} symbol-hash symbol
+@deffnx {C Function} scm_symbol_hash (symbol)
Return a hash value for @var{symbol}.
@end deffn
\fsymbol-fref
-@deffn primitive symbol-fref s
+@c snarfed from symbols.c:305
+@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
-@deffn primitive symbol-pref s
+@c snarfed from symbols.c:316
+@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!
-@deffn primitive symbol-fset! s val
+@c snarfed from symbols.c:327
+@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!
-@deffn primitive symbol-pset! s val
+@c snarfed from symbols.c:339
+@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:1105
+@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:1114
+@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:1129
+@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
-@deffn primitive catch key thunk handler
+@c snarfed from throw.c:510
+@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
exceptions matching @var{key}. If thunk throws to the symbol
@var{key}, then @var{handler} is invoked this way:
@end deffn
\flazy-catch
-@deffn primitive lazy-catch key thunk handler
+@c snarfed from throw.c:538
+@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
not unwind the stack before invoking @var{handler}.
The @var{handler} procedure is not allowed to return:
@end deffn
\fthrow
-@deffn primitive throw key . args
+@c snarfed from throw.c:571
+@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
@var{handler}.
@end deffn
\fvalues
-@deffn primitive values . args
+@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
continuations created by the @code{call-with-values} procedure,
all continuations take exactly one value. The effect of
@end deffn
\fmake-variable
-@deffn primitive make-variable init
+@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
-@deffn primitive make-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?
-@deffn primitive variable? obj
+@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
return @code{#f}.
@end deffn
\fvariable-ref
-@deffn primitive variable-ref var
+@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.
@var{var} must be a variable object; see @code{make-variable}
and @code{make-undefined-variable}.
@end deffn
\fvariable-set!
-@deffn primitive variable-set! var val
+@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}.
@var{var} must be a variable object, @var{val} can be any
value. Return an unspecified value.
@end deffn
\fvariable-bound?
-@deffn primitive variable-bound? var
+@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.
Throws an error if @var{var} is not a variable object.
@end deffn
\fvector?
-@deffn primitive vector? obj
+@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
@code{#f}.
@end deffn
\flist->vector
-@deffn primitive list->vector
+@c snarfed from vectors.c:52
+@deffn {Scheme Procedure} list->vector
implemented by the C function "scm_vector"
@end deffn
\fvector
-@deffn primitive vector . l
-@deffnx primitive list->vector l
-Return a newly allocated vector whose elements contain the
+@c snarfed from vectors.c:69
+@deffn {Scheme Procedure} vector . l
+@deffnx {Scheme Procedure} list->vector l
+@deffnx {C Function} scm_vector (l)
+Return a newly allocated vector composed of the
given arguments. Analogous to @code{list}.
@lisp
@end deffn
\fmake-vector
-@deffn primitive make-vector k [fill]
+@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
-second argument is given, then each element is initialized to
-@var{fill}. Otherwise the initial contents of each element is
+second argument is given, then each position is initialized to
+@var{fill}. Otherwise the initial contents of each position is
unspecified.
@end deffn
\fvector->list
-@deffn primitive vector->list v
-Return a newly allocated list of the objects contained in the
-elements of @var{vector}.
+@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}.
@lisp
(vector->list '#(dah dah didah)) @result{} (dah dah didah)
@end deffn
\fvector-fill!
-@deffn primitive vector-fill! v fill
-Store @var{fill} in every element of @var{vector}. The value
+@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
returned by @code{vector-fill!} is unspecified.
@end deffn
\fvector-move-left!
-@deffn primitive vector-move-left! vec1 start1 end1 vec2 start2
-Vector version of @code{substring-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},
+to @var{vec2} starting at position @var{start2}. @var{start1} and
+@var{start2} are inclusive indices; @var{end1} is exclusive.
+
+@code{vector-move-left!} copies elements in leftmost order.
+Therefore, in the case where @var{vec1} and @var{vec2} refer to the
+same vector, @code{vector-move-left!} is usually appropriate when
+@var{start1} is greater than @var{start2}.
@end deffn
\fvector-move-right!
-@deffn primitive vector-move-right! vec1 start1 end1 vec2 start2
-Vector version of @code{substring-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},
+to @var{vec2} starting at position @var{start2}. @var{start1} and
+@var{start2} are inclusive indices; @var{end1} is exclusive.
+
+@code{vector-move-right!} copies elements in rightmost order.
+Therefore, in the case where @var{vec1} and @var{vec2} refer to the
+same vector, @code{vector-move-right!} is usually appropriate when
+@var{start1} is less than @var{start2}.
@end deffn
\fmajor-version
-@deffn primitive major-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.
E.g., the 1 in "1.6.5".
@end deffn
\fminor-version
-@deffn primitive minor-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.
E.g., the 6 in "1.6.5".
@end deffn
\fmicro-version
-@deffn primitive micro-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.
E.g., the 5 in "1.6.5".
@end deffn
\fversion
-@deffn primitive version
-@deffnx primitive major-version
-@deffnx primitive minor-version
-@deffnx primitive micro-version
+@c snarfed from version.c:83
+@deffn {Scheme Procedure} version
+@deffnx {Scheme Procedure} major-version
+@deffnx {Scheme Procedure} minor-version
+@deffnx {Scheme Procedure} micro-version
+@deffnx {C Function} scm_version ()
Return a string describing Guile's version number, or its major, minor
or micro version number, respectively.
@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
-@deffn primitive make-soft-port pv modes
+@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
specified by the @var{modes} string (@pxref{File Ports,
-open-file}). @var{pv} must be a vector of length 5. Its
+open-file}). @var{pv} must be a vector of length 5 or 6. Its
components are as follows:
@enumerate 0
thunk for getting one character
@item
thunk for closing port (not by garbage collection)
+@item
+(if present and not @code{#f}) thunk for computing the number of
+characters that can be read from the port without blocking.
@end enumerate
For an output-only port only elements 0, 1, 2, and 4 need be
@end deffn
\fmake-weak-vector
-@deffn primitive make-weak-vector size [fill]
+@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
argument @var{fill} is given, all entries in the vector will be
set to @var{fill}. The default value for @var{fill} is the
@end deffn
\flist->weak-vector
-@deffn primitive list->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
-@deffn primitive weak-vector . l
-@deffnx primitive list->weak-vector l
+@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)
Construct a weak vector from a list: @code{weak-vector} uses
the list of its arguments while @code{list->weak-vector} uses
its only argument @var{l} (a list) to construct a weak vector
@end deffn
\fweak-vector?
-@deffn primitive weak-vector? obj
+@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 primitive make-weak-key-hash-table size
-@deffnx primitive make-weak-value-hash-table size
-@deffnx primitive make-doubly-weak-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 primitive 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 primitive 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 primitive weak-key-hash-table? obj
-@deffnx primitive weak-value-hash-table? obj
-@deffnx primitive doubly-weak-hash-table? 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 primitive weak-value-hash-table? 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 primitive doubly-weak-hash-table? 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
-\fregexp?
-@deffn primitive regexp? obj
-Return @code{#t} if @var{obj} is a compiled regular expression,
+\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
+@var{filename} and link it into the running Guile
+application. The returned
+scheme object is a ``handle'' for the library which can
+be passed to @code{dynamic-func}, @code{dynamic-call} etc.
+
+Searching for object files is system dependent. Normally,
+if @var{filename} does have an explicit directory it will
+be searched for in locations
+such as @file{/usr/lib} and @file{/usr/local/lib}.
+@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,
or @code{#f} otherwise.
@end deffn
-\fmake-regexp
-@deffn primitive make-regexp pat . flags
-Compile the regular expression described by @var{pat}, and
-return the compiled regexp structure. If @var{pat} does not
-describe a legal regular expression, @code{make-regexp} throws
-a @code{regular-expression-syntax} error.
+\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
+object must have been linked by @code{dynamic-link}, with
+@var{dobj} the corresponding handle. After this procedure
+is called, the handle can no longer be used to access the
+object.
+@end deffn
-The @var{flags} arguments change the behavior of the compiled
-regular expression. The following flags may be supplied:
+\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
+shared object referred to by @var{dobj}. The handle
+can be passed to @code{dynamic-call} to actually
+call the function.
-@table @code
-@item regexp/icase
-Consider uppercase and lowercase letters to be the same when
-matching.
-@item regexp/newline
-If a newline appears in the target string, then permit the
-@samp{^} and @samp{$} operators to match immediately after or
-immediately before the newline, respectively. Also, the
-@samp{.} and @samp{[^...]} operators will never match a newline
-character. The intent of this flag is to treat the target
-string as a buffer containing many lines of text, and the
-regular expression as a pattern that may match a single one of
-those lines.
-@item regexp/basic
-Compile a basic (``obsolete'') regexp instead of the extended
-(``modern'') regexps that are the default. Basic regexps do
-not consider @samp{|}, @samp{+} or @samp{?} to be special
-characters, and require the @samp{@{...@}} and @samp{(...)}
-metacharacters to be backslash-escaped (@pxref{Backslash
-Escapes}). There are several other differences between basic
-and extended regular expressions, but these are the most
-significant.
-@item regexp/extended
-Compile an extended regular expression rather than a basic
-regexp. This is the default behavior; this flag will not
-usually be needed. If a call to @code{make-regexp} includes
-both @code{regexp/basic} and @code{regexp/extended} flags, the
-one which comes last will override the earlier one.
-@end table
+Regardless whether your C compiler prepends an underscore
+@samp{_} to the global names in a program, you should
+@strong{not} include this underscore in @var{name}
+since it will be added automatically when necessary.
@end deffn
-\fregexp-exec
-@deffn primitive regexp-exec rx str [start [flags]]
-Match the compiled regular expression @var{rx} against
-@code{str}. If the optional integer @var{start} argument is
-provided, begin matching from that position in the string.
-Return a match structure describing the results of the match,
-or @code{#f} if no match could be found.
+\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
+invocation are supported:
+
+@itemize @bullet
+@item @var{func} can be a function handle returned by
+@code{dynamic-func}. In this case @var{dobj} is
+ignored
+@item @var{func} can be a string with the name of the
+function to call, with @var{dobj} the handle of the
+dynamic object in which to find the function.
+This is equivalent to
+@smallexample
-The @var{flags} arguments change the matching behavior.
-The following flags may be supplied:
+(dynamic-call (dynamic-func @var{func} @var{dobj}) #f)
+@end smallexample
+@end itemize
-@table @code
-@item regexp/notbol
-Operator @samp{^} always fails (unless @code{regexp/newline}
-is used). Use this when the beginning of the string should
-not be considered the beginning of a line.
-@item regexp/noteol
-Operator @samp{$} always fails (unless @code{regexp/newline}
-is used). Use this when the end of the string should not be
-considered the end of a line.
-@end table
+In either case, the function is passed no arguments
+and its return value is ignored.
+@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},
+just like @code{dynamic-call}, but pass it some arguments and
+return its return value. The C function is expected to take
+two arguments and return an @code{int}, just like @code{main}:
+@smallexample
+int c_func (int argc, char **argv);
+@end smallexample
+
+The parameter @var{args} must be a list of strings and is
+converted into an array of @code{char *}. The array is passed
+in @var{argv} and its size in @var{argc}. The return value is
+converted to a Scheme number and returned from the call to
+@code{dynamic-args-call}.
@end deffn
\farray-fill!
-@deffn primitive array-fill! ra fill
-Stores @var{fill} in every element of @var{array}. The value returned
+@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
is unspecified.
@end deffn
\farray-copy-in-order!
-@deffn primitive array-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!
-@deffn primitive array-copy! src dst
-@deffnx primitive array-copy-in-order! src dst
-Copies every element from vector or array @var{source} to the
+@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)
+Copy every element from vector or array @var{source} to the
corresponding element of @var{destination}. @var{destination} must have
the same rank as @var{source}, and be at least as large in each
dimension. The order is unspecified.
@end deffn
\farray-map-in-order!
-@deffn primitive array-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!
-@deffn primitive array-map! ra0 proc . lra
-@deffnx primitive array-map-in-order! ra0 proc . lra
+@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)
@var{array1}, @dots{} must have the same number of dimensions as
@var{array0} and have a range for each index which includes the range
for the corresponding index in @var{array0}. @var{proc} is applied to
@end deffn
\farray-for-each
-@deffn primitive array-for-each proc ra0 . lra
-@var{proc} is applied to each tuple of elements of @var{array0} @dots{}
+@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{}
in row-major order. The value returned is unspecified.
@end deffn
\farray-index-map!
-@deffn primitive array-index-map! ra proc
-applies @var{proc} to the indices of each element of @var{array} in
+@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
turn, storing the result in the corresponding element. The value
returned and the order of application are unspecified.
@end deffn
\funiform-vector-length
-@deffn primitive uniform-vector-length v
+@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?
-@deffn primitive array? v [prot]
+@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
not. The @var{prototype} argument is used with uniform arrays
and is described elsewhere.
@end deffn
\farray-rank
-@deffn primitive array-rank ra
+@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
not an array, @code{0} is returned.
@end deffn
\farray-dimensions
-@deffn primitive array-dimensions ra
+@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
elements with a @code{0} minimum with one greater than the maximum. So:
@lisp
@end deffn
\fshared-array-root
-@deffn primitive shared-array-root ra
+@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
-@deffn primitive shared-array-offset ra
+@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
-@deffn primitive shared-array-increments ra
+@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
-@deffn primitive dimensions->uniform-array dims prot [fill]
-@deffnx primitive make-uniform-vector length prototype [fill]
+@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)
Create and return a uniform array or vector of type
corresponding to @var{prototype} with dimensions @var{dims} or
length @var{length}. If @var{fill} is supplied, it's used to
@end deffn
\fmake-shared-array
-@deffn primitive make-shared-array oldra mapfunc . dims
+@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
arrays. The @var{mapper} is a function that translates coordinates in
the new array into coordinates in the old array. A @var{mapper} must be
@end deffn
\ftranspose-array
-@deffn primitive transpose-array ra . args
+@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
dimensions arranged in a different order. There must be one
@var{dim} argument for each dimension of @var{array}.
@end deffn
\fenclose-array
-@deffn primitive enclose-array ra . axes
+@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
the rank of @var{array}. @var{enclose-array} returns an array
resembling an array of shared arrays. The dimensions of each shared
@end deffn
\farray-in-bounds?
-@deffn primitive array-in-bounds? v . args
+@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
@code{array-ref}.
@end deffn
\farray-ref
-@deffn primitive array-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
-@deffn primitive uniform-vector-ref v args
-@deffnx primitive array-ref v . args
+@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)
Return the element at the @code{(index1, index2)} element in
@var{array}.
@end deffn
\funiform-array-set1!
-@deffn primitive uniform-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!
-@deffn primitive array-set! v obj . args
-@deffnx primitive uniform-array-set1! v obj args
-Sets the element at the @code{(index1, index2)} element in @var{array} to
+@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)
+Set the element at the @code{(index1, index2)} element in @var{array} to
@var{new-value}. The value returned by array-set! is unspecified.
@end deffn
\farray-contents
-@deffn primitive array-contents ra [strict]
-@deffnx primitive array-contents array strict
+@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
without changing their order (last subscript changing fastest), then
@code{array-contents} returns that shared array, otherwise it returns
@end deffn
\funiform-array-read!
-@deffn primitive uniform-array-read! ra [port_or_fd [start [end]]]
-@deffnx primitive uniform-vector-read! uve [port-or-fdes] [start] [end]
-Attempts to read all elements of @var{ura}, in lexicographic order, as
+@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)
+Attempt to read all elements of @var{ura}, in lexicographic order, as
binary objects from @var{port-or-fdes}.
-If an end of file is encountered during
-uniform-array-read! the objects up to that point only are put into @var{ura}
+If an end of file is encountered,
+the objects up to that point are put into @var{ura}
(starting at the beginning) and the remainder of the array is
unchanged.
@end deffn
\funiform-array-write
-@deffn primitive uniform-array-write v [port_or_fd [start [end]]]
-@deffnx primitive uniform-vector-write uve [port-or-fdes] [start] [end]
+@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)
Writes all elements of @var{ura} as binary objects to
@var{port-or-fdes}.
@end deffn
\fbit-count
-@deffn primitive bit-count b bitvector
+@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
@var{bitvector}.
@end deffn
\fbit-position
-@deffn primitive 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.
+@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 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*!
-@deffn primitive bit-set*! 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}.
+@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)
+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 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*
-@deffn primitive bit-count* 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.
+@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 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!
-@deffn primitive bit-invert! v
-Modifies @var{bv} by replacing each element with its negation.
+@c snarfed from unif.c:2021
+@deffn {Scheme Procedure} bit-invert! v
+@deffnx {C Function} scm_bit_invert_x (v)
+Modify the bit vector @var{v} by replacing each element with
+its negation.
@end deffn
\farray->list
-@deffn primitive array->list v
+@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
@var{array}.
@end deffn
\flist->uniform-array
-@deffn primitive list->uniform-array ndim prot lst
-@deffnx procedure list->uniform-vector prot lst
+@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)
Return a uniform array of the type indicated by prototype
@var{prot} with elements the same as those of @var{lst}.
Elements must be of the appropriate type, no coercions are
@end deffn
\farray-prototype
-@deffn primitive array-prototype ra
+@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
as @var{array}, if used as the @var{prototype} for
@code{make-uniform-array}.
@end deffn
\fchown
-@deffn primitive chown object owner group
+@c snarfed from filesys.c:224
+@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
the integer values @var{owner} and @var{group}. @var{object} can be
a string containing a file name or, if the platform
@end deffn
\fchmod
-@deffn primitive chmod object mode
+@c snarfed from filesys.c:262
+@deffn {Scheme Procedure} chmod object mode
+@deffnx {C Function} scm_chmod (object, mode)
Changes the permissions of the file referred to by @var{obj}.
@var{obj} can be a string containing a file name or a port or integer file
descriptor which is open on a file (in which case @code{fchmod} is used
@end deffn
\fumask
-@deffn primitive umask [mode]
-If @var{mode} is omitted, retuns a decimal number representing the current
+@c snarfed from filesys.c:294
+@deffn {Scheme Procedure} umask [mode]
+@deffnx {C Function} scm_umask (mode)
+If @var{mode} is omitted, returns a decimal number representing the current
file creation mask. Otherwise the file creation mask is set to
@var{mode} and the previous value is returned.
@end deffn
\fopen-fdes
-@deffn primitive open-fdes path flags [mode]
+@c snarfed from filesys.c:316
+@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
a port.
@end deffn
\fopen
-@deffn primitive open path flags [mode]
+@c snarfed from filesys.c:357
+@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.
@var{flags} is an integer specifying how the file should be opened.
@var{mode} is an integer specifying the permission bits of the file, if
@end deffn
\fclose
-@deffn primitive close fd_or_port
-Similar to close-port (@pxref{Generic Port Operations, close-port}),
+@c snarfed from filesys.c:395
+@deffn {Scheme Procedure} close fd_or_port
+@deffnx {C Function} scm_close (fd_or_port)
+Similar to close-port (@pxref{Closing, close-port}),
but also works on file descriptors. A side
effect of closing a file descriptor is that any ports using that file
descriptor are moved to a different file descriptor and have
@end deffn
\fclose-fdes
-@deffn primitive close-fdes fd
+@c snarfed from filesys.c:422
+@deffn {Scheme Procedure} close-fdes fd
+@deffnx {C Function} scm_close_fdes (fd)
A simple wrapper for the @code{close} system call.
Close file descriptor @var{fd}, which must be an integer.
Unlike close (@pxref{Ports and File Descriptors, close}),
@end deffn
\fstat
-@deffn primitive stat object
+@c snarfed from filesys.c:624
+@deffn {Scheme Procedure} stat object
+@deffnx {C Function} scm_stat (object)
Return an object containing various information about the file
determined by @var{obj}. @var{obj} can be a string containing
a file name or a port or integer file descriptor which is open
@end deffn
\flink
-@deffn primitive link oldpath newpath
+@c snarfed from filesys.c:686
+@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
file named by @var{oldpath}. If @var{oldpath} is a symbolic
link, the link may or may not be followed depending on the
@end deffn
\frename-file
-@deffn primitive rename-file oldname newname
+@c snarfed from filesys.c:724
+@deffn {Scheme Procedure} rename-file oldname newname
+@deffnx {C Function} scm_rename (oldname, newname)
Renames the file specified by @var{oldname} to @var{newname}.
The return value is unspecified.
@end deffn
\fdelete-file
-@deffn primitive delete-file str
+@c snarfed from filesys.c:741
+@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
-@deffn primitive mkdir path [mode]
+@c snarfed from filesys.c:758
+@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
then the permissions of the directory file are set using the current
umask. Otherwise they are set to the decimal value specified with
@end deffn
\frmdir
-@deffn primitive rmdir path
+@c snarfed from filesys.c:785
+@deffn {Scheme Procedure} rmdir path
+@deffnx {C Function} scm_rmdir (path)
Remove the existing directory named by @var{path}. The directory must
be empty for this to succeed. The return value is unspecified.
@end deffn
\fdirectory-stream?
-@deffn primitive directory-stream? obj
+@c snarfed from filesys.c:809
+@deffn {Scheme Procedure} directory-stream? obj
+@deffnx {C Function} scm_directory_stream_p (obj)
Return a boolean indicating whether @var{object} is a directory
stream as returned by @code{opendir}.
@end deffn
\fopendir
-@deffn primitive opendir dirname
+@c snarfed from filesys.c:820
+@deffn {Scheme Procedure} opendir dirname
+@deffnx {C Function} scm_opendir (dirname)
Open the directory specified by @var{path} and return a directory
stream.
@end deffn
\freaddir
-@deffn primitive readdir port
+@c snarfed from filesys.c:841
+@deffn {Scheme Procedure} readdir port
+@deffnx {C Function} scm_readdir (port)
Return (as a string) the next directory entry from the directory stream
@var{stream}. If there is no remaining entry to be read then the
end of file object is returned.
@end deffn
\frewinddir
-@deffn primitive rewinddir port
+@c snarfed from filesys.c:880
+@deffn {Scheme Procedure} rewinddir port
+@deffnx {C Function} scm_rewinddir (port)
Reset the directory port @var{stream} so that the next call to
@code{readdir} will return the first directory entry.
@end deffn
\fclosedir
-@deffn primitive closedir port
+@c snarfed from filesys.c:897
+@deffn {Scheme Procedure} closedir port
+@deffnx {C Function} scm_closedir (port)
Close the directory stream @var{stream}.
The return value is unspecified.
@end deffn
\fchdir
-@deffn primitive chdir str
+@c snarfed from filesys.c:947
+@deffn {Scheme Procedure} chdir str
+@deffnx {C Function} scm_chdir (str)
Change the current working directory to @var{path}.
The return value is unspecified.
@end deffn
\fgetcwd
-@deffn primitive getcwd
+@c snarfed from filesys.c:962
+@deffn {Scheme Procedure} getcwd
+@deffnx {C Function} scm_getcwd ()
Return the name of the current working directory.
@end deffn
\fselect
-@deffn primitive select reads writes excepts [secs [usecs]]
+@c snarfed from filesys.c:1163
+@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
-to provide input, accept output, or the existance of
+to provide input, accept output, or the existence of
exceptional conditions on a collection of ports or file
descriptors, or waiting for a timeout to occur.
It also returns if interrupted by a signal.
@end deffn
\ffcntl
-@deffn primitive fcntl object cmd [value]
+@c snarfed from filesys.c:1301
+@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
file descriptor of the specified port. @var{value} is an optional
integer argument.
@end deffn
\ffsync
-@deffn primitive fsync object
+@c snarfed from filesys.c:1333
+@deffn {Scheme Procedure} fsync object
+@deffnx {C Function} scm_fsync (object)
Copies any unwritten data for the specified output file descriptor to disk.
If @var{port/fd} is a port, its buffer is flushed before the underlying
file descriptor is fsync'd.
@end deffn
\fsymlink
-@deffn primitive symlink oldpath newpath
+@c snarfed from filesys.c:1358
+@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)
@var{path-from}. The return value is unspecified.
@end deffn
\freadlink
-@deffn primitive readlink path
+@c snarfed from filesys.c:1377
+@deffn {Scheme Procedure} readlink path
+@deffnx {C Function} scm_readlink (path)
Return the value of the symbolic link named by @var{path} (a
string), i.e., the file that the link points to.
@end deffn
\flstat
-@deffn primitive lstat str
+@c snarfed from filesys.c:1419
+@deffn {Scheme Procedure} lstat str
+@deffnx {C Function} scm_lstat (str)
Similar to @code{stat}, but does not follow symbolic links, i.e.,
it will return information about a symbolic link itself, not the
file it points to. @var{path} must be a string.
@end deffn
\fcopy-file
-@deffn primitive copy-file oldfile newfile
+@c snarfed from filesys.c:1442
+@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}.
The return value is unspecified.
@end deffn
\fdirname
-@deffn primitive dirname filename
+@c snarfed from filesys.c:1505
+@deffn {Scheme Procedure} dirname filename
+@deffnx {C Function} scm_dirname (filename)
Return the directory name component of the file name
@var{filename}. If @var{filename} does not contain a directory
component, @code{.} is returned.
@end deffn
\fbasename
-@deffn primitive basename filename [suffix]
+@c snarfed from filesys.c:1548
+@deffn {Scheme Procedure} basename filename [suffix]
+@deffnx {C Function} scm_basename (filename, suffix)
Return the base name of the file name @var{filename}. The
base name is the file name without any directory components.
-If @var{suffix} is privided, and is equal to the end of
+If @var{suffix} is provided, and is equal to the end of
@var{basename}, it is removed also.
@end deffn
\fpipe
-@deffn primitive pipe
+@c snarfed from posix.c:232
+@deffn {Scheme Procedure} pipe
+@deffnx {C Function} scm_pipe ()
Return a newly created pipe: a pair of ports which are linked
together on the local machine. The @emph{car} is the input
port and the @emph{cdr} is the output port. Data written (and
@end deffn
\fgetgroups
-@deffn primitive getgroups
+@c snarfed from posix.c:253
+@deffn {Scheme Procedure} getgroups
+@deffnx {C Function} scm_getgroups ()
Return a vector of integers representing the current
-supplimentary group IDs.
+supplementary group IDs.
+@end deffn
+
+\fsetgroups
+@c snarfed from posix.c:286
+@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
-@deffn primitive getpw [user]
+@c snarfed from posix.c:334
+@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,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
@end deffn
\fsetpw
-@deffn primitive setpw [arg]
+@c snarfed from posix.c:384
+@deffn {Scheme Procedure} setpw [arg]
+@deffnx {C Function} scm_setpwent (arg)
If called with a true argument, initialize or reset the password data
stream. Otherwise, close the stream. The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
@end deffn
\fgetgr
-@deffn primitive getgr [name]
+@c snarfed from posix.c:403
+@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,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
@end deffn
\fsetgr
-@deffn primitive setgr [arg]
+@c snarfed from posix.c:439
+@deffn {Scheme Procedure} setgr [arg]
+@deffnx {C Function} scm_setgrent (arg)
If called with a true argument, initialize or reset the group data
stream. Otherwise, close the stream. The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
@end deffn
\fkill
-@deffn primitive kill pid sig
+@c snarfed from posix.c:475
+@deffn {Scheme Procedure} kill pid sig
+@deffnx {C Function} scm_kill (pid, sig)
Sends a signal to the specified process or group of processes.
@var{pid} specifies the processes to which the signal is sent:
@end deffn
\fwaitpid
-@deffn primitive waitpid pid [options]
+@c snarfed from posix.c:526
+@deffn {Scheme Procedure} waitpid pid [options]
+@deffnx {C Function} scm_waitpid (pid, options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped. Normally it will
suspend the calling process until this can be done. If more than one
@end deffn
\fstatus:exit-val
-@deffn primitive status:exit-val status
+@c snarfed from posix.c:552
+@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
ended normally through a call to @code{exit} or @code{_exit},
if any, otherwise @code{#f}.
@end deffn
\fstatus:term-sig
-@deffn primitive status:term-sig status
+@c snarfed from posix.c:570
+@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,
otherwise @code{#f}.
@end deffn
\fstatus:stop-sig
-@deffn primitive status:stop-sig status
+@c snarfed from posix.c:586
+@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,
otherwise @code{#f}.
@end deffn
\fgetppid
-@deffn primitive getppid
+@c snarfed from posix.c:604
+@deffn {Scheme Procedure} getppid
+@deffnx {C Function} scm_getppid ()
Return an integer representing the process ID of the parent
process.
@end deffn
\fgetuid
-@deffn primitive getuid
+@c snarfed from posix.c:616
+@deffn {Scheme Procedure} getuid
+@deffnx {C Function} scm_getuid ()
Return an integer representing the current real user ID.
@end deffn
\fgetgid
-@deffn primitive getgid
+@c snarfed from posix.c:627
+@deffn {Scheme Procedure} getgid
+@deffnx {C Function} scm_getgid ()
Return an integer representing the current real group ID.
@end deffn
\fgeteuid
-@deffn primitive geteuid
+@c snarfed from posix.c:641
+@deffn {Scheme Procedure} geteuid
+@deffnx {C Function} scm_geteuid ()
Return an integer representing the current effective user ID.
If the system does not support effective IDs, then the real ID
-is returned. @code{(feature? 'EIDs)} reports whether the
+is returned. @code{(provided? 'EIDs)} reports whether the
system supports effective IDs.
@end deffn
\fgetegid
-@deffn primitive getegid
+@c snarfed from posix.c:658
+@deffn {Scheme Procedure} getegid
+@deffnx {C Function} scm_getegid ()
Return an integer representing the current effective group ID.
If the system does not support effective IDs, then the real ID
-is returned. @code{(feature? 'EIDs)} reports whether the
+is returned. @code{(provided? 'EIDs)} reports whether the
system supports effective IDs.
@end deffn
\fsetuid
-@deffn primitive setuid id
+@c snarfed from posix.c:674
+@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
the process has appropriate privileges.
The return value is unspecified.
@end deffn
\fsetgid
-@deffn primitive setgid id
+@c snarfed from posix.c:687
+@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
the process has appropriate privileges.
The return value is unspecified.
@end deffn
\fseteuid
-@deffn primitive seteuid id
+@c snarfed from posix.c:702
+@deffn {Scheme Procedure} seteuid id
+@deffnx {C Function} scm_seteuid (id)
Sets the effective user ID to the integer @var{id}, provided the process
has appropriate privileges. If effective IDs are not supported, the
-real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
+real ID is set instead -- @code{(provided? 'EIDs)} reports whether the
system supports effective IDs.
The return value is unspecified.
@end deffn
\fsetegid
-@deffn primitive setegid id
+@c snarfed from posix.c:727
+@deffn {Scheme Procedure} setegid id
+@deffnx {C Function} scm_setegid (id)
Sets the effective group ID to the integer @var{id}, provided the process
has appropriate privileges. If effective IDs are not supported, the
-real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
+real ID is set instead -- @code{(provided? 'EIDs)} reports whether the
system supports effective IDs.
The return value is unspecified.
@end deffn
\fgetpgrp
-@deffn primitive getpgrp
+@c snarfed from posix.c:750
+@deffn {Scheme Procedure} getpgrp
+@deffnx {C Function} scm_getpgrp ()
Return an integer representing the current process group ID.
This is the POSIX definition, not BSD.
@end deffn
\fsetpgid
-@deffn primitive setpgid pid pgid
+@c snarfed from posix.c:768
+@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
@var{pgid} must be integers: they can be zero to indicate the ID of the
current process.
@end deffn
\fsetsid
-@deffn primitive setsid
+@c snarfed from posix.c:785
+@deffn {Scheme Procedure} setsid
+@deffnx {C Function} scm_setsid ()
Creates a new session. The current process becomes the session leader
and is put in a new process group. The process will be detached
from its controlling terminal if it has one.
@end deffn
\fttyname
-@deffn primitive ttyname port
+@c snarfed from posix.c:809
+@deffn {Scheme Procedure} ttyname port
+@deffnx {C Function} scm_ttyname (port)
Return a string with the name of the serial terminal device
underlying @var{port}.
@end deffn
\fctermid
-@deffn primitive ctermid
+@c snarfed from posix.c:848
+@deffn {Scheme Procedure} ctermid
+@deffnx {C Function} scm_ctermid ()
Return a string containing the file name of the controlling
terminal for the current process.
@end deffn
\ftcgetpgrp
-@deffn primitive tcgetpgrp port
+@c snarfed from posix.c:872
+@deffn {Scheme Procedure} tcgetpgrp port
+@deffnx {C Function} scm_tcgetpgrp (port)
Return the process group ID of the foreground process group
associated with the terminal open on the file descriptor
underlying @var{port}.
@end deffn
\ftcsetpgrp
-@deffn primitive tcsetpgrp port pgid
+@c snarfed from posix.c:896
+@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
descriptor underlying @var{port} to the integer @var{pgid}.
The calling process
@end deffn
\fexecl
-@deffn primitive execl filename . args
+@c snarfed from posix.c:928
+@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.
The remaining arguments are supplied to the process; from a C program
-they are accessable as the @code{argv} argument to @code{main}.
+they are accessible as the @code{argv} argument to @code{main}.
Conventionally the first @var{arg} is the same as @var{path}.
-All arguments must be strings.
+All arguments must be strings.
If @var{arg} is missing, @var{path} is executed with a null
argument list, which may have system-dependent side-effects.
@end deffn
\fexeclp
-@deffn primitive execlp filename . args
+@c snarfed from posix.c:959
+@deffn {Scheme Procedure} execlp filename . args
+@deffnx {C Function} scm_execlp (filename, args)
Similar to @code{execl}, however if
@var{filename} does not contain a slash
then the file to execute will be located by searching the
@end deffn
\fexecle
-@deffn primitive execle filename env . args
+@c snarfed from posix.c:993
+@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
specified by @var{env}, which must be a list of strings as returned by the
@code{environ} procedure.
@end deffn
\fprimitive-fork
-@deffn primitive primitive-fork
+@c snarfed from posix.c:1029
+@deffn {Scheme Procedure} primitive-fork
+@deffnx {C Function} scm_fork ()
Creates a new "child" process by duplicating the current "parent" process.
In the child the return value is 0. In the parent the return value is
the integer process ID of the child.
@end deffn
\funame
-@deffn primitive uname
+@c snarfed from posix.c:1049
+@deffn {Scheme Procedure} uname
+@deffnx {C Function} scm_uname ()
Return an object with some information about the computer
system the program is running on.
@end deffn
\fenviron
-@deffn primitive environ [env]
+@c snarfed from posix.c:1078
+@deffn {Scheme Procedure} environ [env]
+@deffnx {C Function} scm_environ (env)
If @var{env} is omitted, return the current environment (in the
Unix sense) as a list of strings. Otherwise set the current
environment, which is also the default environment for child
@end deffn
\ftmpnam
-@deffn primitive tmpnam
+@c snarfed from posix.c:1111
+@deffn {Scheme Procedure} tmpnam
+@deffnx {C Function} scm_tmpnam ()
Return a name in the file system that does not match any
existing file. However there is no guarantee that another
process will not create the file after @code{tmpnam} is called.
@end deffn
\fmkstemp!
-@deffn primitive mkstemp! tmpl
+@c snarfed from posix.c:1137
+@deffn {Scheme Procedure} mkstemp! tmpl
+@deffnx {C Function} scm_mkstemp (tmpl)
Create a new unique file in the file system and returns a new
buffered port open for reading and writing to the file.
@var{tmpl} is a string specifying where the file should be
@end deffn
\futime
-@deffn primitive utime pathname [actime [modtime]]
+@c snarfed from posix.c:1172
+@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
file named by @var{path}. If @var{actime} or @var{modtime} is
not supplied, then the current time is used. @var{actime} and
@end deffn
\faccess?
-@deffn primitive access? path how
-Return @code{#t} if @var{path} corresponds to an existing file
-and the current process has the type of access specified by
-@var{how}, otherwise @code{#f}. @var{how} should be specified
-using the values of the variables listed below. Multiple
-values can be combined using a bitwise or, in which case
-@code{#t} will only be returned if all accesses are granted.
-
-Permissions are checked using the real id of the current
-process, not the effective id, although it's the effective id
-which determines whether the access would actually be granted.
+@c snarfed from posix.c:1237
+@deffn {Scheme Procedure} access? path how
+@deffnx {C Function} scm_access (path, how)
+Test accessibility of a file under the real UID and GID of the
+calling process. The return is @code{#t} if @var{path} exists
+and the permissions requested by @var{how} are all allowed, or
+@code{#f} if not.
+
+@var{how} is an integer which is one of the following values,
+or a bitwise-OR (@code{logior}) of multiple values.
@defvar R_OK
-test for read permission.
+Test for read permission.
@end defvar
@defvar W_OK
-test for write permission.
+Test for write permission.
@end defvar
@defvar X_OK
-test for execute permission.
+Test for execute permission.
@end defvar
@defvar F_OK
-test for existence of the file.
+Test for existence of the file. This is implied by each of the
+other tests, so there's no need to combine it with them.
@end defvar
+
+It's important to note that @code{access?} does not simply
+indicate what will happen on attempting to read or write a
+file. In normal circumstances it does, but in a set-UID or
+set-GID program it doesn't because @code{access?} tests the
+real ID, whereas an open or execute attempt uses the effective
+ID.
+
+A program which will never run set-UID/GID can ignore the
+difference between real and effective IDs, but for maximum
+generality, especially in library functions, it's best not to
+use @code{access?} to predict the result of an open or execute,
+instead simply attempt that and catch any exception.
+
+The main use for @code{access?} is to let a set-UID/GID program
+determine what the invoking user would have been allowed to do,
+without the greater (or perhaps lesser) privileges afforded by
+the effective ID. For more on this, see ``Testing File
+Access'' in The GNU C Library Reference Manual.
@end deffn
\fgetpid
-@deffn primitive getpid
+@c snarfed from posix.c:1250
+@deffn {Scheme Procedure} getpid
+@deffnx {C Function} scm_getpid ()
Return an integer representing the current process ID.
@end deffn
\fputenv
-@deffn primitive putenv str
+@c snarfed from posix.c:1267
+@deffn {Scheme Procedure} putenv str
+@deffnx {C Function} scm_putenv (str)
Modifies the environment of the current process, which is
also the default environment inherited by child processes.
@end deffn
\fsetlocale
-@deffn primitive setlocale category [locale]
+@c snarfed from posix.c:1351
+@deffn {Scheme Procedure} setlocale category [locale]
+@deffnx {C Function} scm_setlocale (category, locale)
If @var{locale} is omitted, return the current value of the
specified locale category as a system-dependent string.
@var{category} should be specified using the values
Otherwise the specified locale category is set to the string
@var{locale} and the new value is returned as a
system-dependent string. If @var{locale} is an empty string,
-the locale will be set using envirionment variables.
+the locale will be set using environment variables.
@end deffn
\fmknod
-@deffn primitive mknod path type perms dev
+@c snarfed from posix.c:1394
+@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.
@var{path} specifies the name of the file. @var{type} should
be one of the following symbols:
@end deffn
\fnice
-@deffn primitive nice incr
+@c snarfed from posix.c:1440
+@deffn {Scheme Procedure} nice incr
+@deffnx {C Function} scm_nice (incr)
Increment the priority of the current process by @var{incr}. A higher
priority value means that the process runs less often.
The return value is unspecified.
@end deffn
\fsync
-@deffn primitive sync
+@c snarfed from posix.c:1458
+@deffn {Scheme Procedure} sync
+@deffnx {C Function} scm_sync ()
Flush the operating system disk buffers.
The return value is unspecified.
@end deffn
\fcrypt
-@deffn primitive crypt key salt
+@c snarfed from posix.c:1489
+@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
crypt(3) library call.
@end deffn
\fchroot
-@deffn primitive chroot path
+@c snarfed from posix.c:1521
+@deffn {Scheme Procedure} chroot path
+@deffnx {C Function} scm_chroot (path)
Change the root directory to that specified in @var{path}.
This directory will be used for path names beginning with
@file{/}. The root directory is inherited by all children
@end deffn
\fgetlogin
-@deffn primitive getlogin
+@c snarfed from posix.c:1555
+@deffn {Scheme Procedure} getlogin
+@deffnx {C Function} scm_getlogin ()
Return a string containing the name of the user logged in on
the controlling terminal of the process, or @code{#f} if this
information cannot be obtained.
@end deffn
\fcuserid
-@deffn primitive cuserid
+@c snarfed from posix.c:1573
+@deffn {Scheme Procedure} cuserid
+@deffnx {C Function} scm_cuserid ()
Return a string containing a user name associated with the
effective user id of the process. Return @code{#f} if this
information cannot be obtained.
@end deffn
\fgetpriority
-@deffn primitive getpriority which who
+@c snarfed from posix.c:1599
+@deffn {Scheme Procedure} getpriority which who
+@deffnx {C Function} scm_getpriority (which, who)
Return the scheduling priority of the process, process group
or user, as indicated by @var{which} and @var{who}. @var{which}
is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
@end deffn
\fsetpriority
-@deffn primitive setpriority which who prio
+@c snarfed from posix.c:1633
+@deffn {Scheme Procedure} setpriority which who prio
+@deffnx {C Function} scm_setpriority (which, who, prio)
Set the scheduling priority of the process, process group
or user, as indicated by @var{which} and @var{who}. @var{which}
is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
@end deffn
\fgetpass
-@deffn primitive getpass prompt
+@c snarfed from posix.c:1658
+@deffn {Scheme Procedure} getpass prompt
+@deffnx {C Function} scm_getpass (prompt)
Display @var{prompt} to the standard error output and read
a password from @file{/dev/tty}. If this file is not
accessible, it reads from standard input. The password may be
@end deffn
\fflock
-@deffn primitive flock file operation
+@c snarfed from posix.c:1763
+@deffn {Scheme Procedure} flock file operation
+@deffnx {C Function} scm_flock (file, operation)
Apply or remove an advisory lock on an open file.
@var{operation} specifies the action to be done:
@table @code
it to one of the other operations.
@end table
The return value is not specified. @var{file} may be an open
-file descriptor or an open file descriptior port.
+file descriptor or an open file descriptor port.
@end deffn
\fsethostname
-@deffn primitive sethostname name
+@c snarfed from posix.c:1788
+@deffn {Scheme Procedure} sethostname name
+@deffnx {C Function} scm_sethostname (name)
Set the host name of the current processor to @var{name}. May
only be used by the superuser. The return value is not
specified.
@end deffn
\fgethostname
-@deffn primitive gethostname
+@c snarfed from posix.c:1806
+@deffn {Scheme Procedure} gethostname
+@deffnx {C Function} scm_gethostname ()
Return the host name of the current processor.
@end deffn
\fgethost
-@deffn primitive gethost [host]
-@deffnx procedure gethostbyname hostname
-@deffnx procedure gethostbyaddr address
+@c snarfed from net_db.c:134
+@deffn {Scheme Procedure} gethost [host]
+@deffnx {Scheme Procedure} gethostbyname hostname
+@deffnx {Scheme Procedure} gethostbyaddr address
+@deffnx {C Function} scm_gethost (host)
Look up a host by name or address, returning a host object. The
@code{gethost} procedure will accept either a string name or an integer
address; if given no arguments, it behaves like @code{gethostent} (see
@end deffn
\fgetnet
-@deffn primitive getnet [net]
-@deffnx procedure getnetbyname net-name
-@deffnx procedure getnetbyaddr net-number
+@c snarfed from net_db.c:216
+@deffn {Scheme Procedure} getnet [net]
+@deffnx {Scheme Procedure} getnetbyname net-name
+@deffnx {Scheme Procedure} getnetbyaddr net-number
+@deffnx {C Function} scm_getnet (net)
Look up a network by name or net number in the network database. The
@var{net-name} argument must be a string, and the @var{net-number}
argument must be an integer. @code{getnet} will accept either type of
@end deffn
\fgetproto
-@deffn primitive getproto [protocol]
-@deffnx procedure getprotobyname name
-@deffnx procedure getprotobynumber number
+@c snarfed from net_db.c:268
+@deffn {Scheme Procedure} getproto [protocol]
+@deffnx {Scheme Procedure} getprotobyname name
+@deffnx {Scheme Procedure} getprotobynumber number
+@deffnx {C Function} scm_getproto (protocol)
Look up a network protocol by name or by number. @code{getprotobyname}
takes a string argument, and @code{getprotobynumber} takes an integer
argument. @code{getproto} will accept either type, behaving like
@end deffn
\fgetserv
-@deffn primitive getserv [name [protocol]]
-@deffnx procedure getservbyname name protocol
-@deffnx procedure getservbyport port protocol
+@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
+@deffnx {C Function} scm_getserv (name, protocol)
Look up a network service by name or by service number, and return a
network service object. The @var{protocol} argument specifies the name
of the desired protocol; if the protocol found in the network service
@end deffn
\fsethost
-@deffn primitive sethost [stayopen]
+@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}.
Otherwise it is equivalent to @code{sethostent stayopen}.
@end deffn
\fsetnet
-@deffn primitive setnet [stayopen]
+@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}.
Otherwise it is equivalent to @code{setnetent stayopen}.
@end deffn
\fsetproto
-@deffn primitive setproto [stayopen]
+@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}.
Otherwise it is equivalent to @code{setprotoent stayopen}.
@end deffn
\fsetserv
-@deffn primitive setserv [stayopen]
+@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}.
Otherwise it is equivalent to @code{setservent stayopen}.
@end deffn
\fhtons
-@deffn primitive htons value
+@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.
@var{value} is packed into 2 bytes, which are then converted
and returned as a new integer.
@end deffn
\fntohs
-@deffn primitive ntohs value
+@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.
@var{value} is packed into 2 bytes, which are then converted
and returned as a new integer.
@end deffn
\fhtonl
-@deffn primitive htonl value
+@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.
@var{value} is packed into 4 bytes, which are then converted
and returned as a new integer.
@end deffn
\fntohl
-@deffn primitive ntohl value
+@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.
@var{value} is packed into 4 bytes, which are then converted
and returned as a new integer.
@end deffn
\finet-aton
-@deffn primitive inet-aton address
+@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
(dotted decimal notation) to an integer. E.g.,
@end deffn
\finet-ntoa
-@deffn primitive inet-ntoa inetid
+@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
(dotted decimal notation) string. E.g.,
@end deffn
\finet-netof
-@deffn primitive inet-netof address
+@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
Internet address. E.g.,
@end deffn
\finet-lnaof
-@deffn primitive inet-lnaof address
+@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
IPv4 Internet address, using the obsolete class A/B/C system.
E.g.,
@end deffn
\finet-makeaddr
-@deffn primitive inet-makeaddr net lna
+@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
@var{net} with the local-address-within-network number
@var{lna}. E.g.,
@end deffn
\finet-pton
-@deffn primitive inet-pton family address
+@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
an integer address. Note that unlike the C version of this
function,
@end deffn
\finet-ntop
-@deffn primitive inet-ntop family address
+@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.
Note that unlike the C version of this function,
the input is an integer with normal host byte ordering.
@end deffn
\fsocket
-@deffn primitive socket family style proto
+@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},
@var{style} and @var{proto}. All three parameters are
integers. Supported values for @var{family} are
@end deffn
\fsocketpair
-@deffn primitive socketpair family style proto
+@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
type specified by @var{family}, @var{style} and @var{proto}.
Many systems support only socket pairs of the @code{AF_UNIX}
@end deffn
\fgetsockopt
-@deffn primitive getsockopt sock level optname
+@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
port @var{sock}. @var{level} is an integer code for type of
option being requested, e.g., @code{SOL_SOCKET} for
@end deffn
\fsetsockopt
-@deffn primitive setsockopt sock level optname value
+@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
port @var{sock}. @var{level} is an integer code for type of option
being set, e.g., @code{SOL_SOCKET} for socket-level options.
@end deffn
\fshutdown
-@deffn primitive shutdown sock how
+@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
-@code{shutdown} procedure allows reception or tranmission on a
+@code{shutdown} procedure allows reception or transmission on a
connection to be shut down individually, according to the parameter
@var{how}:
@end deffn
\fconnect
-@deffn primitive connect sock fam address . args
+@c snarfed from socket.c:840
+@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
family to the address
specified by @var{address} and possibly @var{args}.
@end deffn
\fbind
-@deffn primitive bind sock fam address . args
+@c snarfed from socket.c:899
+@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}.
Generally this only needs to be done for server sockets,
so they know where to look for incoming connections. A socket
@end deffn
\flisten
-@deffn primitive listen sock backlog
+@c snarfed from socket.c:932
+@deffn {Scheme Procedure} listen sock backlog
+@deffnx {C Function} scm_listen (sock, backlog)
Enable @var{sock} to accept connection
requests. @var{backlog} is an integer specifying
the maximum length of the queue for pending connections.
@end deffn
\faccept
-@deffn primitive accept sock
+@c snarfed from socket.c:1044
+@deffn {Scheme Procedure} accept sock
+@deffnx {C Function} scm_accept (sock)
Accept a connection on a bound, listening socket.
If there
are no pending connections in the queue, wait until
@end deffn
\fgetsockname
-@deffn primitive getsockname sock
+@c snarfed from socket.c:1071
+@deffn {Scheme Procedure} getsockname sock
+@deffnx {C Function} scm_getsockname (sock)
Return the address of @var{sock}, in the same form as the
object returned by @code{accept}. On many systems the address
of a socket in the @code{AF_FILE} namespace cannot be read.
@end deffn
\fgetpeername
-@deffn primitive getpeername sock
+@c snarfed from socket.c:1093
+@deffn {Scheme Procedure} getpeername sock
+@deffnx {C Function} scm_getpeername (sock)
Return the address that @var{sock}
is connected to, in the same form as the object returned by
@code{accept}. On many systems the address of a socket in the
@end deffn
\frecv!
-@deffn primitive recv! sock buf [flags]
+@c snarfed from socket.c:1128
+@deffn {Scheme Procedure} recv! sock buf [flags]
+@deffnx {C Function} scm_recv (sock, buf, flags)
Receive data from a socket port.
@var{sock} must already
be bound to the address from which data is to be received.
@end deffn
\fsend
-@deffn primitive send sock message [flags]
+@c snarfed from socket.c:1171
+@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}.
@var{sock} must already be bound to a destination address. The
value returned is the number of bytes transmitted --
@end deffn
\frecvfrom!
-@deffn primitive recvfrom! sock str [flags [start [end]]]
+@c snarfed from socket.c:1222
+@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
information about where the data was received from.
@var{sock} must already be bound to the address from which
@end deffn
\fsendto
-@deffn primitive sendto sock message fam address . args_and_flags
+@c snarfed from socket.c:1287
+@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
@var{sock}. The
destination address is specified using the @var{fam},
file descriptor:
any unflushed buffered port data is ignored.
@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,
+or @code{#f} otherwise.
+@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
+return the compiled regexp structure. If @var{pat} does not
+describe a legal regular expression, @code{make-regexp} throws
+a @code{regular-expression-syntax} error.
+
+The @var{flags} arguments change the behavior of the compiled
+regular expression. The following flags may be supplied:
+
+@table @code
+@item regexp/icase
+Consider uppercase and lowercase letters to be the same when
+matching.
+@item regexp/newline
+If a newline appears in the target string, then permit the
+@samp{^} and @samp{$} operators to match immediately after or
+immediately before the newline, respectively. Also, the
+@samp{.} and @samp{[^...]} operators will never match a newline
+character. The intent of this flag is to treat the target
+string as a buffer containing many lines of text, and the
+regular expression as a pattern that may match a single one of
+those lines.
+@item regexp/basic
+Compile a basic (``obsolete'') regexp instead of the extended
+(``modern'') regexps that are the default. Basic regexps do
+not consider @samp{|}, @samp{+} or @samp{?} to be special
+characters, and require the @samp{@{...@}} and @samp{(...)}
+metacharacters to be backslash-escaped (@pxref{Backslash
+Escapes}). There are several other differences between basic
+and extended regular expressions, but these are the most
+significant.
+@item regexp/extended
+Compile an extended regular expression rather than a basic
+regexp. This is the default behavior; this flag will not
+usually be needed. If a call to @code{make-regexp} includes
+both @code{regexp/basic} and @code{regexp/extended} flags, the
+one which comes last will override the earlier one.
+@end table
+@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
+@code{str}. If the optional integer @var{start} argument is
+provided, begin matching from that position in the string.
+Return a match structure describing the results of the match,
+or @code{#f} if no match could be found.
+
+The @var{flags} arguments change the matching behavior.
+The following flags may be supplied:
+
+@table @code
+@item regexp/notbol
+Operator @samp{^} always fails (unless @code{regexp/newline}
+is used). Use this when the beginning of the string should
+not be considered the beginning of a line.
+@item regexp/noteol
+Operator @samp{$} always fails (unless @code{regexp/newline}
+is used). Use this when the end of the string should not be
+considered the end of a line.
+@end table
+@end deffn
HCoop / bpt / guile.git / blobdiff