\facons
-@c snarfed from alist.c:35
+@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
@end deffn
\fsloppy-assq
-@c snarfed from alist.c:49
+@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.
@end deffn
\fsloppy-assv
-@c snarfed from alist.c:67
+@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.
@end deffn
\fsloppy-assoc
-@c snarfed from alist.c:85
+@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.
@end deffn
\fassq
-@c snarfed from alist.c:112
+@c snarfed from alist.c:113
@deffn {Scheme Procedure} assq key alist
@deffnx {Scheme Procedure} assv key alist
@deffnx {Scheme Procedure} assoc key alist
@end deffn
\fassv
-@c snarfed from alist.c:133
+@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
-@c snarfed from alist.c:154
+@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
-@c snarfed from alist.c:198
+@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
@end deffn
\fassv-ref
-@c snarfed from alist.c:215
+@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
-@c snarfed from alist.c:232
+@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!
-@c snarfed from alist.c:261
+@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
@end deffn
\fassv-set!
-@c snarfed from alist.c:279
+@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!
-@c snarfed from alist.c:297
+@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!
-@c snarfed from alist.c:321
+@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
@end deffn
\fassv-remove!
-@c snarfed from alist.c:337
+@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!
-@c snarfed from alist.c:353
+@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.
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]
otherwise return the first argument.
@end deffn
+\funmask-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
+@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
@end deffn
\fdisplay-backtrace
-@c snarfed from backtrace.c:756
-@deffn {Scheme Procedure} display-backtrace stack port [first [depth]]
-@deffnx {C Function} scm_display_backtrace (stack, port, first, depth)
+@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
-@c snarfed from backtrace.c:779
-@deffn {Scheme Procedure} backtrace
-@deffnx {C Function} scm_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
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
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
@c snarfed from dynl.c:149
@deffn {Scheme Procedure} dynamic-link filename
@end deffn
\fscm-error
-@c snarfed from error.c:81
+@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
@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
-@c snarfed from error.c:128
+@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
@end deffn
\fapply:nconc2last
-@c snarfed from eval.c:4700
+@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
@end deffn
\fforce
-@c snarfed from eval.c:5628
+@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
@end deffn
\fpromise?
-@c snarfed from eval.c:5651
+@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
@end deffn
\fcons-source
-@c snarfed from eval.c:5663
+@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}.
@end deffn
\fcopy-tree
-@c snarfed from eval.c:5820
+@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
@end deffn
\fprimitive-eval
-@c snarfed from eval.c:5906
+@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
@end deffn
\feval
-@c snarfed from eval.c:5975
+@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,
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
@c snarfed from ioext.c:54
@deffn {Scheme Procedure} ftell fd_port
environment.
@end deffn
+\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{code} to the expression and the
+environment. For example:
+
+@lisp
+(define trace
+ (procedure->macro
+ (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))
+
+(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
+@end lisp
+@end deffn
+
\fmacro?
@c snarfed from macros.c:165
@deffn {Scheme Procedure} macro? obj
@end deffn
\fexact?
-@c snarfed from numbers.c:461
+@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}
@end deffn
\fodd?
-@c snarfed from numbers.c:480
+@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}
@end deffn
\feven?
-@c snarfed from numbers.c:515
+@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}
@end deffn
\finf?
-@c snarfed from numbers.c:549
+@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}
@end deffn
\fnan?
-@c snarfed from numbers.c:565
+@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}
@end deffn
\finf
-@c snarfed from numbers.c:635
+@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:650
+@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:666
+@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
-@c snarfed from numbers.c:1201
+@c snarfed from numbers.c:1200
@deffn {Scheme Procedure} logand n1 n2
Return the bitwise AND of the integer arguments.
@end deffn
\flogior
-@c snarfed from numbers.c:1277
+@c snarfed from numbers.c:1276
@deffn {Scheme Procedure} logior n1 n2
Return the bitwise OR of the integer arguments.
@end deffn
\flogxor
-@c snarfed from numbers.c:1353
+@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.
@end deffn
\flogtest
-@c snarfed from numbers.c:1424
+@c snarfed from numbers.c:1423
@deffn {Scheme Procedure} logtest j k
@deffnx {C Function} scm_logtest (j, k)
@lisp
@end deffn
\flogbit?
-@c snarfed from numbers.c:1495
+@c snarfed from numbers.c:1494
@deffn {Scheme Procedure} logbit? index j
@deffnx {C Function} scm_logbit_p (index, j)
@lisp
@end deffn
\flognot
-@c snarfed from numbers.c:1529
+@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
@end deffn
\fmodulo-expt
-@c snarfed from numbers.c:1574
+@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
@end deffn
\finteger-expt
-@c snarfed from numbers.c:1679
+@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 non-negative integer exponent
+Return @var{n} raised to the exact integer exponent
@var{k}.
@lisp
@end deffn
\fash
-@c snarfed from numbers.c:1785
+@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
@end deffn
\fbit-extract
-@c snarfed from numbers.c:1825
+@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)
@end deffn
\flogcount
-@c snarfed from numbers.c:1904
+@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
@end deffn
\finteger-length
-@c snarfed from numbers.c:1952
+@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}.
@end deffn
\fnumber->string
-@c snarfed from numbers.c:2275
+@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
@end deffn
\fstring->number
-@c snarfed from numbers.c:2958
+@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
@end deffn
\fnumber?
-@c snarfed from numbers.c:3021
+@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}
@end deffn
\fcomplex?
-@c snarfed from numbers.c:3034
+@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}
@end deffn
\freal?
-@c snarfed from numbers.c:3047
+@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}
@end deffn
\frational?
-@c snarfed from numbers.c:3060
+@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}
@end deffn
\finteger?
-@c snarfed from numbers.c:3083
+@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}
@end deffn
\finexact?
-@c snarfed from numbers.c:3108
+@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}
@end deffn
\ftruncate
-@c snarfed from numbers.c:4955
+@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:4971
+@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:4997
+@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:5028
+@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
-@c snarfed from numbers.c:5137
+@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
@end deffn
\f$atan2
-@c snarfed from numbers.c:5153
+@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
@end deffn
\fmake-rectangular
-@c snarfed from numbers.c:5181
+@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
@end deffn
\fmake-polar
-@c snarfed from numbers.c:5205
+@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
-@c snarfed from numbers.c:5408
+@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:5445
+@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
\fset-car!
-@c snarfed from pairs.c:85
+@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
@end deffn
\fset-cdr!
-@c snarfed from pairs.c:98
+@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
@end deffn
\fpeek-char
-@c snarfed from ports.c:1281
+@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},
@end deffn
\funread-char
-@c snarfed from ports.c:1304
+@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
@end deffn
\funread-string
-@c snarfed from ports.c:1327
+@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
@end deffn
\fseek
-@c snarfed from ports.c:1366
+@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
@end deffn
\ftruncate-file
-@c snarfed from ports.c:1424
+@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
@end deffn
\fport-line
-@c snarfed from ports.c:1484
+@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}.
@end deffn
\fset-port-line!
-@c snarfed from ports.c:1496
+@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
@end deffn
\fport-column
-@c snarfed from ports.c:1515
+@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}.
@end deffn
\fset-port-column!
-@c snarfed from ports.c:1527
+@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
@end deffn
\fport-filename
-@c snarfed from ports.c:1541
+@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
@end deffn
\fset-port-filename!
-@c snarfed from ports.c:1555
+@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
@end deffn
\f%make-void-port
-@c snarfed from ports.c:1649
+@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
@end deffn
\fsimple-format
-@c snarfed from print.c:914
+@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
@end deffn
\fnewline
-@c snarfed from print.c:1004
+@c snarfed from print.c:1022
@deffn {Scheme Procedure} newline [port]
@deffnx {C Function} scm_newline (port)
Send a newline to @var{port}.
@end deffn
\fwrite-char
-@c snarfed from print.c:1019
+@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
-@c snarfed from print.c:1073
+@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
@end deffn
\fget-print-state
-@c snarfed from print.c:1086
+@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}
@end deffn
\fread-hash-extend
-@c snarfed from read.c:866
+@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
@end deffn
\fget-internal-real-time
-@c snarfed from stime.c:117
+@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
@end deffn
\ftimes
-@c snarfed from stime.c:164
+@c snarfed from stime.c:179
@deffn {Scheme Procedure} times
@deffnx {C Function} scm_times ()
Return an object with information about real and processor
@end deffn
\fget-internal-run-time
-@c snarfed from stime.c:196
+@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
@end deffn
\fcurrent-time
-@c snarfed from stime.c:213
+@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,
@end deffn
\fgettimeofday
-@c snarfed from stime.c:231
+@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
@end deffn
\flocaltime
-@c snarfed from stime.c:335
+@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
@end deffn
\fgmtime
-@c snarfed from stime.c:420
+@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
@end deffn
\fmktime
-@c snarfed from stime.c:498
+@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}
@end deffn
\ftzset
-@c snarfed from stime.c:581
+@c snarfed from stime.c:611
@deffn {Scheme Procedure} tzset
@deffnx {C Function} scm_tzset ()
Initialize the timezone from the TZ environment variable
@end deffn
\fstrftime
-@c snarfed from stime.c:598
+@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}
@end deffn
\fstrptime
-@c snarfed from stime.c:696
+@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
@end deffn
\fstring?
-@c snarfed from strings.c:494
+@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
-@c snarfed from strings.c:502
+@c snarfed from strings.c:534
@deffn {Scheme Procedure} list->string
implemented by the C function "scm_string"
@end deffn
\fstring
-@c snarfed from strings.c:508
+@c snarfed from strings.c:540
@deffn {Scheme Procedure} string . chrs
@deffnx {Scheme Procedure} list->string chrs
@deffnx {C Function} scm_string (chrs)
@end deffn
\fmake-string
-@c snarfed from strings.c:546
+@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
@end deffn
\fstring-length
-@c snarfed from strings.c:572
+@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
-@c snarfed from strings.c:591
+@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
@end deffn
\fstring-set!
-@c snarfed from strings.c:614
+@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
@end deffn
\fsubstring
-@c snarfed from strings.c:650
+@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
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:673
+@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
@end deffn
\fsubstring/shared
-@c snarfed from strings.c:697
+@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
@end deffn
\fstring-append
-@c snarfed from strings.c:716
+@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
@end deffn
\fstring-null?
-@c snarfed from srfi-13.c:71
+@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
@end deffn
\fstring-any
-@c snarfed from srfi-13.c:91
+@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
@end deffn
\fstring-every
-@c snarfed from srfi-13.c:150
+@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
@end deffn
\fstring-tabulate
-@c snarfed from srfi-13.c:202
+@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
@end deffn
\fstring->list
-@c snarfed from srfi-13.c:234
+@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:271
+@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
@end deffn
\fstring-join
-@c snarfed from srfi-13.c:324
+@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
@end deffn
\fstring-copy
-@c snarfed from srfi-13.c:480
+@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
@end deffn
\fstring-copy!
-@c snarfed from srfi-13.c:507
+@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},
@end deffn
\fsubstring-move!
-@c snarfed from srfi-13.c:536
+@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}
@end deffn
\fstring-take
-@c snarfed from srfi-13.c:545
+@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-drop
-@c snarfed from srfi-13.c:555
+@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-take-right
-@c snarfed from srfi-13.c:565
+@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-drop-right
-@c snarfed from srfi-13.c:577
+@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:592
+@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
@end deffn
\fstring-pad-right
-@c snarfed from srfi-13.c:632
+@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
@end deffn
\fstring-trim
-@c snarfed from srfi-13.c:686
+@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
@end deffn
\fstring-trim-right
-@c snarfed from srfi-13.c:762
+@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
@end deffn
\fstring-trim-both
-@c snarfed from srfi-13.c:838
+@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
@end deffn
\fstring-fill!
-@c snarfed from srfi-13.c:925
+@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
@end deffn
\fstring-compare
-@c snarfed from srfi-13.c:975
+@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
@end deffn
\fstring-compare-ci
-@c snarfed from srfi-13.c:1018
+@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
@end deffn
\fstring=
-@c snarfed from srfi-13.c:1056
+@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
@end deffn
\fstring<>
-@c snarfed from srfi-13.c:1095
+@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
@end deffn
\fstring<
-@c snarfed from srfi-13.c:1138
+@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
@end deffn
\fstring>
-@c snarfed from srfi-13.c:1181
+@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
@end deffn
\fstring<=
-@c snarfed from srfi-13.c:1224
+@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
@end deffn
\fstring>=
-@c snarfed from srfi-13.c:1267
+@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
@end deffn
\fstring-ci=
-@c snarfed from srfi-13.c:1311
+@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
@end deffn
\fstring-ci<>
-@c snarfed from srfi-13.c:1355
+@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
@end deffn
\fstring-ci<
-@c snarfed from srfi-13.c:1399
+@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
@end deffn
\fstring-ci>
-@c snarfed from srfi-13.c:1443
+@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
@end deffn
\fstring-ci<=
-@c snarfed from srfi-13.c:1487
+@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
@end deffn
\fstring-ci>=
-@c snarfed from srfi-13.c:1531
+@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
@end deffn
\fstring-hash
-@c snarfed from srfi-13.c:1576
+@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:1593
+@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:1605
+@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
@end deffn
\fstring-prefix-length-ci
-@c snarfed from srfi-13.c:1634
+@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
@end deffn
\fstring-suffix-length
-@c snarfed from srfi-13.c:1663
+@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
@end deffn
\fstring-suffix-length-ci
-@c snarfed from srfi-13.c:1692
+@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
@end deffn
\fstring-prefix?
-@c snarfed from srfi-13.c:1720
+@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:1749
+@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:1778
+@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:1807
+@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:1848
+@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
@end deffn
\fstring-index-right
-@c snarfed from srfi-13.c:1907
+@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
@end deffn
\fstring-rindex
-@c snarfed from srfi-13.c:1966
+@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
@end deffn
\fstring-skip
-@c snarfed from srfi-13.c:1986
+@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
@end deffn
\fstring-skip-right
-@c snarfed from srfi-13.c:2047
+@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
@end deffn
\fstring-count
-@c snarfed from srfi-13.c:2107
+@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
@end deffn
\fstring-contains
-@c snarfed from srfi-13.c:2162
+@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
@end deffn
\fstring-contains-ci
-@c snarfed from srfi-13.c:2203
+@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
@end deffn
\fstring-upcase!
-@c snarfed from srfi-13.c:2261
+@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}.
@end deffn
\fstring-upcase
-@c snarfed from srfi-13.c:2282
+@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!
-@c snarfed from srfi-13.c:2328
+@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}.
@end deffn
\fstring-downcase
-@c snarfed from srfi-13.c:2349
+@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:2404
+@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
@end deffn
\fstring-titlecase
-@c snarfed from srfi-13.c:2420
+@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!
-@c snarfed from srfi-13.c:2445
+@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}
@end deffn
\fstring-capitalize
-@c snarfed from srfi-13.c:2457
+@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
@end deffn
\fstring-reverse
-@c snarfed from srfi-13.c:2488
+@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
@end deffn
\fstring-reverse!
-@c snarfed from srfi-13.c:2512
+@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
@end deffn
\fstring-append/shared
-@c snarfed from srfi-13.c:2535
+@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
@end deffn
\fstring-concatenate
-@c snarfed from srfi-13.c:2556
+@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)
@end deffn
\fstring-concatenate-reverse
-@c snarfed from srfi-13.c:2578
+@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
@end deffn
\fstring-concatenate/shared
-@c snarfed from srfi-13.c:2647
+@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
@end deffn
\fstring-concatenate-reverse/shared
-@c snarfed from srfi-13.c:2658
+@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
@end deffn
\fstring-map
-@c snarfed from srfi-13.c:2671
+@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
@end deffn
\fstring-map!
-@c snarfed from srfi-13.c:2704
+@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
@end deffn
\fstring-fold
-@c snarfed from srfi-13.c:2731
+@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}
@end deffn
\fstring-fold-right
-@c snarfed from srfi-13.c:2760
+@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}
@end deffn
\fstring-unfold
-@c snarfed from srfi-13.c:2803
+@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
@end deffn
\fstring-unfold-right
-@c snarfed from srfi-13.c:2866
+@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
@end deffn
\fstring-for-each
-@c snarfed from srfi-13.c:2913
+@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
@end deffn
\fstring-for-each-index
-@c snarfed from srfi-13.c:2937
+@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
@end deffn
\fxsubstring
-@c snarfed from srfi-13.c:2967
+@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
@end deffn
\fstring-xcopy!
-@c snarfed from srfi-13.c:3010
+@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
@end deffn
\fstring-replace
-@c snarfed from srfi-13.c:3058
+@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
@end deffn
\fstring-tokenize
-@c snarfed from srfi-13.c:3093
+@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
@end deffn
\fstring-split
-@c snarfed from srfi-13.c:3157
+@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
@end deffn
\fstring-filter
-@c snarfed from srfi-13.c:3195
+@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
@end deffn
\fstring-delete
-@c snarfed from srfi-13.c:3265
+@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
@end deffn
\fsymbol?
-@c snarfed from symbols.c:158
+@c snarfed from symbols.c:156
@deffn {Scheme Procedure} symbol? obj
@deffnx {C Function} scm_symbol_p (obj)
Return @code{#t} if @var{obj} is a symbol, otherwise return
@end deffn
\fsymbol-interned?
-@c snarfed from symbols.c:168
+@c snarfed from symbols.c:166
@deffn {Scheme Procedure} symbol-interned? symbol
@deffnx {C Function} scm_symbol_interned_p (symbol)
Return @code{#t} if @var{symbol} is interned, otherwise return
@end deffn
\fmake-symbol
-@c snarfed from symbols.c:180
+@c snarfed from symbols.c:178
@deffn {Scheme Procedure} make-symbol name
@deffnx {C Function} scm_make_symbol (name)
Return a new uninterned symbol with the name @var{name}. The returned symbol is guaranteed to be unique and future calls to @code{string->symbol} will not return it.
@end deffn
\fsymbol->string
-@c snarfed from symbols.c:212
+@c snarfed from symbols.c:210
@deffn {Scheme Procedure} symbol->string s
@deffnx {C Function} scm_symbol_to_string (s)
Return the name of @var{symbol} as a string. If the symbol was
@end deffn
\fstring->symbol
-@c snarfed from symbols.c:242
+@c snarfed from symbols.c:240
@deffn {Scheme Procedure} string->symbol string
@deffnx {C Function} scm_string_to_symbol (string)
Return the symbol whose name is @var{string}. This procedure
@end deffn
\fstring-ci->symbol
-@c snarfed from symbols.c:254
+@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
@end deffn
\fgensym
-@c snarfed from symbols.c:271
+@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
@end deffn
\fsymbol-hash
-@c snarfed from symbols.c:297
+@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
-@c snarfed from symbols.c:307
+@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
-@c snarfed from symbols.c:318
+@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!
-@c snarfed from symbols.c:329
+@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!
-@c snarfed from symbols.c:341
+@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
\fcurrent-thread
-@c snarfed from threads.c:1103
+@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:1112
+@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:1127
+@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
-@c snarfed from throw.c:500
+@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
@end deffn
\flazy-catch
-@c snarfed from throw.c:528
+@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
@end deffn
\fthrow
-@c snarfed from throw.c:561
+@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
@end deffn
\fchown
-@c snarfed from filesys.c:220
+@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
@end deffn
\fchmod
-@c snarfed from filesys.c:258
+@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}.
@end deffn
\fumask
-@c snarfed from filesys.c:290
+@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
@end deffn
\fopen-fdes
-@c snarfed from filesys.c:312
+@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
@end deffn
\fopen
-@c snarfed from filesys.c:353
+@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.
@end deffn
\fclose
-@c snarfed from filesys.c:391
+@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}),
@end deffn
\fclose-fdes
-@c snarfed from filesys.c:418
+@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.
@end deffn
\fstat
-@c snarfed from filesys.c:620
+@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
@end deffn
\flink
-@c snarfed from filesys.c:682
+@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
@end deffn
\frename-file
-@c snarfed from filesys.c:720
+@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}.
@end deffn
\fdelete-file
-@c snarfed from filesys.c:737
+@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
-@c snarfed from filesys.c:754
+@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
@end deffn
\frmdir
-@c snarfed from filesys.c:781
+@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
@end deffn
\fdirectory-stream?
-@c snarfed from filesys.c:805
+@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
@end deffn
\fopendir
-@c snarfed from filesys.c:816
+@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
@end deffn
\freaddir
-@c snarfed from filesys.c:837
+@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
@end deffn
\frewinddir
-@c snarfed from filesys.c:876
+@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
@end deffn
\fclosedir
-@c snarfed from filesys.c:893
+@c snarfed from filesys.c:897
@deffn {Scheme Procedure} closedir port
@deffnx {C Function} scm_closedir (port)
Close the directory stream @var{stream}.
@end deffn
\fchdir
-@c snarfed from filesys.c:943
+@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}.
@end deffn
\fgetcwd
-@c snarfed from filesys.c:958
+@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
-@c snarfed from filesys.c:1159
+@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
@end deffn
\ffcntl
-@c snarfed from filesys.c:1297
+@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
@end deffn
\ffsync
-@c snarfed from filesys.c:1329
+@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.
@end deffn
\fsymlink
-@c snarfed from filesys.c:1354
+@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)
@end deffn
\freadlink
-@c snarfed from filesys.c:1373
+@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
@end deffn
\flstat
-@c snarfed from filesys.c:1415
+@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.,
@end deffn
\fcopy-file
-@c snarfed from filesys.c:1438
+@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}.
@end deffn
\fdirname
-@c snarfed from filesys.c:1501
+@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
@end deffn
\fbasename
-@c snarfed from filesys.c:1544
+@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
@end deffn
\fpipe
-@c snarfed from posix.c:231
+@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
@end deffn
\fgetgroups
-@c snarfed from posix.c:252
+@c snarfed from posix.c:253
@deffn {Scheme Procedure} getgroups
@deffnx {C Function} scm_getgroups ()
Return a vector of integers representing the current
@end deffn
\fsetgroups
-@c snarfed from posix.c:285
+@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
@end deffn
\fgetpw
-@c snarfed from posix.c:333
+@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,
@end deffn
\fsetpw
-@c snarfed from posix.c:383
+@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
@end deffn
\fgetgr
-@c snarfed from posix.c:402
+@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,
@end deffn
\fsetgr
-@c snarfed from posix.c:438
+@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
@end deffn
\fkill
-@c snarfed from posix.c:474
+@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.
@end deffn
\fwaitpid
-@c snarfed from posix.c:525
+@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
@end deffn
\fstatus:exit-val
-@c snarfed from posix.c:551
+@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
@end deffn
\fstatus:term-sig
-@c snarfed from posix.c:569
+@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,
@end deffn
\fstatus:stop-sig
-@c snarfed from posix.c:585
+@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,
@end deffn
\fgetppid
-@c snarfed from posix.c:603
+@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
@end deffn
\fgetuid
-@c snarfed from posix.c:615
+@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
-@c snarfed from posix.c:626
+@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
-@c snarfed from posix.c:640
+@c snarfed from posix.c:641
@deffn {Scheme Procedure} geteuid
@deffnx {C Function} scm_geteuid ()
Return an integer representing the current effective user ID.
@end deffn
\fgetegid
-@c snarfed from posix.c:657
+@c snarfed from posix.c:658
@deffn {Scheme Procedure} getegid
@deffnx {C Function} scm_getegid ()
Return an integer representing the current effective group ID.
@end deffn
\fsetuid
-@c snarfed from posix.c:673
+@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
@end deffn
\fsetgid
-@c snarfed from posix.c:686
+@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
@end deffn
\fseteuid
-@c snarfed from posix.c:701
+@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
@end deffn
\fsetegid
-@c snarfed from posix.c:726
+@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
@end deffn
\fgetpgrp
-@c snarfed from posix.c:749
+@c snarfed from posix.c:750
@deffn {Scheme Procedure} getpgrp
@deffnx {C Function} scm_getpgrp ()
Return an integer representing the current process group ID.
@end deffn
\fsetpgid
-@c snarfed from posix.c:767
+@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
@end deffn
\fsetsid
-@c snarfed from posix.c:784
+@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
@end deffn
\fttyname
-@c snarfed from posix.c:808
+@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
@end deffn
\fctermid
-@c snarfed from posix.c:847
+@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
@end deffn
\ftcgetpgrp
-@c snarfed from posix.c:871
+@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
@end deffn
\ftcsetpgrp
-@c snarfed from posix.c:895
+@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
@end deffn
\fexecl
-@c snarfed from posix.c:927
+@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.
@end deffn
\fexeclp
-@c snarfed from posix.c:958
+@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
@end deffn
\fexecle
-@c snarfed from posix.c:992
+@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
@end deffn
\fprimitive-fork
-@c snarfed from posix.c:1028
+@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.
@end deffn
\funame
-@c snarfed from posix.c:1048
+@c snarfed from posix.c:1049
@deffn {Scheme Procedure} uname
@deffnx {C Function} scm_uname ()
Return an object with some information about the computer
@end deffn
\fenviron
-@c snarfed from posix.c:1077
+@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
@end deffn
\ftmpnam
-@c snarfed from posix.c:1110
+@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
@end deffn
\fmkstemp!
-@c snarfed from posix.c:1136
+@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
@end deffn
\futime
-@c snarfed from posix.c:1171
+@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
@end deffn
\faccess?
-@c snarfed from posix.c:1219
+@c snarfed from posix.c:1237
@deffn {Scheme Procedure} access? path how
@deffnx {C Function} scm_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.
+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.
-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.
+@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
-@c snarfed from posix.c:1232
+@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
-@c snarfed from posix.c:1249
+@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
@end deffn
\fsetlocale
-@c snarfed from posix.c:1333
+@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
@end deffn
\fmknod
-@c snarfed from posix.c:1376
+@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.
@end deffn
\fnice
-@c snarfed from posix.c:1422
+@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
@end deffn
\fsync
-@c snarfed from posix.c:1436
+@c snarfed from posix.c:1458
@deffn {Scheme Procedure} sync
@deffnx {C Function} scm_sync ()
Flush the operating system disk buffers.
@end deffn
\fcrypt
-@c snarfed from posix.c:1467
+@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
@end deffn
\fchroot
-@c snarfed from posix.c:1499
+@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}.
@end deffn
\fgetlogin
-@c snarfed from posix.c:1533
+@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
@end deffn
\fcuserid
-@c snarfed from posix.c:1551
+@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
@end deffn
\fgetpriority
-@c snarfed from posix.c:1577
+@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
@end deffn
\fsetpriority
-@c snarfed from posix.c:1611
+@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
@end deffn
\fgetpass
-@c snarfed from posix.c:1636
+@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
@end deffn
\fflock
-@c snarfed from posix.c:1741
+@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.
@end deffn
\fsethostname
-@c snarfed from posix.c:1766
+@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
@end deffn
\fgethostname
-@c snarfed from posix.c:1784
+@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
\fconnect
-@c snarfed from socket.c:842
+@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
@end deffn
\fbind
-@c snarfed from socket.c:901
+@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}.
@end deffn
\flisten
-@c snarfed from socket.c:934
+@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
@end deffn
\faccept
-@c snarfed from socket.c:1046
+@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.
@end deffn
\fgetsockname
-@c snarfed from socket.c:1073
+@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
@end deffn
\fgetpeername
-@c snarfed from socket.c:1095
+@c snarfed from socket.c:1093
@deffn {Scheme Procedure} getpeername sock
@deffnx {C Function} scm_getpeername (sock)
Return the address that @var{sock}
@end deffn
\frecv!
-@c snarfed from socket.c:1130
+@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.
@end deffn
\fsend
-@c snarfed from socket.c:1173
+@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}.
@end deffn
\frecvfrom!
-@c snarfed from socket.c:1224
+@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
@end deffn
\fsendto
-@c snarfed from socket.c:1289
+@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
HCoop / bpt / guile.git / blobdiff