diff options
Diffstat (limited to 'doc/maint')
-rw-r--r-- | doc/maint/ChangeLog | 9 | ||||
-rw-r--r-- | doc/maint/docstring.el | 30 | ||||
-rw-r--r-- | doc/maint/guile.texi | 2244 |
3 files changed, 1464 insertions, 819 deletions
diff --git a/doc/maint/ChangeLog b/doc/maint/ChangeLog index 17c3ddba2..37e19e73d 100644 --- a/doc/maint/ChangeLog +++ b/doc/maint/ChangeLog @@ -1,3 +1,12 @@ +2001-11-16 Neil Jerram <neil@ossau.uklinux.net> + + * guile.texi: Replaced by regenerated libguile version. + + * docstring.el (make-module-description-list): Exclude @deffn's + with category {C Function}. + (docstring-process-alist): Bind key "d" to + docstring-ediff-this-line in the docstring output buffer. + 2001-11-13 Neil Jerram <neil@ossau.uklinux.net> * guile.texi: Replaced by libguile version (after automatically diff --git a/doc/maint/docstring.el b/doc/maint/docstring.el index e0c05fa58..58d07eaa3 100644 --- a/doc/maint/docstring.el +++ b/doc/maint/docstring.el @@ -217,19 +217,22 @@ to which new docstrings should be added.") (match-end 1)))) (if (string-equal matched "@c module ") (setq module (read (current-buffer))) - (setq matched - (concat (buffer-substring (match-beginning 2) - (match-end 2)) - " " - (buffer-substring (match-beginning 3) - (match-end 3)))) - (message "Found docstring: %S: %s" module matched) - (let ((descriptions (assoc module alist))) - (setq alist - (cons (cons module (cons matched (cdr-safe descriptions))) - (if descriptions - (delete descriptions alist) - alist)))))))) + (let ((type (buffer-substring (match-beginning 2) + (match-end 2)))) + (if (string-equal type "{C Function}") + nil + (setq matched + (concat type + " " + (buffer-substring (match-beginning 3) + (match-end 3)))) + (message "Found docstring: %S: %s" module matched) + (let ((descriptions (assoc module alist))) + (setq alist + (cons (cons module (cons matched (cdr-safe descriptions))) + (if descriptions + (delete descriptions alist) + alist)))))))))) alist)) ;; Return the docstring from the specified LOCATION. LOCATION is a @@ -428,6 +431,7 @@ new snarfed docstring file.\n\n") (insert "\n") (goto-char (point-min)) + (local-set-key "d" 'docstring-ediff-this-line) ;; Popup the issues buffer. (let ((pop-up-frames t)) diff --git a/doc/maint/guile.texi b/doc/maint/guile.texi index fb07f2cba..a099e3dd7 100644 --- a/doc/maint/guile.texi +++ b/doc/maint/guile.texi @@ -1,58 +1,66 @@ @paragraphindent 0 acons -@deffn primitive acons key value alist -Adds a new key-value pair to @var{alist}. A new pair is +@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 sloppy-assq -@deffn primitive sloppy-assq key alist +@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 sloppy-assv -@deffn primitive sloppy-assv key alist +@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 sloppy-assoc -@deffn primitive sloppy-assoc key alist +@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 assq -@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 +@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 assv -@deffn primitive assv key alist +@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 assoc -@deffn primitive assoc key alist +@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 assq-ref -@deffn primitive assq-ref alist key -@deffnx primitive assv-ref alist key -@deffnx primitive assoc-ref alist key +@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 @@ -66,19 +74,22 @@ where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}. @end deffn assv-ref -@deffn primitive assv-ref alist key +@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 assoc-ref -@deffn primitive assoc-ref alist key +@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 assq-set! -@deffn primitive assq-set! alist key val -@deffnx primitive assv-set! alist key value -@deffnx primitive assoc-set! alist key value +@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}, @@ -90,96 +101,113 @@ association list. @end deffn assv-set! -@deffn primitive assv-set! alist key val +@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 assoc-set! -@deffn primitive assoc-set! alist key val +@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 assq-remove! -@deffn primitive assq-remove! alist key -@deffnx primitive assv-remove! alist key -@deffnx primitive assoc-remove! alist key +@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 assv-remove! -@deffn primitive assv-remove! alist key +@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 assoc-remove! -@deffn primitive assoc-remove! alist key +@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 make-arbiter -@deffn primitive make-arbiter name +@deffn {Scheme Procedure} make-arbiter name +@deffnx {C Function} scm_make_arbiter (name) Return an object of type arbiter and name @var{name}. Its state is initially unlocked. Arbiters are a way to achieve process synchronization. @end deffn try-arbiter -@deffn primitive try-arbiter arb +@deffn {Scheme Procedure} try-arbiter arb +@deffnx {C Function} scm_try_arbiter (arb) Return @code{#t} and lock the arbiter @var{arb} if the arbiter was unlocked. Otherwise, return @code{#f}. @end deffn release-arbiter -@deffn primitive release-arbiter arb +@deffn {Scheme Procedure} release-arbiter arb +@deffnx {C Function} scm_release_arbiter (arb) Return @code{#t} and unlock the arbiter @var{arb} if the arbiter was locked. Otherwise, return @code{#f}. @end deffn async -@deffn primitive async thunk +@deffn {Scheme Procedure} async thunk +@deffnx {C Function} scm_async (thunk) Create a new async for the procedure @var{thunk}. @end deffn system-async -@deffn primitive system-async thunk +@deffn {Scheme Procedure} system-async thunk +@deffnx {C Function} scm_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 async-mark -@deffn primitive async-mark a +@deffn {Scheme Procedure} async-mark a +@deffnx {C Function} scm_async_mark (a) Mark the async @var{a} for future execution. @end deffn system-async-mark -@deffn primitive system-async-mark a +@deffn {Scheme Procedure} system-async-mark a +@deffnx {C Function} scm_system_async_mark (a) Mark the async @var{a} for future execution. @end deffn run-asyncs -@deffn primitive run-asyncs list_of_a +@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 noop -@deffn primitive noop . args +@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 unmask-signals -@deffn primitive unmask-signals +@deffn {Scheme Procedure} unmask-signals +@deffnx {C Function} scm_unmask_signals () Unmask signals. The returned value is not specified. @end deffn mask-signals -@deffn primitive mask-signals +@deffn {Scheme Procedure} mask-signals +@deffnx {C Function} scm_mask_signals () Mask signals. The returned value is not specified. @end deffn display-error -@deffn primitive display-error stack port subr message args rest +@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 @@ -190,14 +218,16 @@ ignored. @end deffn display-application -@deffn primitive display-application frame [port [indent]] +@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 display-backtrace -@deffn primitive display-backtrace stack port [first [depth]] +@deffn {Scheme Procedure} display-backtrace stack port [first [depth]] +@deffnx {C Function} scm_display_backtrace (stack, port, first, depth) Display a backtrace to the output port @var{port}. @var{stack} is the stack to take the backtrace from, @var{first} specifies where in the stack to start and @var{depth} how much frames @@ -206,187 +236,210 @@ which means that default values will be used. @end deffn backtrace -@deffn primitive backtrace +@deffn {Scheme Procedure} backtrace +@deffnx {C Function} scm_backtrace () Display a backtrace of the stack saved by the last error to the current output port. @end deffn not -@deffn primitive not x +@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 boolean? -@deffn primitive boolean? obj +@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 char? -@deffn primitive char? x +@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 char=? -@deffn primitive char=? x y +@deffn {Scheme Procedure} char=? x y Return @code{#t} iff @var{x} is the same character as @var{y}, else @code{#f}. @end deffn char<? -@deffn primitive char<? x y +@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 char<=? -@deffn primitive char<=? x y +@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 char>? -@deffn primitive char>? x y +@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 char>=? -@deffn primitive char>=? x y +@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 char-ci=? -@deffn primitive char-ci=? x y +@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 char-ci<? -@deffn primitive char-ci<? x y +@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 char-ci<=? -@deffn primitive char-ci<=? x y +@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 char-ci>? -@deffn primitive char-ci>? x y +@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 char-ci>=? -@deffn primitive char-ci>=? x y +@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 char-alphabetic? -@deffn primitive char-alphabetic? chr +@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 char-numeric? -@deffn primitive char-numeric? chr +@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 char-whitespace? -@deffn primitive char-whitespace? chr +@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 char-upper-case? -@deffn primitive char-upper-case? chr +@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 char-lower-case? -@deffn primitive char-lower-case? chr +@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 char-is-both? -@deffn primitive char-is-both? chr +@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 char->integer -@deffn primitive char->integer chr +@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 integer->char -@deffn primitive integer->char n +@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 char-upcase -@deffn primitive char-upcase chr +@deffn {Scheme Procedure} char-upcase chr +@deffnx {C Function} scm_char_upcase (chr) Return the uppercase character version of @var{chr}. @end deffn char-downcase -@deffn primitive char-downcase chr +@deffn {Scheme Procedure} char-downcase chr +@deffnx {C Function} scm_char_downcase (chr) Return the lowercase character version of @var{chr}. @end deffn debug-options-interface -@deffn primitive debug-options-interface [setting] +@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}. @end deffn with-traps -@deffn primitive with-traps thunk +@deffn {Scheme Procedure} with-traps thunk +@deffnx {C Function} scm_with_traps (thunk) Call @var{thunk} with traps enabled. @end deffn memoized? -@deffn primitive memoized? obj +@deffn {Scheme Procedure} memoized? obj +@deffnx {C Function} scm_memoized_p (obj) Return @code{#t} if @var{obj} is memoized. @end deffn unmemoize -@deffn primitive unmemoize m +@deffn {Scheme Procedure} unmemoize m +@deffnx {C Function} scm_unmemoize (m) Unmemoize the memoized expression @var{m}, @end deffn memoized-environment -@deffn primitive memoized-environment m +@deffn {Scheme Procedure} memoized-environment m +@deffnx {C Function} scm_memoized_environment (m) Return the environment of the memoized expression @var{m}. @end deffn procedure-name -@deffn primitive procedure-name proc +@deffn {Scheme Procedure} procedure-name proc +@deffnx {C Function} scm_procedure_name (proc) Return the name of the procedure @var{proc} @end deffn procedure-source -@deffn primitive procedure-source proc +@deffn {Scheme Procedure} procedure-source proc +@deffnx {C Function} scm_procedure_source (proc) Return the source of the procedure @var{proc}. @end deffn procedure-environment -@deffn primitive procedure-environment proc +@deffn {Scheme Procedure} procedure-environment proc +@deffnx {C Function} scm_procedure_environment (proc) Return the environment of the procedure @var{proc}. @end deffn local-eval -@deffn primitive local-eval exp [env] +@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 @@ -394,12 +447,14 @@ is implicit). @end deffn debug-object? -@deffn primitive debug-object? obj +@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 dynamic-link -@deffn primitive dynamic-link filename +@deffn {Scheme Procedure} dynamic-link filename +@deffnx {C Function} scm_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 @@ -407,13 +462,15 @@ functions. @end deffn dynamic-object? -@deffn primitive dynamic-object? obj +@deffn {Scheme Procedure} dynamic-object? obj +@deffnx {C Function} scm_dynamic_object_p (obj) Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f} otherwise. @end deffn dynamic-unlink -@deffn primitive dynamic-unlink dobj +@deffn {Scheme Procedure} dynamic-unlink dobj +@deffnx {C Function} scm_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 @@ -421,7 +478,8 @@ called on @var{dobj}, its content is no longer accessible. @end deffn dynamic-func -@deffn primitive dynamic-func name dobj +@deffn {Scheme Procedure} dynamic-func name dobj +@deffnx {C Function} scm_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 @@ -434,7 +492,8 @@ needed or not and will add it when necessary. @end deffn dynamic-call -@deffn primitive dynamic-call func dobj +@deffn {Scheme Procedure} dynamic-call func dobj +@deffnx {C Function} scm_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 @@ -450,7 +509,8 @@ Interrupts are deferred while the C function is executing (with @end deffn dynamic-args-call -@deffn primitive dynamic-args-call func dobj args +@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 @@ -467,7 +527,8 @@ converted to a Scheme number and returned from the call to @end deffn dynamic-wind -@deffn primitive dynamic-wind in_guard thunk out_guard +@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}. @@ -519,26 +580,30 @@ a-cont @end deffn environment? -@deffn primitive environment? obj +@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 environment-bound? -@deffn primitive environment-bound? env sym +@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 environment-ref -@deffn primitive environment-ref env sym +@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 environment-fold -@deffn primitive environment-fold env proc init +@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 @@ -573,7 +638,8 @@ using environment-fold: @end deffn environment-define -@deffn primitive environment-define env sym val +@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 @@ -584,7 +650,8 @@ immutable, signal an @code{environment:immutable-binding} error. @end deffn environment-undefine -@deffn primitive environment-undefine env sym +@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. @@ -593,7 +660,8 @@ immutable, signal an @code{environment:immutable-binding} error. @end deffn environment-set! -@deffn primitive environment-set! env sym val +@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. @@ -604,7 +672,8 @@ to an immutable location, signal an @end deffn environment-cell -@deffn primitive environment-cell env sym for_write +@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 @@ -620,7 +689,8 @@ re-bound to a new value cell, or becomes undefined. @end deffn environment-observe -@deffn primitive environment-observe env proc +@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 @@ -630,7 +700,8 @@ token is unspecified. @end deffn environment-observe-weak -@deffn primitive environment-observe-weak env proc +@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, @@ -640,7 +711,8 @@ list of observing procedures. @end deffn environment-unobserve -@deffn primitive environment-unobserve token +@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 @@ -650,20 +722,23 @@ bindings change. @end deffn make-leaf-environment -@deffn primitive make-leaf-environment +@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 leaf-environment? -@deffn primitive leaf-environment? object +@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 make-eval-environment -@deffn primitive make-eval-environment local imported +@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 @@ -688,33 +763,39 @@ In typical use, @var{local} will be a finite environment, and @end deffn eval-environment? -@deffn primitive eval-environment? object +@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 eval-environment-local -@deffn primitive eval-environment-local env +@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 eval-environment-set-local! -@deffn primitive eval-environment-set-local! env local +@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 eval-environment-imported -@deffn primitive eval-environment-imported env +@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 eval-environment-set-imported! -@deffn primitive eval-environment-set-imported! env imported +@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 make-import-environment -@deffn primitive make-import-environment imports conflict_proc +@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, @@ -743,25 +824,29 @@ if one of its imported environments changes. @end deffn import-environment? -@deffn primitive import-environment? object +@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 import-environment-imports -@deffn primitive import-environment-imports env +@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 import-environment-set-imports! -@deffn primitive import-environment-set-imports! env imports +@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 make-export-environment -@deffn primitive make-export-environment private signature +@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 @@ -809,33 +894,38 @@ if the bindings in private change. @end deffn export-environment? -@deffn primitive export-environment? object +@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 export-environment-private -@deffn primitive export-environment-private env +@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 export-environment-set-private! -@deffn primitive export-environment-set-private! env private +@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 export-environment-signature -@deffn primitive export-environment-signature env +@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 export-environment-set-signature! -@deffn primitive export-environment-set-signature! env signature +@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 eq? -@deffn primitive eq? x y +@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 @@ -843,7 +933,7 @@ capable of discerning distinctions finer than those detectable by @end deffn eqv? -@deffn primitive eqv? x y +@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 @@ -852,7 +942,7 @@ and inexact numbers. @end deffn equal? -@deffn primitive equal? x y +@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 @@ -862,7 +952,8 @@ terminate if its arguments are circular data structures. @end deffn scm-error -@deffn primitive scm-error key subr message args data +@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 @@ -879,13 +970,15 @@ it will usually be @code{#f}. @end deffn strerror -@deffn primitive strerror err +@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 apply:nconc2last -@deffn primitive apply:nconc2last lst +@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 @@ -896,27 +989,31 @@ destroys its argument, so use with care. @end deffn force -@deffn primitive force x +@deffn {Scheme Procedure} force x +@deffnx {C Function} scm_force (x) If the promise @var{x} has not been computed yet, compute and return @var{x}, otherwise just return the previously computed value. @end deffn promise? -@deffn primitive promise? obj +@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 cons-source -@deffn primitive cons-source xorig x y +@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 copy-tree -@deffn primitive copy-tree obj +@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 contents of both pairs and vectors (since both cons cells and vector @@ -925,44 +1022,50 @@ any other object. @end deffn primitive-eval -@deffn primitive primitive-eval exp +@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 eval -@deffn primitive eval exp module +@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 eval-options-interface -@deffn primitive eval-options-interface [setting] +@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}. @end deffn evaluator-traps-interface -@deffn primitive evaluator-traps-interface [setting] +@deffn {Scheme Procedure} evaluator-traps-interface [setting] +@deffnx {C Function} scm_evaluator_traps (setting) Option interface for the evaluator trap options. @end deffn defined? -@deffn primitive defined? sym [env] +@deffn {Scheme Procedure} defined? sym [env] +@deffnx {C Function} scm_definedp (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 map-in-order -@deffn primitive map-in-order +@deffn {Scheme Procedure} map-in-order implemented by the C function "scm_map" @end deffn load-extension -@deffn primitive load-extension lib init +@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 @@ -1000,8 +1103,9 @@ well. For example, @end deffn program-arguments -@deffn primitive program-arguments -@deffnx procedure command-line +@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 @@ -1009,7 +1113,8 @@ options like @code{-e} and @code{-l}. @end deffn make-fluid -@deffn primitive make-fluid +@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 @@ -1020,25 +1125,29 @@ in its own dynamic root, you can use fluids for thread local storage. @end deffn fluid? -@deffn primitive fluid? obj +@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 fluid-ref -@deffn primitive fluid-ref fluid +@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 fluid-set! -@deffn primitive fluid-set! fluid value +@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 with-fluids* -@deffn primitive with-fluids* fluids values thunk +@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 @@ -1046,7 +1155,8 @@ one after another. @var{thunk} must be a procedure with no argument. @end deffn setvbuf -@deffn primitive setvbuf port mode [size] +@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 @@ -1060,12 +1170,14 @@ If @var{size} is omitted, a default size will be used. @end deffn file-port? -@deffn primitive file-port? obj +@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 open-file -@deffn primitive open-file filename mode +@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 @@ -1106,32 +1218,37 @@ requested, @code{open-file} throws an exception. @end deffn gc-stats -@deffn primitive gc-stats +@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 object-address -@deffn primitive object-address obj +@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 gc -@deffn primitive gc +@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 %compute-slots -@deffn primitive %compute-slots class +@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 get-keyword -@deffn primitive get-keyword key l default_value +@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 @@ -1141,246 +1258,293 @@ If @var{l} does not hold a value for @var{key}, the value @end deffn %initialize-object -@deffn primitive %initialize-object obj initargs +@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 %prep-layout! -@deffn primitive %prep-layout! class +@deffn {Scheme Procedure} %prep-layout! class +@deffnx {C Function} scm_sys_prep_layout_x (class) @end deffn %inherit-magic! -@deffn primitive %inherit-magic! class dsupers +@deffn {Scheme Procedure} %inherit-magic! class dsupers +@deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers) @end deffn instance? -@deffn primitive instance? obj +@deffn {Scheme Procedure} instance? obj +@deffnx {C Function} scm_instance_p (obj) Return @code{#t} if @var{obj} is an instance. @end deffn class-name -@deffn primitive class-name obj +@deffn {Scheme Procedure} class-name obj +@deffnx {C Function} scm_class_name (obj) Return the class name of @var{obj}. @end deffn class-direct-supers -@deffn primitive class-direct-supers obj +@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 class-direct-slots -@deffn primitive class-direct-slots obj +@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 class-direct-subclasses -@deffn primitive class-direct-subclasses obj +@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 class-direct-methods -@deffn primitive class-direct-methods obj +@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 class-precedence-list -@deffn primitive class-precedence-list obj +@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 class-slots -@deffn primitive class-slots obj +@deffn {Scheme Procedure} class-slots obj +@deffnx {C Function} scm_class_slots (obj) Return the slot list of the class @var{obj}. @end deffn class-environment -@deffn primitive class-environment obj +@deffn {Scheme Procedure} class-environment obj +@deffnx {C Function} scm_class_environment (obj) Return the environment of the class @var{obj}. @end deffn generic-function-name -@deffn primitive generic-function-name obj +@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 generic-function-methods -@deffn primitive generic-function-methods obj +@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 method-generic-function -@deffn primitive method-generic-function obj +@deffn {Scheme Procedure} method-generic-function obj +@deffnx {C Function} scm_method_generic_function (obj) Return the generic function fot the method @var{obj}. @end deffn method-specializers -@deffn primitive method-specializers obj +@deffn {Scheme Procedure} method-specializers obj +@deffnx {C Function} scm_method_specializers (obj) Return specializers of the method @var{obj}. @end deffn method-procedure -@deffn primitive method-procedure obj +@deffn {Scheme Procedure} method-procedure obj +@deffnx {C Function} scm_method_procedure (obj) Return the procedure of the method @var{obj}. @end deffn accessor-method-slot-definition -@deffn primitive accessor-method-slot-definition obj +@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 %tag-body -@deffn primitive %tag-body body +@deffn {Scheme Procedure} %tag-body body +@deffnx {C Function} scm_sys_tag_body (body) Internal GOOPS magic---don't use this function! @end deffn make-unbound -@deffn primitive make-unbound +@deffn {Scheme Procedure} make-unbound +@deffnx {C Function} scm_make_unbound () Return the unbound value. @end deffn unbound? -@deffn primitive unbound? obj +@deffn {Scheme Procedure} unbound? obj +@deffnx {C Function} scm_unbound_p (obj) Return @code{#t} if @var{obj} is unbound. @end deffn assert-bound -@deffn primitive assert-bound value obj +@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 @@assert-bound-ref -@deffn primitive @@assert-bound-ref obj index +@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 %fast-slot-ref -@deffn primitive %fast-slot-ref obj index +@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 %fast-slot-set! -@deffn primitive %fast-slot-set! obj index value +@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 slot-ref-using-class -@deffn primitive slot-ref-using-class class obj slot_name +@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 slot-set-using-class! -@deffn primitive slot-set-using-class! class obj slot_name value +@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 slot-bound-using-class? -@deffn primitive slot-bound-using-class? class obj slot_name +@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 slot-exists-using-class? -@deffn primitive slot-exists-using-class? class obj slot_name +@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 slot-ref -@deffn primitive slot-ref obj slot_name +@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 slot-set! -@deffn primitive slot-set! obj slot_name value +@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 slot-bound? -@deffn primitive slot-bound? obj slot_name +@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 slot-exists? -@deffn primitive slot-exists? obj slot_name +@deffn {Scheme Procedure} slot-exists? obj slot_name +@deffnx {C Function} scm_slots_exists_p (obj, slot_name) Return @code{#t} if @var{obj} has a slot named @var{slot_name}. @end deffn %allocate-instance -@deffn primitive %allocate-instance class initargs +@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 %set-object-setter! -@deffn primitive %set-object-setter! obj setter +@deffn {Scheme Procedure} %set-object-setter! obj setter +@deffnx {C Function} scm_sys_set_object_setter_x (obj, setter) @end deffn %modify-instance -@deffn primitive %modify-instance old new +@deffn {Scheme Procedure} %modify-instance old new +@deffnx {C Function} scm_sys_modify_instance (old, new) @end deffn %modify-class -@deffn primitive %modify-class old new +@deffn {Scheme Procedure} %modify-class old new +@deffnx {C Function} scm_sys_modify_class (old, new) @end deffn %invalidate-class -@deffn primitive %invalidate-class class +@deffn {Scheme Procedure} %invalidate-class class +@deffnx {C Function} scm_sys_invalidate_class (class) @end deffn %invalidate-method-cache! -@deffn primitive %invalidate-method-cache! gf +@deffn {Scheme Procedure} %invalidate-method-cache! gf +@deffnx {C Function} scm_sys_invalidate_method_cache_x (gf) @end deffn generic-capability? -@deffn primitive generic-capability? proc +@deffn {Scheme Procedure} generic-capability? proc +@deffnx {C Function} scm_generic_capability_p (proc) @end deffn enable-primitive-generic! -@deffn primitive enable-primitive-generic! . subrs +@deffn {Scheme Procedure} enable-primitive-generic! . subrs +@deffnx {C Function} scm_enable_primitive_generic_x (subrs) @end deffn primitive-generic-generic -@deffn primitive primitive-generic-generic subr +@deffn {Scheme Procedure} primitive-generic-generic subr +@deffnx {C Function} scm_primitive_generic_generic (subr) @end deffn make -@deffn primitive make . args +@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 find-method -@deffn primitive find-method . l +@deffn {Scheme Procedure} find-method . l +@deffnx {C Function} scm_find_method (l) @end deffn %method-more-specific? -@deffn primitive %method-more-specific? m1 m2 targs +@deffn {Scheme Procedure} %method-more-specific? m1 m2 targs +@deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs) @end deffn %goops-loaded -@deffn primitive %goops-loaded +@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 make-guardian -@deffn primitive make-guardian [greedy_p] +@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. @@ -1409,24 +1573,28 @@ paper still (mostly) accurately describes the interface). @end deffn guardian-destroyed? -@deffn primitive guardian-destroyed? guardian +@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 guardian-greedy? -@deffn primitive guardian-greedy? guardian +@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 destroy-guardian! -@deffn primitive destroy-guardian! guardian +@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 hashq -@deffn primitive hashq key size +@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 @@ -1440,7 +1608,8 @@ different values, since @code{foo} will be garbage collected. @end deffn hashv -@deffn primitive hashv key size +@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 @@ -1454,7 +1623,8 @@ different values, since @code{foo} will be garbage collected. @end deffn hash -@deffn primitive hash key size +@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 @@ -1462,7 +1632,8 @@ integer in the range 0 to @var{size} - 1. @end deffn hashq-get-handle -@deffn primitive hashq-get-handle table key +@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. @@ -1470,14 +1641,16 @@ Uses @code{eq?} for equality testing. @end deffn hashq-create-handle! -@deffn primitive hashq-create-handle! table key init +@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 hashq-ref -@deffn primitive hashq-ref table key [dflt] +@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 @@ -1485,19 +1658,22 @@ is supplied). Uses @code{eq?} for equality testing. @end deffn hashq-set! -@deffn primitive hashq-set! table key val +@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 hashq-remove! -@deffn primitive hashq-remove! table key +@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 hashv-get-handle -@deffn primitive hashv-get-handle table key +@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. @@ -1505,14 +1681,16 @@ Uses @code{eqv?} for equality testing. @end deffn hashv-create-handle! -@deffn primitive hashv-create-handle! table key init +@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 hashv-ref -@deffn primitive hashv-ref table key [dflt] +@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 @@ -1520,19 +1698,22 @@ is supplied). Uses @code{eqv?} for equality testing. @end deffn hashv-set! -@deffn primitive hashv-set! table key val +@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 hashv-remove! -@deffn primitive hashv-remove! table key +@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 hash-get-handle -@deffn primitive hash-get-handle table key +@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. @@ -1540,14 +1721,16 @@ Uses @code{equal?} for equality testing. @end deffn hash-create-handle! -@deffn primitive hash-create-handle! table key init +@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 hash-ref -@deffn primitive hash-ref table key [dflt] +@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 @@ -1555,20 +1738,23 @@ is supplied). Uses @code{equal?} for equality testing. @end deffn hash-set! -@deffn primitive hash-set! table key val +@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 hash-remove! -@deffn primitive hash-remove! table key +@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 hashx-get-handle -@deffn primitive hashx-get-handle hash assoc table key +@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 @@ -1578,7 +1764,8 @@ table size. @code{assoc} must be an associator function, like @end deffn hashx-create-handle! -@deffn primitive hashx-create-handle! hash assoc table key init +@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 @@ -1588,7 +1775,8 @@ table size. @code{assoc} must be an associator function, like @end deffn hashx-ref -@deffn primitive hashx-ref hash assoc table key [dflt] +@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 @@ -1601,7 +1789,8 @@ equivalent to @code{hashx-ref hashq assq table key}. @end deffn hashx-set! -@deffn primitive hashx-set! hash assoc table key val +@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 @@ -1614,7 +1803,8 @@ equivalent to @code{hashx-set! hashq assq table key}. @end deffn hash-fold -@deffn primitive hash-fold proc init table +@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 @@ -1626,25 +1816,29 @@ table into an a-list of key-value pairs. @end deffn make-hook -@deffn primitive make-hook [n_args] +@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 hook? -@deffn primitive hook? x +@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 hook-empty? -@deffn primitive hook-empty? hook +@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 add-hook! -@deffn primitive add-hook! hook proc [append_p] +@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 @@ -1652,31 +1846,36 @@ procedure is not specified. @end deffn remove-hook! -@deffn primitive remove-hook! hook proc +@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 reset-hook! -@deffn primitive reset-hook! hook +@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 run-hook -@deffn primitive run-hook hook . args +@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 hook->list -@deffn primitive hook->list hook +@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 ftell -@deffn primitive ftell fd_port +@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: @@ -1686,7 +1885,8 @@ Return an integer representing the current position of @end deffn redirect-port -@deffn primitive redirect-port old new +@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. @@ -1703,14 +1903,16 @@ revealed counts. @end deffn dup->fdes -@deffn primitive dup->fdes fd_or_port [fd] +@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 dup2 -@deffn primitive dup2 oldfd newfd +@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 @@ -1722,19 +1924,22 @@ The return value is unspecified. @end deffn fileno -@deffn primitive fileno port +@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 isatty? -@deffn primitive isatty? port +@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 fdopen -@deffn primitive fdopen fdes modes +@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 @@ -1742,7 +1947,8 @@ same as that accepted by @ref{File Ports, open-file}. @end deffn primitive-move->fdes -@deffn primitive primitive-move->fdes port fd +@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 @@ -1752,68 +1958,78 @@ required value or @code{#t} if it was moved. @end deffn fdes->ports -@deffn primitive fdes->ports fd +@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 make-keyword-from-dash-symbol -@deffn primitive make-keyword-from-dash-symbol symbol +@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 keyword? -@deffn primitive keyword? obj +@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 keyword-dash-symbol -@deffn primitive keyword-dash-symbol keyword +@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 nil-cons -@deffn primitive nil-cons x y +@deffn {Scheme Procedure} nil-cons x y +@deffnx {C Function} scm_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 nil-car -@deffn primitive nil-car x +@deffn {Scheme Procedure} nil-car x +@deffnx {C Function} scm_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 nil-cdr -@deffn primitive nil-cdr x +@deffn {Scheme Procedure} nil-cdr x +@deffnx {C Function} scm_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 null -@deffn primitive null x +@deffn {Scheme Procedure} null x +@deffnx {C Function} scm_null (x) Return LISP's @code{t} if @var{x} is nil in the LISP sense, return LISP's nil otherwise. @end deffn nil-eq -@deffn primitive nil-eq x y +@deffn {Scheme Procedure} 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 list -@deffn primitive list . objs +@deffn {Scheme Procedure} list . objs +@deffnx {C Function} scm_list (objs) Return a list containing @var{objs}, the arguments to @code{list}. @end deffn cons* -@deffn primitive cons* arg . rest +@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 @@ -1823,22 +2039,26 @@ Schemes and in Common LISP. @end deffn null? -@deffn primitive null? x +@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 list? -@deffn primitive list? x +@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 length -@deffn primitive length lst +@deffn {Scheme Procedure} length lst +@deffnx {C Function} scm_length (lst) Return the number of elements in list @var{lst}. @end deffn append -@deffn primitive append . args +@deffn {Scheme Procedure} append . args +@deffnx {C Function} scm_append (args) Return a list consisting of the elements the lists passed as arguments. @lisp @@ -1857,7 +2077,8 @@ if the last argument is not a proper list. @end deffn append! -@deffn primitive append! . lists +@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 @@ -1866,19 +2087,22 @@ the mutated list. @end deffn last-pair -@deffn primitive last-pair lst +@deffn {Scheme Procedure} last-pair lst +@deffnx {C Function} scm_last_pair (lst) Return a pointer to the last pair in @var{lst}, signalling an error if @var{lst} is circular. @end deffn reverse -@deffn primitive reverse lst +@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 reverse! -@deffn primitive reverse! lst [new_tail] +@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 @@ -1893,23 +2117,26 @@ of the modified list is not lost, it is wise to save the return value of @end deffn list-ref -@deffn primitive list-ref list k +@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 list-set! -@deffn primitive list-set! list k val +@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 list-cdr-ref -@deffn primitive list-cdr-ref +@deffn {Scheme Procedure} list-cdr-ref implemented by the C function "scm_list_tail" @end deffn list-tail -@deffn primitive list-tail lst k -@deffnx primitive list-cdr-ref lst k +@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. @@ -1919,23 +2146,27 @@ or returning the results of cdring @var{k} times down @var{lst}. @end deffn list-cdr-set! -@deffn primitive list-cdr-set! list k val +@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 list-head -@deffn primitive list-head lst k +@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 list-copy -@deffn primitive list-copy lst +@deffn {Scheme Procedure} list-copy lst +@deffnx {C Function} scm_list_copy (lst) Return a (newly-created) copy of @var{lst}. @end deffn memq -@deffn primitive memq x lst +@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 @@ -1945,7 +2176,8 @@ returned. @end deffn memv -@deffn primitive memv x lst +@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 @@ -1955,7 +2187,8 @@ returned. @end deffn member -@deffn primitive member x lst +@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} @@ -1965,9 +2198,10 @@ empty list) is returned. @end deffn delq! -@deffn primitive delq! item lst -@deffnx primitive delv! item lst -@deffnx primitive delete! item lst +@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} rather than creating a new list. Caveat evaluator: Like other @@ -1977,19 +2211,22 @@ destructive list functions, these functions cannot modify the binding of @end deffn delv! -@deffn primitive delv! item lst +@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 delete! -@deffn primitive delete! item lst +@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 delq -@deffn primitive delq item lst +@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 @@ -1997,7 +2234,8 @@ Return a newly-created copy of @var{lst} with elements @end deffn delv -@deffn primitive delv item lst +@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 @@ -2005,7 +2243,8 @@ Return a newly-created copy of @var{lst} with elements @end deffn delete -@deffn primitive delete item lst +@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} @@ -2013,28 +2252,32 @@ against @var{item} with @code{equal?}. @end deffn delq1! -@deffn primitive delq1! item lst +@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 delv1! -@deffn primitive delv1! item lst +@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 delete1! -@deffn primitive delete1! item lst +@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 primitive-load -@deffn primitive primitive-load filename +@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 @@ -2045,26 +2288,30 @@ documentation for @code{%load-hook} later in this section. @end deffn %package-data-dir -@deffn primitive %package-data-dir +@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 %library-dir -@deffn primitive %library-dir +@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 %site-dir -@deffn primitive %site-dir +@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 parse-path -@deffn primitive parse-path path [tail] +@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} @@ -2072,7 +2319,8 @@ is returned. @end deffn search-path -@deffn primitive search-path path filename [extensions] +@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 @@ -2083,7 +2331,8 @@ concatenated with each @var{extension}. @end deffn %search-load-path -@deffn primitive %search-load-path filename +@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 @@ -2094,7 +2343,8 @@ will try each extension automatically. @end deffn primitive-load-path -@deffn primitive primitive-load-path filename +@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, @@ -2102,7 +2352,8 @@ an error is signalled. @end deffn procedure->syntax -@deffn primitive procedure->syntax code +@deffn {Scheme Procedure} procedure->syntax code +@deffnx {C Function} scm_makacro (code) Return a @dfn{macro} which, when a symbol defined to this value appears as the first symbol in an expression, returns the result of applying @var{code} to the expression and the @@ -2110,7 +2361,8 @@ environment. @end deffn procedure->macro -@deffn primitive procedure->macro code +@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 @@ -2128,7 +2380,8 @@ passed to @var{code}. For example: @end deffn procedure->memoizing-macro -@deffn primitive procedure->memoizing-macro code +@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, evaluates the result of applying @var{proc} to the expression and the @@ -2146,43 +2399,50 @@ passed to @var{proc}. For example: @end deffn macro? -@deffn primitive macro? obj +@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 macro-type -@deffn primitive macro-type m +@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 macro-name -@deffn primitive macro-name m +@deffn {Scheme Procedure} macro-name m +@deffnx {C Function} scm_macro_name (m) Return the name of the macro @var{m}. @end deffn macro-transformer -@deffn primitive macro-transformer m +@deffn {Scheme Procedure} macro-transformer m +@deffnx {C Function} scm_macro_transformer (m) Return the transformer of the macro @var{m}. @end deffn current-module -@deffn primitive current-module +@deffn {Scheme Procedure} current-module +@deffnx {C Function} scm_current_module () Return the current module. @end deffn set-current-module -@deffn primitive set-current-module module +@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 interaction-environment -@deffn primitive interaction-environment +@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 @@ -2191,45 +2451,52 @@ evaluate expressions dynamically typed by the user. @end deffn env-module -@deffn primitive env-module env +@deffn {Scheme Procedure} env-module env +@deffnx {C Function} scm_env_module (env) Return the module of @var{ENV}, a lexical environment. @end deffn standard-eval-closure -@deffn primitive standard-eval-closure module +@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 standard-interface-eval-closure -@deffn primitive standard-interface-eval-closure module +@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 %get-pre-modules-obarray -@deffn primitive %get-pre-modules-obarray +@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 exact? -@deffn primitive exact? x +@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 odd? -@deffn primitive odd? n +@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 even? -@deffn primitive even? n +@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 logand -@deffn primitive logand n1 n2 +@deffn {Scheme Procedure} logand n1 n2 Return the bitwise AND of the integer arguments. @lisp @@ -2240,7 +2507,7 @@ Return the bitwise AND of the integer arguments. @end deffn logior -@deffn primitive logior n1 n2 +@deffn {Scheme Procedure} logior n1 n2 Return the bitwise OR of the integer arguments. @lisp @@ -2251,7 +2518,7 @@ Return the bitwise OR of the integer arguments. @end deffn logxor -@deffn primitive logxor n1 n2 +@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 @@ -2263,7 +2530,8 @@ set in the result if it is set in an odd number of arguments. @end deffn logtest -@deffn primitive logtest j k +@deffn {Scheme Procedure} logtest j k +@deffnx {C Function} scm_logtest (j, k) @lisp (logtest j k) @equiv{} (not (zero? (logand j k))) @@ -2273,7 +2541,8 @@ set in the result if it is set in an odd number of arguments. @end deffn logbit? -@deffn primitive logbit? index j +@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) @@ -2286,7 +2555,8 @@ set in the result if it is set in an odd number of arguments. @end deffn lognot -@deffn primitive lognot n +@deffn {Scheme Procedure} lognot n +@deffnx {C Function} scm_lognot (n) Return the integer which is the 2s-complement of the integer argument. @@ -2299,7 +2569,8 @@ argument. @end deffn integer-expt -@deffn primitive integer-expt n k +@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 @var{k}. @@ -2312,7 +2583,8 @@ Return @var{n} raised to the non-negative integer exponent @end deffn ash -@deffn primitive ash n cnt +@deffn {Scheme Procedure} ash n cnt +@deffnx {C Function} scm_ash (n, cnt) The function ash performs an arithmetic shift left by @var{cnt} bits (or shift right, if @var{cnt} is negative). 'Arithmetic' means, that the function does not guarantee to keep the bit @@ -2331,7 +2603,8 @@ Formally, the function returns an integer equivalent to @end deffn bit-extract -@deffn primitive bit-extract n start end +@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. @@ -2345,7 +2618,8 @@ through @var{end} (exclusive) bits of @var{n}. The @end deffn logcount -@deffn primitive logcount n +@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 @@ -2362,7 +2636,8 @@ representation are counted. If 0, 0 is returned. @end deffn integer-length -@deffn primitive integer-length n +@deffn {Scheme Procedure} integer-length n +@deffnx {C Function} scm_integer_length (n) Return the number of bits neccessary to represent @var{n}. @lisp @@ -2376,14 +2651,16 @@ Return the number of bits neccessary to represent @var{n}. @end deffn number->string -@deffn primitive number->string n [radix] +@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 string->number -@deffn primitive string->number string [radix] +@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} @@ -2395,12 +2672,13 @@ syntactically valid notation for a number, then @end deffn number? -@deffn primitive number? +@deffn {Scheme Procedure} number? implemented by the C function "scm_number_p" @end deffn complex? -@deffn primitive complex? x +@deffn {Scheme Procedure} complex? x +@deffnx {C Function} scm_number_p (x) Return @code{#t} if @var{x} is a complex number, @code{#f} else. Note that the sets of real, rational and integer values form subsets of the set of complex numbers, i. e. the @@ -2409,12 +2687,13 @@ rational or integer number. @end deffn real? -@deffn primitive real? +@deffn {Scheme Procedure} real? implemented by the C function "scm_real_p" @end deffn rational? -@deffn primitive rational? x +@deffn {Scheme Procedure} rational? x +@deffnx {C Function} scm_real_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 the set of rational numbers, i. e. the predicate will also be @@ -2424,25 +2703,29 @@ precision. @end deffn integer? -@deffn primitive integer? x +@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 inexact? -@deffn primitive inexact? x +@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 $expt -@deffn primitive $expt x y +@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 $atan2 -@deffn primitive $atan2 x y +@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 @@ -2451,111 +2734,126 @@ procedure does not accept complex arguments. @end deffn make-rectangular -@deffn primitive make-rectangular real imaginary +@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 make-polar -@deffn primitive make-polar x y +@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 inexact->exact -@deffn primitive inexact->exact z +@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 class-of -@deffn primitive class-of x +@deffn {Scheme Procedure} class-of x +@deffnx {C Function} scm_class_of (x) Return the class of @var{x}. @end deffn entity? -@deffn primitive entity? obj +@deffn {Scheme Procedure} entity? obj +@deffnx {C Function} scm_entity_p (obj) Return @code{#t} if @var{obj} is an entity. @end deffn operator? -@deffn primitive operator? obj +@deffn {Scheme Procedure} operator? obj +@deffnx {C Function} scm_operator_p (obj) Return @code{#t} if @var{obj} is an operator. @end deffn valid-object-procedure? -@deffn primitive valid-object-procedure? proc +@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 set-object-procedure! -@deffn primitive set-object-procedure! obj proc +@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 make-class-object -@deffn primitive make-class-object metaclass layout +@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 make-subclass-object -@deffn primitive make-subclass-object class layout +@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 object-properties -@deffn primitive object-properties obj -@deffnx primitive procedure-properties obj +@deffn {Scheme Procedure} object-properties obj +@deffnx {C Function} scm_object_properties (obj) Return @var{obj}'s property list. @end deffn set-object-properties! -@deffn primitive set-object-properties! obj alist -@deffnx primitive set-procedure-properties! obj alist +@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 object-property -@deffn primitive object-property obj key -@deffnx primitive procedure-property obj key +@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 set-object-property! -@deffn primitive set-object-property! obj key value -@deffnx primitive set-procedure-property! obj key value +@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 cons -@deffn primitive cons x y +@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 pair? -@deffn primitive pair? x +@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 set-car! -@deffn primitive set-car! pair value +@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 set-cdr! -@deffn primitive set-cdr! pair value +@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 char-ready? -@deffn primitive char-ready? [port] +@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 @@ -2572,7 +2870,8 @@ interactive port that has no ready characters.} @end deffn drain-input -@deffn primitive drain-input port +@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., @@ -2590,14 +2889,16 @@ for further input. @end deffn current-input-port -@deffn primitive current-input-port +@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 current-output-port -@deffn primitive current-output-port +@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 @@ -2605,49 +2906,57 @@ Unix and C terminology. @end deffn current-error-port -@deffn primitive current-error-port +@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 current-load-port -@deffn primitive current-load-port +@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 set-current-input-port -@deffn primitive set-current-input-port port -@deffnx primitive set-current-output-port port -@deffnx primitive set-current-error-port port +@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 set-current-output-port -@deffn primitive set-current-output-port port +@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 set-current-error-port -@deffn primitive set-current-error-port port +@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 port-revealed -@deffn primitive port-revealed port +@deffn {Scheme Procedure} port-revealed port +@deffnx {C Function} scm_port_revealed (port) Return the revealed count for @var{port}. @end deffn set-port-revealed! -@deffn primitive set-port-revealed! port rcount +@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 port-mode -@deffn primitive port-mode port +@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 @@ -2655,7 +2964,8 @@ used only during port creation are not retained. @end deffn close-port -@deffn primitive close-port port +@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 @@ -2665,7 +2975,8 @@ descriptors. @end deffn close-input-port -@deffn primitive close-input-port port +@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. @@ -2675,7 +2986,8 @@ which can close file descriptors. @end deffn close-output-port -@deffn primitive close-output-port port +@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. @@ -2685,7 +2997,8 @@ which can close file descriptors. @end deffn port-for-each -@deffn primitive port-for-each proc +@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 @@ -2695,40 +3008,46 @@ have no effect as far as @var{port-for-each} is concerned. @end deffn input-port? -@deffn primitive input-port? x +@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 output-port? -@deffn primitive output-port? x +@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 port? -@deffn primitive port? x +@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 port-closed? -@deffn primitive port-closed? port +@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 eof-object? -@deffn primitive eof-object? x +@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 force-output -@deffn primitive force-output [port] +@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 @@ -2739,20 +3058,23 @@ The return value is unspecified. @end deffn flush-all-ports -@deffn primitive flush-all-ports +@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 read-char -@deffn primitive read-char [port] +@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 peek-char -@deffn primitive peek-char [port] +@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 @@ -2768,7 +3090,8 @@ to @code{read-char} would have hung.} @end deffn unread-char -@deffn primitive unread-char cobj [port] +@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 @@ -2776,7 +3099,8 @@ not supplied, the current input port is used. @end deffn unread-string -@deffn primitive unread-string str port +@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 @@ -2784,7 +3108,8 @@ unread characters will be read again in last-in first-out order. If @end deffn seek -@deffn primitive seek fd_port offset whence +@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}. @@ -2811,7 +3136,8 @@ that the current position of a port can be obtained using: @end deffn truncate-file -@deffn primitive truncate-file object [length] +@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. @@ -2821,18 +3147,21 @@ position. The return value is unspecified. @end deffn port-line -@deffn primitive port-line port +@deffn {Scheme Procedure} port-line port +@deffnx {C Function} scm_port_line (port) Return the current line number for @var{port}. @end deffn set-port-line! -@deffn primitive set-port-line! port line +@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}. @end deffn port-column -@deffn primitive port-column port -@deffnx primitive port-line port +@deffn {Scheme Procedure} port-column port +@deffnx {Scheme Procedure} port-line port +@deffnx {C Function} scm_port_column (port) Return the current column number or line number of @var{port}, using the current input port if none is specified. If the number is unknown, the result is #f. Otherwise, the result is a 0-origin integer @@ -2844,21 +3173,24 @@ what non-programmers will find most natural.) @end deffn set-port-column! -@deffn primitive set-port-column! port column -@deffnx primitive set-port-line! port line +@deffn {Scheme Procedure} set-port-column! port column +@deffnx {Scheme Procedure} set-port-line! port line +@deffnx {C Function} scm_set_port_column_x (port, column) Set the current column or line number of @var{port}, using the current input port if none is specified. @end deffn port-filename -@deffn primitive port-filename port +@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 set-port-filename! -@deffn primitive set-port-filename! port filename +@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 @@ -2866,7 +3198,8 @@ source of data, but only the value that is returned by @end deffn %make-void-port -@deffn primitive %make-void-port mode +@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 specifies the input/output modes for this port: see the @@ -2874,7 +3207,8 @@ documentation for @code{open-file} in @ref{File Ports}. @end deffn print-options-interface -@deffn primitive print-options-interface [setting] +@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!} @@ -2882,7 +3216,8 @@ and @code{print-options}. @end deffn simple-format -@deffn primitive simple-format destination message . args +@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 @@ -2897,65 +3232,78 @@ containing the formatted text. Does not add a trailing newline. @end deffn newline -@deffn primitive newline [port] +@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 write-char -@deffn primitive write-char chr [port] +@deffn {Scheme Procedure} write-char chr [port] +@deffnx {C Function} scm_write_char (chr, port) Send character @var{chr} to @var{port}. @end deffn port-with-print-state -@deffn primitive port-with-print-state port pstate +@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}. @end deffn get-print-state -@deffn primitive get-print-state port +@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 procedure-properties -@deffn primitive procedure-properties proc +@deffn {Scheme Procedure} procedure-properties proc +@deffnx {C Function} scm_procedure_properties (proc) Return @var{obj}'s property list. @end deffn set-procedure-properties! -@deffn primitive set-procedure-properties! proc new_val +@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 procedure-property -@deffn primitive procedure-property p k +@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 set-procedure-property! -@deffn primitive set-procedure-property! p k v +@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 procedure? -@deffn primitive procedure? obj +@deffn {Scheme Procedure} procedure? obj +@deffnx {C Function} scm_procedure_p (obj) Return @code{#t} if @var{obj} is a procedure. @end deffn closure? -@deffn primitive closure? obj +@deffn {Scheme Procedure} closure? obj +@deffnx {C Function} scm_closure_p (obj) Return @code{#t} if @var{obj} is a closure. @end deffn thunk? -@deffn primitive thunk? obj +@deffn {Scheme Procedure} thunk? obj +@deffnx {C Function} scm_thunk_p (obj) Return @code{#t} if @var{obj} is a thunk. @end deffn procedure-documentation -@deffn primitive procedure-documentation proc +@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 @@ -2963,25 +3311,29 @@ documentation for that procedure. @end deffn procedure-with-setter? -@deffn primitive procedure-with-setter? obj +@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 make-procedure-with-setter -@deffn primitive make-procedure-with-setter procedure setter +@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 procedure -@deffn primitive procedure proc +@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 primitive-make-property -@deffn primitive primitive-make-property not_found_proc +@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 @@ -2989,7 +3341,8 @@ See @code{primitive-property-ref} for the significance of @end deffn primitive-property-ref -@deffn primitive primitive-property-ref prop obj +@deffn {Scheme Procedure} primitive-property-ref prop obj +@deffnx {C Function} scm_primitive_property_ref (prop, obj) Return the property @var{prop} of @var{obj}. When no value has yet been associated with @var{prop} and @var{obj}, call @var{not-found-proc} instead (see @code{primitive-make-property}) @@ -3000,17 +3353,20 @@ default value of @var{prop}. @end deffn primitive-property-set! -@deffn primitive primitive-property-set! prop obj val +@deffn {Scheme Procedure} primitive-property-set! prop obj val +@deffnx {C Function} scm_primitive_property_set_x (prop, obj, val) Associate @var{code} with @var{prop} and @var{obj}. @end deffn primitive-property-del! -@deffn primitive primitive-property-del! prop obj +@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 random -@deffn primitive random n [state] +@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 @@ -3026,23 +3382,27 @@ as a side effect of the random operation. @end deffn copy-random-state -@deffn primitive copy-random-state [state] +@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 seed->random-state -@deffn primitive seed->random-state seed +@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 random:uniform -@deffn primitive random:uniform [state] +@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 random:normal -@deffn primitive random:normal [state] +@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 @@ -3050,7 +3410,8 @@ normal distribution with mean m and standard deviation d use @end deffn random:solid-sphere! -@deffn primitive random:solid-sphere! v [state] +@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 @@ -3060,7 +3421,8 @@ The sum of the squares of the numbers is returned. @end deffn random:hollow-sphere! -@deffn primitive random:hollow-sphere! v [state] +@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 @@ -3070,21 +3432,24 @@ unit n-sphere. @end deffn random:normal-vector! -@deffn primitive random:normal-vector! v [state] +@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 random:exp -@deffn primitive random:exp [state] +@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 %read-delimited! -@deffn primitive %read-delimited! delims str gobble [port [start [end]]] +@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; @@ -3103,7 +3468,8 @@ a delimiter, this value is @code{#f}. @end deffn %read-line -@deffn primitive %read-line [port] +@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 @@ -3113,7 +3479,8 @@ delimiter may be either a newline or the @var{eof-object}; if @end deffn write-line -@deffn primitive write-line obj [port] +@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: @@ -3124,21 +3491,24 @@ used. This function is equivalent to: @end deffn read-options-interface -@deffn primitive read-options-interface [setting] +@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}. @end deffn read -@deffn primitive read [port] +@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 read-hash-extend -@deffn primitive read-hash-extend chr proc +@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 @@ -3147,7 +3517,8 @@ returned will be the return value of @code{read}. @end deffn call-with-dynamic-root -@deffn primitive call-with-dynamic-root thunk handler +@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 @@ -3193,7 +3564,8 @@ be under a new dynamic root.) @end deffn dynamic-root -@deffn primitive dynamic-root +@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?}. @@ -3202,7 +3574,8 @@ in no way depend on this. @end deffn read-string!/partial -@deffn primitive read-string!/partial str [port_or_fdes [start [end]]] +@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 @@ -3243,7 +3616,8 @@ end-of-file check. @end deffn write-string/partial -@deffn primitive write-string/partial str [port_or_fdes [start [end]]] +@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 @@ -3288,7 +3662,8 @@ return 0 immediately if the request size is 0 bytes. @end deffn sigaction -@deffn primitive sigaction signum [handler [flags]] +@deffn {Scheme Procedure} sigaction signum [handler [flags]] +@deffnx {C Function} scm_sigaction (signum, handler, flags) Install or report the signal handler for a specified signal. @var{signum} is the signal number, which can be specified using the value @@ -3318,13 +3693,15 @@ structures. @end deffn restore-signals -@deffn primitive restore-signals +@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 alarm -@deffn primitive alarm i +@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 @@ -3337,7 +3714,8 @@ no previous alarm, the return value is zero. @end deffn setitimer -@deffn primitive setitimer which_timer interval_seconds interval_microseconds value_seconds value_microseconds +@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. @@ -3356,7 +3734,8 @@ the seconds and microseconds of the timer @code{it_value}. @end deffn getitimer -@deffn primitive getitimer which_timer +@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''. @@ -3371,33 +3750,38 @@ the seconds and microseconds of the timer @code{it_value}. @end deffn pause -@deffn primitive pause +@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 sleep -@deffn primitive sleep i +@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 usleep -@deffn primitive usleep i +@deffn {Scheme Procedure} usleep i +@deffnx {C Function} scm_usleep (i) Sleep for I microseconds. @code{usleep} is not available on all platforms. @end deffn raise -@deffn primitive raise sig +@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 system -@deffn primitive system [cmd] +@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 @@ -3409,21 +3793,24 @@ indicating whether the command processor is available. @end deffn getenv -@deffn primitive getenv nam +@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 primitive-exit -@deffn primitive primitive-exit [status] +@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 restricted-vector-sort! -@deffn primitive restricted-vector-sort! vec less startpos endpos +@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 @@ -3431,24 +3818,28 @@ is not specified. @end deffn sorted? -@deffn primitive sorted? items less +@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 merge -@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 +@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 merge! -@deffn primitive merge! alist blist less +@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 @@ -3459,7 +3850,8 @@ Note: this does _not_ accept vectors. @end deffn sort! -@deffn primitive sort! items less +@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 @@ -3468,14 +3860,16 @@ This is not a stable sort. @end deffn sort -@deffn primitive sort items less +@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 stable-sort! -@deffn primitive stable-sort! items less +@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 @@ -3484,14 +3878,16 @@ This is a stable sort. @end deffn stable-sort -@deffn primitive stable-sort items less +@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 sort-list! -@deffn primitive sort-list! items less +@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. @@ -3499,41 +3895,48 @@ This is a stable sort. @end deffn sort-list -@deffn primitive sort-list items less +@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 source-properties -@deffn primitive source-properties obj +@deffn {Scheme Procedure} source-properties obj +@deffnx {C Function} scm_source_properties (obj) Return the source property association list of @var{obj}. @end deffn set-source-properties! -@deffn primitive set-source-properties! obj plist +@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 source-property -@deffn primitive source-property obj key +@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 set-source-property! -@deffn primitive set-source-property! obj key datum +@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 stack? -@deffn primitive stack? obj +@deffn {Scheme Procedure} stack? obj +@deffnx {C Function} scm_stack_p (obj) Return @code{#t} if @var{obj} is a calling stack. @end deffn make-stack -@deffn primitive make-stack obj . args +@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 @@ -3565,93 +3968,110 @@ taken as 0. @end deffn stack-id -@deffn primitive stack-id stack +@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 stack-ref -@deffn primitive stack-ref stack index +@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 stack-length -@deffn primitive stack-length stack +@deffn {Scheme Procedure} stack-length stack +@deffnx {C Function} scm_stack_length (stack) Return the length of @var{stack}. @end deffn frame? -@deffn primitive frame? obj +@deffn {Scheme Procedure} frame? obj +@deffnx {C Function} scm_frame_p (obj) Return @code{#t} if @var{obj} is a stack frame. @end deffn last-stack-frame -@deffn primitive last-stack-frame obj +@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 frame-number -@deffn primitive frame-number frame +@deffn {Scheme Procedure} frame-number frame +@deffnx {C Function} scm_frame_number (frame) Return the frame number of @var{frame}. @end deffn frame-source -@deffn primitive frame-source frame +@deffn {Scheme Procedure} frame-source frame +@deffnx {C Function} scm_frame_source (frame) Return the source of @var{frame}. @end deffn frame-procedure -@deffn primitive frame-procedure frame +@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 frame-arguments -@deffn primitive frame-arguments frame +@deffn {Scheme Procedure} frame-arguments frame +@deffnx {C Function} scm_frame_arguments (frame) Return the arguments of @var{frame}. @end deffn frame-previous -@deffn primitive frame-previous frame +@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 frame-next -@deffn primitive frame-next frame +@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 frame-real? -@deffn primitive frame-real? frame +@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 frame-procedure? -@deffn primitive frame-procedure? frame +@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 frame-evaluating-args? -@deffn primitive frame-evaluating-args? frame +@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 frame-overflow? -@deffn primitive frame-overflow? frame +@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 get-internal-real-time -@deffn primitive get-internal-real-time +@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 times -@deffn primitive times +@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: @@ -3676,20 +4096,23 @@ terminated child processes. @end deffn get-internal-run-time -@deffn primitive get-internal-run-time +@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 current-time -@deffn primitive current-time +@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 gettimeofday -@deffn primitive gettimeofday +@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 @@ -3697,7 +4120,8 @@ operating system. @end deffn localtime -@deffn primitive localtime time [zone] +@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 @@ -3706,14 +4130,16 @@ optionally specified by @var{zone} (a string), otherwise the @end deffn gmtime -@deffn primitive gmtime time +@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 mktime -@deffn primitive mktime sbd_time [zone] +@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). @@ -3725,7 +4151,8 @@ as @var{bd-time} but with normalized values. @end deffn tzset -@deffn primitive tzset +@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 @@ -3733,7 +4160,8 @@ timezone. @end deffn strftime -@deffn primitive strftime format stime +@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 @@ -3744,7 +4172,8 @@ is the formatted string. @end deffn strptime -@deffn primitive strptime format string +@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 @@ -3758,25 +4187,27 @@ which were used for the conversion. @end deffn string? -@deffn primitive string? obj -Return @code{#t} iff @var{obj} is a string, else returns -@code{#f}. +@deffn {Scheme Procedure} string? obj +@deffnx {C Function} scm_string_p (obj) +Return @code{#t} iff @var{obj} is a string, else @code{#f}. @end deffn list->string -@deffn primitive list->string +@deffn {Scheme Procedure} list->string implemented by the C function "scm_string" @end deffn string -@deffn primitive string . chrs -@deffnx primitive list->string chrs +@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 make-string -@deffn primitive make-string k [chr] +@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 @@ -3784,25 +4215,29 @@ of the @var{string} are unspecified. @end deffn string-length -@deffn primitive string-length string +@deffn {Scheme Procedure} string-length string +@deffnx {C Function} scm_string_length (string) Return the number of characters in @var{string}. @end deffn string-ref -@deffn primitive string-ref str k +@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 string-set! -@deffn primitive string-set! str k chr +@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 substring -@deffn primitive substring str start [end] +@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). @@ -3813,13 +4248,15 @@ exact integers satisfying: @end deffn string-append -@deffn primitive string-append . args +@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 string-index -@deffn primitive string-index str chr [frm [to]] +@deffn {Scheme Procedure} string-index str chr [frm [to]] +@deffnx {C Function} scm_string_index (str, chr, frm, to) Return the index of the first occurrence of @var{chr} in @var{str}. The optional integer arguments @var{frm} and @var{to} limit the search to a portion of the string. This @@ -3839,7 +4276,8 @@ procedure essentially implements the @code{index} or @end deffn string-rindex -@deffn primitive string-rindex str chr [frm [to]] +@deffn {Scheme Procedure} string-rindex str chr [frm [to]] +@deffnx {C Function} scm_string_rindex (str, chr, frm, to) Like @code{string-index}, but search from the right of the string rather than from the left. This procedure essentially implements the @code{rindex} or @code{strrchr} functions from @@ -3857,40 +4295,17 @@ the C library. @end lisp @end deffn -substring-move-left! -@deffn primitive substring-move-left! -implemented by the C function "scm_substring_move_x" -@end deffn - -substring-move-right! -@deffn primitive substring-move-right! -implemented by the C function "scm_substring_move_x" -@end deffn - substring-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 +@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. +@var{str1} and @var{str2} can be the same string. @end deffn substring-fill! -@deffn primitive substring-fill! str start end fill +@deffn {Scheme Procedure} substring-fill! str start end fill +@deffnx {C Function} scm_substring_fill_x (str, start, end, fill) Change every character in @var{str} between @var{start} and @var{end} to @var{fill}. @@ -3903,7 +4318,8 @@ y @end deffn string-null? -@deffn primitive string-null? str +@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 @@ -3914,7 +4330,8 @@ y @result{} "foo" @end deffn string->list -@deffn primitive string->list str +@deffn {Scheme Procedure} string->list str +@deffnx {C Function} scm_string_to_list (str) Return a newly allocated list of the characters that make up the given string @var{str}. @code{string->list} and @code{list->string} are inverses as far as @samp{equal?} is @@ -3922,18 +4339,21 @@ concerned. @end deffn string-copy -@deffn primitive string-copy str +@deffn {Scheme Procedure} string-copy str +@deffnx {C Function} scm_string_copy (str) Return a newly allocated copy of the given @var{string}. @end deffn string-fill! -@deffn primitive string-fill! str chr +@deffn {Scheme Procedure} string-fill! str chr +@deffnx {C Function} scm_string_fill_x (str, chr) Store @var{char} in every element of the given @var{string} and return an unspecified value. @end deffn string-upcase! -@deffn primitive string-upcase! str +@deffn {Scheme Procedure} string-upcase! str +@deffnx {C Function} scm_string_upcase_x (str) Destructively upcase every character in @var{str} and return @var{str}. @lisp @@ -3944,13 +4364,15 @@ y @result{} "ARRDEFG" @end deffn string-upcase -@deffn primitive string-upcase str +@deffn {Scheme Procedure} string-upcase str +@deffnx {C Function} scm_string_upcase (str) Return a freshly allocated string containing the characters of @var{str} in upper case. @end deffn string-downcase! -@deffn primitive string-downcase! str +@deffn {Scheme Procedure} string-downcase! str +@deffnx {C Function} scm_string_downcase_x (str) Destructively downcase every character in @var{str} and return @var{str}. @lisp @@ -3961,13 +4383,15 @@ y @result{} "arrdefg" @end deffn string-downcase -@deffn primitive string-downcase str +@deffn {Scheme Procedure} string-downcase str +@deffnx {C Function} scm_string_downcase (str) Return a freshly allocation string containing the characters in @var{str} in lower case. @end deffn string-capitalize! -@deffn primitive string-capitalize! str +@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}. @@ -3979,43 +4403,46 @@ y @result{} "Hello World" @end deffn string-capitalize -@deffn primitive string-capitalize str +@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 string-split -@deffn primitive string-split str chr +@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 string-ci->symbol -@deffn primitive string-ci->symbol str +@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. +is currently reading symbols case-insensitively. @end deffn string=? -@deffn primitive string=? s1 s2 +@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}. @@ -4027,7 +4454,7 @@ characters. @end deffn string-ci=? -@deffn primitive string-ci=? s1 s2 +@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 @@ -4035,80 +4462,84 @@ return @code{#f}. @end deffn string<? -@deffn primitive string<? s1 s2 +@deffn {Scheme Procedure} string<? s1 s2 Lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically less than @var{s2}. @end deffn string<=? -@deffn primitive string<=? s1 s2 +@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 string>? -@deffn primitive string>? s1 s2 +@deffn {Scheme Procedure} string>? s1 s2 Lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically greater than @var{s2}. @end deffn string>=? -@deffn primitive string>=? s1 s2 +@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 string-ci<? -@deffn primitive string-ci<? s1 s2 +@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 string-ci<=? -@deffn primitive string-ci<=? s1 s2 +@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 string-ci>? -@deffn primitive string-ci>? s1 s2 +@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 string-ci>=? -@deffn primitive string-ci>=? s1 s2 +@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 object->string -@deffn primitive object->string obj [printer] +@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 call-with-output-string -@deffn primitive call-with-output-string proc +@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 call-with-input-string -@deffn primitive call-with-input-string string proc +@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 open-input-string -@deffn primitive open-input-string str +@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 @@ -4116,7 +4547,8 @@ by the garbage collector if it becomes inaccessible. @end deffn open-output-string -@deffn primitive open-output-string +@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 @@ -4125,14 +4557,16 @@ inaccessible. @end deffn get-output-string -@deffn primitive get-output-string port +@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 eval-string -@deffn primitive eval-string string +@deffn {Scheme Procedure} eval-string string +@deffnx {C Function} scm_eval_string (string) 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 @@ -4140,7 +4574,8 @@ procedure @code{interaction-environment}. @end deffn make-struct-layout -@deffn primitive make-struct-layout fields +@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 @@ -4154,18 +4589,21 @@ indicate that the field is a tail-array. @end deffn struct? -@deffn primitive struct? x +@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 struct-vtable? -@deffn primitive struct-vtable? x +@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 make-struct -@deffn primitive make-struct vtable tail_array_size . init +@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}). @@ -4194,7 +4632,8 @@ For more information, see the documentation for @code{make-vtable-vtable}. @end deffn make-vtable-vtable -@deffn primitive make-vtable-vtable user_fields tail_array_size . init +@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 @@ -4254,8 +4693,9 @@ ball @result{} #<a green ball owned by Nisse> @end deffn struct-ref -@deffn primitive struct-ref handle pos -@deffnx primitive struct-set! struct n value +@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. @@ -4265,40 +4705,47 @@ integer value small enough to fit in one machine word. @end deffn struct-set! -@deffn primitive struct-set! handle pos val +@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 struct-vtable -@deffn primitive struct-vtable handle +@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 struct-vtable-tag -@deffn primitive struct-vtable-tag handle +@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 struct-vtable-name -@deffn primitive struct-vtable-name vtable +@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 set-struct-vtable-name! -@deffn primitive set-struct-vtable-name! vtable name +@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 symbol? -@deffn primitive symbol? obj +@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 symbol->string -@deffn primitive symbol->string s +@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 @@ -4325,7 +4772,8 @@ standard case is lower case: @end deffn string->symbol -@deffn primitive string->symbol string +@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 @@ -4349,7 +4797,8 @@ standard case is lower case: @end deffn gensym -@deffn primitive gensym [prefix] +@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 @@ -4358,32 +4807,38 @@ resetting the counter. @end deffn symbol-hash -@deffn primitive symbol-hash symbol +@deffn {Scheme Procedure} symbol-hash symbol +@deffnx {C Function} scm_symbol_hash (symbol) Return a hash value for @var{symbol}. @end deffn symbol-fref -@deffn primitive symbol-fref s +@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 symbol-pref -@deffn primitive symbol-pref s +@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 symbol-fset! -@deffn primitive symbol-fset! s val +@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 symbol-pset! -@deffn primitive symbol-pset! s val +@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 catch -@deffn primitive catch key thunk handler +@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: @@ -4405,7 +4860,8 @@ match this call to @code{catch}. @end deffn lazy-catch -@deffn primitive lazy-catch key thunk handler +@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: @@ -4413,7 +4869,8 @@ it must throw to another catch, or otherwise exit non-locally. @end deffn throw -@deffn primitive throw key . args +@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}. @@ -4424,7 +4881,8 @@ If there is no handler at all, Guile prints an error and then exits. @end deffn values -@deffn primitive values . args +@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 @@ -4433,56 +4891,64 @@ were not created by @code{call-with-values} is unspecified. @end deffn make-variable -@deffn primitive make-variable init +@deffn {Scheme Procedure} make-variable init +@deffnx {C Function} scm_make_variable (init) Return a variable initialized to value @var{init}. @end deffn make-undefined-variable -@deffn primitive make-undefined-variable +@deffn {Scheme Procedure} make-undefined-variable +@deffnx {C Function} scm_make_undefined_variable () Return a variable that is initially unbound. @end deffn variable? -@deffn primitive variable? obj +@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 variable-ref -@deffn primitive variable-ref var +@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 variable-set! -@deffn primitive variable-set! var val +@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 variable-bound? -@deffn primitive variable-bound? var +@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 vector? -@deffn primitive vector? obj +@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 list->vector -@deffn primitive list->vector +@deffn {Scheme Procedure} list->vector implemented by the C function "scm_vector" @end deffn vector -@deffn primitive vector . l -@deffnx primitive list->vector l -Return a newly allocated vector whose elements contain the +@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 @@ -4491,17 +4957,18 @@ given arguments. Analogous to @code{list}. @end deffn make-vector -@deffn primitive make-vector k [fill] +@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 vector->list -@deffn primitive vector->list v -Return a newly allocated list of the objects contained in the -elements of @var{vector}. +@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) @@ -4510,44 +4977,51 @@ elements of @var{vector}. @end deffn vector-fill! -@deffn primitive vector-fill! v fill -Store @var{fill} in every element of @var{vector}. The value +@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 vector-move-left! -@deffn primitive vector-move-left! vec1 start1 end1 vec2 start2 +@deffn {Scheme Procedure} vector-move-left! vec1 start1 end1 vec2 start2 +@deffnx {C Function} scm_vector_move_left_x (vec1, start1, end1, vec2, start2) Vector version of @code{substring-move-left!}. @end deffn vector-move-right! -@deffn primitive vector-move-right! vec1 start1 end1 vec2 start2 +@deffn {Scheme Procedure} vector-move-right! vec1 start1 end1 vec2 start2 +@deffnx {C Function} scm_vector_move_right_x (vec1, start1, end1, vec2, start2) Vector version of @code{substring-move-right!}. @end deffn major-version -@deffn primitive major-version +@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 minor-version -@deffn primitive minor-version +@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 micro-version -@deffn primitive micro-version +@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 version -@deffn primitive version -@deffnx primitive major-version -@deffnx primitive minor-version -@deffnx primitive micro-version +@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. @@ -4560,7 +5034,8 @@ or micro version number, respectively. @end deffn make-soft-port -@deffn primitive make-soft-port pv modes +@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 @@ -4605,7 +5080,8 @@ For example: @end deffn make-weak-vector -@deffn primitive make-weak-vector size [fill] +@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 @@ -4613,13 +5089,14 @@ empty list. @end deffn list->weak-vector -@deffn primitive list->weak-vector +@deffn {Scheme Procedure} list->weak-vector implemented by the C function "scm_weak_vector" @end deffn weak-vector -@deffn primitive weak-vector . l -@deffnx primitive list->weak-vector l +@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 @@ -4627,15 +5104,17 @@ the same way @code{list->vector} would. @end deffn weak-vector? -@deffn primitive weak-vector? obj +@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 make-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 +@deffn {Scheme Procedure} make-weak-key-hash-table size +@deffnx {Scheme Procedure} make-weak-value-hash-table size +@deffnx {Scheme Procedure} make-doubly-weak-hash-table size +@deffnx {C Function} scm_make_weak_key_hash_table (size) Return a weak hash table with @var{size} buckets. As with any hash table, choosing a good size for the table requires some caution. @@ -4645,44 +5124,51 @@ would modify regular hash tables. (@pxref{Hash Tables}) @end deffn make-weak-value-hash-table -@deffn primitive make-weak-value-hash-table size +@deffn {Scheme Procedure} make-weak-value-hash-table size +@deffnx {C Function} scm_make_weak_value_hash_table (size) Return a hash table with weak values with @var{size} buckets. (@pxref{Hash Tables}) @end deffn make-doubly-weak-hash-table -@deffn primitive make-doubly-weak-hash-table size +@deffn {Scheme Procedure} make-doubly-weak-hash-table size +@deffnx {C Function} scm_make_doubly_weak_hash_table (size) Return a hash table with weak keys and values with @var{size} buckets. (@pxref{Hash Tables}) @end deffn weak-key-hash-table? -@deffn primitive weak-key-hash-table? obj -@deffnx primitive weak-value-hash-table? obj -@deffnx primitive doubly-weak-hash-table? obj +@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 weak-value-hash-table? -@deffn primitive weak-value-hash-table? obj +@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 doubly-weak-hash-table? -@deffn primitive doubly-weak-hash-table? obj +@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 regexp? -@deffn primitive regexp? obj +@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 make-regexp -@deffn primitive make-regexp pat . flags +@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 @@ -4723,7 +5209,8 @@ one which comes last will override the earlier one. @end deffn regexp-exec -@deffn primitive regexp-exec rx str [start [flags]] +@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. @@ -4746,33 +5233,36 @@ considered the end of a line. @end deffn array-fill! -@deffn primitive array-fill! ra fill -Stores @var{fill} in every element of @var{array}. The value returned +@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 array-copy-in-order! -@deffn primitive array-copy-in-order! +@deffn {Scheme Procedure} array-copy-in-order! implemented by the C function "scm_array_copy_x" @end deffn array-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 +@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 array-map-in-order! -@deffn primitive array-map-in-order! +@deffn {Scheme Procedure} array-map-in-order! implemented by the C function "scm_array_map_x" @end deffn array-map! -@deffn primitive array-map! ra0 proc . lra -@deffnx primitive array-map-in-order! ra0 proc . lra +@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 @@ -4782,14 +5272,16 @@ unspecified. The order of application is unspecified. @end deffn array-for-each -@deffn primitive array-for-each proc ra0 . lra -@var{proc} is applied to each tuple of elements of @var{array0} @dots{} +@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 array-index-map! -@deffn primitive array-index-map! ra proc -applies @var{proc} to the indices of each element of @var{array} in +@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. @@ -4810,25 +5302,29 @@ Another example: @end deffn uniform-vector-length -@deffn primitive uniform-vector-length v +@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 array? -@deffn primitive array? v [prot] +@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 array-rank -@deffn primitive array-rank ra +@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 array-dimensions -@deffn primitive array-dimensions ra +@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 @@ -4837,23 +5333,27 @@ elements with a @code{0} minimum with one greater than the maximum. So: @end deffn shared-array-root -@deffn primitive shared-array-root ra +@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 shared-array-offset -@deffn primitive shared-array-offset ra +@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 shared-array-increments -@deffn primitive shared-array-increments ra +@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 dimensions->uniform-array -@deffn primitive dimensions->uniform-array dims prot [fill] -@deffnx primitive make-uniform-vector length prototype [fill] +@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 @@ -4861,7 +5361,8 @@ fill the array, otherwise @var{prototype} is used. @end deffn make-shared-array -@deffn primitive make-shared-array oldra mapfunc . dims +@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 @@ -4880,7 +5381,8 @@ it can be otherwise arbitrary. A simple example: @end deffn transpose-array -@deffn primitive transpose-array ra . args +@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}. @@ -4903,7 +5405,8 @@ have smaller rank than @var{array}. @end deffn enclose-array -@deffn primitive enclose-array ra . axes +@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 @@ -4928,38 +5431,41 @@ examples: @end deffn array-in-bounds? -@deffn primitive array-in-bounds? v . args +@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 array-ref -@deffn primitive array-ref +@deffn {Scheme Procedure} array-ref implemented by the C function "scm_uniform_vector_ref" @end deffn uniform-vector-ref -@deffn primitive uniform-vector-ref v args -@deffnx primitive array-ref v . args +@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 uniform-array-set1! -@deffn primitive uniform-array-set1! +@deffn {Scheme Procedure} uniform-array-set1! implemented by the C function "scm_array_set_x" @end deffn array-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 +@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 array-contents -@deffn primitive array-contents ra [strict] -@deffnx primitive array-contents array strict +@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 @@ -4973,12 +5479,13 @@ memory. @end deffn uniform-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 +@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. @@ -4992,8 +5499,9 @@ returned by @code{(current-input-port)}. @end deffn uniform-array-write -@deffn primitive uniform-array-write v [port_or_fd [start [end]]] -@deffnx primitive uniform-vector-write uve [port-or-fdes] [start] [end] +@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}. @@ -5008,33 +5516,37 @@ omitted, in which case it defaults to the value returned by @end deffn bit-count -@deffn primitive bit-count b bitvector +@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 bit-position -@deffn primitive bit-position item v k +@deffn {Scheme Procedure} bit-position item v k +@deffnx {C Function} scm_bit_position (item, v, k) Return the minimum index of an occurrence of @var{bool} in @var{bv} which is at least @var{k}. If no @var{bool} occurs within the specified range @code{#f} is returned. @end deffn bit-set*! -@deffn primitive bit-set*! v kv obj +@deffn {Scheme Procedure} bit-set*! v kv obj +@deffnx {C Function} scm_bit_set_star_x (v, kv, obj) If uve is a bit-vector @var{bv} and uve must be of the same length. If @var{bool} is @code{#t}, uve is OR'ed into @var{bv}; If @var{bool} is @code{#f}, the inversion of uve is AND'ed into @var{bv}. -If uve is a unsigned integer vector all the elements of uve +If uve is a unsigned long integer vector all the elements of uve must be between 0 and the @code{length} of @var{bv}. The bits of @var{bv} corresponding to the indexes in uve are set to @var{bool}. The return value is unspecified. @end deffn bit-count* -@deffn primitive bit-count* v kv obj +@deffn {Scheme Procedure} bit-count* v kv obj +@deffnx {C Function} scm_bit_count_star (v, kv, obj) Return @lisp (bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t). @@ -5043,19 +5555,22 @@ Return @end deffn bit-invert! -@deffn primitive bit-invert! v -Modifies @var{bv} by replacing each element with its negation. +@deffn {Scheme Procedure} bit-invert! v +@deffnx {C Function} scm_bit_invert_x (v) +Modify @var{bv} by replacing each element with its negation. @end deffn array->list -@deffn primitive array->list v +@deffn {Scheme Procedure} array->list v +@deffnx {C Function} scm_t_arrayo_list (v) Return a list consisting of all the elements, in order, of @var{array}. @end deffn list->uniform-array -@deffn primitive list->uniform-array ndim prot lst -@deffnx procedure list->uniform-vector prot lst +@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 @@ -5063,14 +5578,16 @@ done. @end deffn array-prototype -@deffn primitive array-prototype ra +@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 chown -@deffn primitive chown object owner group +@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 @@ -5086,7 +5603,8 @@ as @code{-1}, then that ID is not changed. @end deffn chmod -@deffn primitive chmod object mode +@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 @@ -5097,7 +5615,8 @@ The return value is unspecified. @end deffn umask -@deffn primitive umask [mode] +@deffn {Scheme Procedure} umask [mode] +@deffnx {C Function} scm_umask (mode) If @var{mode} is omitted, retuns 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. @@ -5106,13 +5625,15 @@ E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18. @end deffn open-fdes -@deffn primitive open-fdes path flags [mode] +@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 open -@deffn primitive open path flags [mode] +@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 @@ -5143,8 +5664,9 @@ for additional flags. @end deffn close -@deffn primitive close fd_or_port -Similar to close-port (@pxref{Generic Port Operations, close-port}), +@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 @@ -5152,7 +5674,8 @@ their revealed counts set to zero. @end deffn close-fdes -@deffn primitive close-fdes fd +@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}), @@ -5161,7 +5684,8 @@ The return value is unspecified. @end deffn stat -@deffn primitive stat object +@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 @@ -5221,7 +5745,8 @@ An integer representing the access permission bits. @end deffn link -@deffn primitive link oldpath newpath +@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 @@ -5229,18 +5754,21 @@ system. @end deffn rename-file -@deffn primitive rename-file oldname newname +@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 delete-file -@deffn primitive delete-file str +@deffn {Scheme Procedure} delete-file str +@deffnx {C Function} scm_delete_file (str) Deletes (or "unlinks") the file specified by @var{path}. @end deffn mkdir -@deffn primitive mkdir path [mode] +@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 @@ -5248,55 +5776,64 @@ umask. Otherwise they are set to the decimal value specified with @end deffn rmdir -@deffn primitive rmdir path +@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 directory-stream? -@deffn primitive directory-stream? obj +@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 opendir -@deffn primitive opendir dirname +@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 readdir -@deffn primitive readdir port +@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 rewinddir -@deffn primitive rewinddir port +@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 closedir -@deffn primitive closedir port +@deffn {Scheme Procedure} closedir port +@deffnx {C Function} scm_closedir (port) Close the directory stream @var{stream}. The return value is unspecified. @end deffn chdir -@deffn primitive chdir str +@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 getcwd -@deffn primitive getcwd +@deffn {Scheme Procedure} getcwd +@deffnx {C Function} scm_getcwd () Return the name of the current working directory. @end deffn select -@deffn primitive select reads writes excepts [secs [usecs]] +@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 exceptional conditions on a collection of ports or file @@ -5329,7 +5866,8 @@ An additional @code{select!} interface is provided. @end deffn fcntl -@deffn primitive fcntl object cmd [value] +@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. @@ -5358,7 +5896,8 @@ The value used to indicate the "close on exec" flag with @code{F_GETFL} or @end deffn fsync -@deffn primitive fsync object +@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. @@ -5366,39 +5905,45 @@ The return value is unspecified. @end deffn symlink -@deffn primitive symlink oldpath newpath +@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 readlink -@deffn primitive readlink path +@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 lstat -@deffn primitive lstat str +@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 copy-file -@deffn primitive copy-file oldfile newfile +@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 dirname -@deffn primitive dirname filename +@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 basename -@deffn primitive basename filename [suffix] +@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 @@ -5406,7 +5951,8 @@ If @var{suffix} is privided, and is equal to the end of @end deffn pipe -@deffn primitive pipe +@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 @@ -5423,41 +5969,47 @@ from the input port. @end deffn getgroups -@deffn primitive getgroups +@deffn {Scheme Procedure} getgroups +@deffnx {C Function} scm_getgroups () Return a vector of integers representing the current supplimentary group IDs. @end deffn getpw -@deffn primitive getpw [user] +@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 setpw -@deffn primitive setpw [arg] +@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 getgr -@deffn primitive getgr [name] +@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 setgr -@deffn primitive setgr [arg] +@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 kill -@deffn primitive kill pid sig +@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: @@ -5488,7 +6040,8 @@ Interrupt signal. @end deffn waitpid -@deffn primitive waitpid pid [options] +@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 @@ -5533,42 +6086,49 @@ The integer status value. @end deffn status:exit-val -@deffn primitive status:exit-val status +@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 status:term-sig -@deffn primitive status:term-sig status +@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 status:stop-sig -@deffn primitive status:stop-sig status +@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 getppid -@deffn primitive getppid +@deffn {Scheme Procedure} getppid +@deffnx {C Function} scm_getppid () Return an integer representing the process ID of the parent process. @end deffn getuid -@deffn primitive getuid +@deffn {Scheme Procedure} getuid +@deffnx {C Function} scm_getuid () Return an integer representing the current real user ID. @end deffn getgid -@deffn primitive getgid +@deffn {Scheme Procedure} getgid +@deffnx {C Function} scm_getgid () Return an integer representing the current real group ID. @end deffn geteuid -@deffn primitive geteuid +@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 @@ -5576,7 +6136,8 @@ system supports effective IDs. @end deffn getegid -@deffn primitive getegid +@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 @@ -5584,21 +6145,24 @@ system supports effective IDs. @end deffn setuid -@deffn primitive setuid id +@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 setgid -@deffn primitive setgid id +@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 seteuid -@deffn primitive seteuid id +@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 @@ -5607,7 +6171,8 @@ The return value is unspecified. @end deffn setegid -@deffn primitive setegid id +@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 @@ -5616,13 +6181,15 @@ The return value is unspecified. @end deffn getpgrp -@deffn primitive getpgrp +@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 setpgid -@deffn primitive setpgid pid pgid +@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. @@ -5631,7 +6198,8 @@ The return value is unspecified. @end deffn setsid -@deffn primitive setsid +@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. @@ -5639,19 +6207,22 @@ The return value is an integer representing the new process group ID. @end deffn ttyname -@deffn primitive ttyname port +@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 ctermid -@deffn primitive ctermid +@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 tcgetpgrp -@deffn primitive tcgetpgrp port +@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}. @@ -5665,7 +6236,8 @@ foreground. @end deffn tcsetpgrp -@deffn primitive tcsetpgrp port pgid +@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 @@ -5674,12 +6246,13 @@ controlling terminal. The return value is unspecified. @end deffn execl -@deffn primitive execl filename . args +@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}. 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. @@ -5689,7 +6262,8 @@ call, but we call it @code{execl} because of its Scheme calling interface. @end deffn execlp -@deffn primitive execlp filename . args +@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 @@ -5700,7 +6274,8 @@ call, but we call it @code{execlp} because of its Scheme calling interface. @end deffn execle -@deffn primitive execle filename env . args +@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. @@ -5710,7 +6285,8 @@ call, but we call it @code{execle} because of its Scheme calling interface. @end deffn primitive-fork -@deffn primitive primitive-fork +@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. @@ -5720,13 +6296,15 @@ with the scsh fork. @end deffn uname -@deffn primitive uname +@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 environ -@deffn primitive environ [env] +@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 @@ -5737,7 +6315,8 @@ then the return value is unspecified. @end deffn tmpnam -@deffn primitive tmpnam +@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. @@ -5746,7 +6325,8 @@ Care should be taken if opening the file, e.g., use the @end deffn mkstemp! -@deffn primitive mkstemp! tmpl +@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 @@ -5755,7 +6335,8 @@ place to return the name of the temporary file. @end deffn utime -@deffn primitive utime pathname [actime [modtime]] +@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 @@ -5769,7 +6350,8 @@ modification time to the current time. @end deffn access? -@deffn primitive access? path how +@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 @@ -5796,12 +6378,14 @@ test for existence of the file. @end deffn getpid -@deffn primitive getpid +@deffn {Scheme Procedure} getpid +@deffnx {C Function} scm_getpid () Return an integer representing the current process ID. @end deffn putenv -@deffn primitive putenv str +@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. @@ -5816,7 +6400,8 @@ The return value is unspecified. @end deffn setlocale -@deffn primitive setlocale category [locale] +@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 @@ -5829,7 +6414,8 @@ the locale will be set using envirionment variables. @end deffn mknod -@deffn primitive mknod path type perms dev +@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: @@ -5848,26 +6434,30 @@ The return value is unspecified. @end deffn nice -@deffn primitive nice incr +@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 sync -@deffn primitive sync +@deffn {Scheme Procedure} sync +@deffnx {C Function} scm_sync () Flush the operating system disk buffers. The return value is unspecified. @end deffn crypt -@deffn primitive crypt key salt +@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 chroot -@deffn primitive chroot path +@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 @@ -5876,21 +6466,24 @@ root directory. @end deffn getlogin -@deffn primitive getlogin +@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 cuserid -@deffn primitive cuserid +@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 getpriority -@deffn primitive getpriority which who +@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} @@ -5904,7 +6497,8 @@ specified processes. @end deffn setpriority -@deffn primitive setpriority which who prio +@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} @@ -5921,7 +6515,8 @@ The return value is not specified. @end deffn getpass -@deffn primitive getpass prompt +@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 @@ -5932,7 +6527,8 @@ characters is disabled. @end deffn flock -@deffn primitive flock file operation +@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 @@ -5953,21 +6549,24 @@ file descriptor or an open file descriptior port. @end deffn sethostname -@deffn primitive sethostname name +@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 gethostname -@deffn primitive gethostname +@deffn {Scheme Procedure} gethostname +@deffnx {C Function} scm_gethostname () Return the host name of the current processor. @end deffn gethost -@deffn primitive gethost [host] -@deffnx procedure gethostbyname hostname -@deffnx procedure gethostbyaddr address +@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 @@ -5980,9 +6579,10 @@ Unusual conditions may result in errors thrown to the @end deffn getnet -@deffn primitive getnet [net] -@deffnx procedure getnetbyname net-name -@deffnx procedure getnetbyaddr net-number +@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 @@ -5991,9 +6591,10 @@ given. @end deffn getproto -@deffn primitive getproto [protocol] -@deffnx procedure getprotobyname name -@deffnx procedure getprotobynumber number +@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 @@ -6001,9 +6602,10 @@ argument. @code{getproto} will accept either type, behaving like @end deffn getserv -@deffn primitive getserv [name [protocol]] -@deffnx procedure getservbyname name protocol -@deffnx procedure getservbyport port protocol +@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 @@ -6015,59 +6617,68 @@ as its first argument; if given no arguments, it behaves like @end deffn sethost -@deffn primitive sethost [stayopen] +@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 setnet -@deffn primitive setnet [stayopen] +@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 setproto -@deffn primitive setproto [stayopen] +@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 setserv -@deffn primitive setserv [stayopen] +@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 htons -@deffn primitive htons value +@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 ntohs -@deffn primitive ntohs value +@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 htonl -@deffn primitive htonl value +@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 ntohl -@deffn primitive ntohl value +@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 inet-aton -@deffn primitive inet-aton address +@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., @@ -6077,7 +6688,8 @@ Convert an IPv4 Internet address from printable string @end deffn inet-ntoa -@deffn primitive inet-ntoa inetid +@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., @@ -6087,7 +6699,8 @@ Convert an IPv4 Internet address to a printable @end deffn inet-netof -@deffn primitive inet-netof address +@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., @@ -6097,7 +6710,8 @@ Internet address. E.g., @end deffn inet-lnaof -@deffn primitive inet-lnaof address +@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., @@ -6108,7 +6722,8 @@ E.g., @end deffn inet-makeaddr -@deffn primitive inet-makeaddr net lna +@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., @@ -6119,7 +6734,8 @@ Make an IPv4 Internet address by combining the network number @end deffn inet-pton -@deffn primitive inet-pton family address +@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, @@ -6133,7 +6749,8 @@ the result is an integer with normal host byte ordering. @end deffn inet-ntop -@deffn primitive inet-ntop family address +@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. @@ -6147,7 +6764,8 @@ ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff @end deffn socket -@deffn primitive socket family style proto +@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 @@ -6164,7 +6782,8 @@ has been connected to another socket. @end deffn socketpair -@deffn primitive socketpair family style proto +@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} @@ -6173,7 +6792,8 @@ family. Zero is likely to be the only meaningful value for @end deffn getsockopt -@deffn primitive getsockopt sock level optname +@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 @@ -6186,7 +6806,8 @@ returns a pair of integers. @end deffn setsockopt -@deffn primitive setsockopt sock level optname value +@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. @@ -6201,7 +6822,8 @@ The return value is unspecified. @end deffn shutdown -@deffn primitive shutdown sock how +@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 connection to be shut down individually, according to the parameter @@ -6222,7 +6844,8 @@ The return value is unspecified. @end deffn connect -@deffn primitive connect sock fam address . args +@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}. @@ -6247,7 +6870,8 @@ The return value is unspecified. @end deffn bind -@deffn primitive bind sock fam address . args +@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 @@ -6294,7 +6918,8 @@ The return value is unspecified. @end deffn listen -@deffn primitive listen sock backlog +@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. @@ -6306,7 +6931,8 @@ The return value is unspecified. @end deffn accept -@deffn primitive accept sock +@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 @@ -6324,14 +6950,16 @@ connection and will continue to accept new requests. @end deffn getsockname -@deffn primitive getsockname sock +@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 getpeername -@deffn primitive getpeername sock +@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 @@ -6339,7 +6967,8 @@ is connected to, in the same form as the object returned by @end deffn recv! -@deffn primitive recv! sock buf [flags] +@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. @@ -6363,7 +6992,8 @@ any unread buffered port data is ignored. @end deffn send -@deffn primitive send sock message [flags] +@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 -- @@ -6380,7 +7010,8 @@ any unflushed buffered port data is ignored. @end deffn recvfrom! -@deffn primitive recvfrom! sock str [flags [start [end]]] +@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 @@ -6407,7 +7038,8 @@ descriptor: any unread buffered port data is ignored. @end deffn sendto -@deffn primitive sendto sock message fam address . args_and_flags +@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}, |