[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-27-gbc0202
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-27-gbc02028 |
|
Date: |
Fri, 03 Feb 2012 23:10:54 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".
http://git.savannah.gnu.org/cgit/guile.git/commit/?id=bc02028b52297bd33247435a573b76a873b2f4ba
The branch, stable-2.0 has been updated
via bc02028b52297bd33247435a573b76a873b2f4ba (commit)
via 5f6ffd66523e4777ed90348b86296ca6715013bf (commit)
via 5556c17511ce19f6dfa9fc6cef0e12cf90282e9b (commit)
via df0a100250a8eea3bfb6b8999cad54d01633567c (commit)
from e7f7691f5f5c2ecc2b6b828322e6bf3ccb130622 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit bc02028b52297bd33247435a573b76a873b2f4ba
Author: Andy Wingo <address@hidden>
Date: Fri Feb 3 16:22:50 2012 +0100
fix check for when libc already has clock_gettime / clock_getcpuclockid
* acinclude.m4 (gl_CLOCK_TIME): If both clock_gettime and
clock_getcpuclockid are present without -lrt and -lposix4, don't add
any libs to LIB_CLOCK_GETTIME. Thanks to address@hidden
commit 5f6ffd66523e4777ed90348b86296ca6715013bf
Author: Bake Timmons <address@hidden>
Date: Sun Jan 15 22:18:08 2012 -0500
Improve consistency of definitions of C functions in manual.
* doc/ref/api-compound.texi
* doc/ref/api-evaluation.texi
* doc/ref/api-foreign.texi
* doc/ref/api-io.texi
* doc/ref/posix.texi
* doc/ref/srfi-modules.texi: Add missing parentheses and commas to
definitions
of C functions.
* doc/ref/api-data.texi: Change from @deffn to @deftypefn for C function
with arguments not of SCM type.
commit 5556c17511ce19f6dfa9fc6cef0e12cf90282e9b
Author: Andy Wingo <address@hidden>
Date: Fri Feb 3 13:57:32 2012 +0100
fix compilation of control.c, continuations.c when SCM_ALIGNED is not
defined
* libguile/control.c:
* libguile/continuations.c: Fix for the case in which SCM_ALIGNED is not
defined. Though I wonder, perhaps we should just error out in those
cases.
commit df0a100250a8eea3bfb6b8999cad54d01633567c
Author: Bake Timmons <address@hidden>
Date: Sun Jan 15 10:56:53 2012 -0500
Make notation for Scheme repeated arguments more consistent in manual.
* doc/ref/api-compound.texi
* doc/ref/api-control.texi
* doc/ref/api-data.texi
* doc/ref/api-debug.texi
* doc/ref/api-evaluation.texi
* doc/ref/api-macros.texi
* doc/ref/api-memory.texi
* doc/ref/api-modules.texi
* doc/ref/api-procedures.texi
* doc/ref/api-regex.texi
* doc/ref/api-scheduling.texi
* doc/ref/api-utility.texi
* doc/ref/goops.texi
* doc/ref/match.texi
* doc/ref/misc-modules.texi
* doc/ref/posix.texi
* doc/ref/r6rs.texi
* doc/ref/scheme-using.texi
* doc/ref/srfi-modules.texi
* doc/ref/sxml-match.texi: Make notation for Scheme repeated arguments more
consistent in manual.
-----------------------------------------------------------------------
Summary of changes:
acinclude.m4 | 3 +-
doc/ref/api-compound.texi | 48 +++++----
doc/ref/api-control.texi | 42 ++++----
doc/ref/api-data.texi | 169 +++++++++++++++--------------
doc/ref/api-debug.texi | 6 +-
doc/ref/api-evaluation.texi | 17 ++--
doc/ref/api-foreign.texi | 12 +-
doc/ref/api-io.texi | 2 +-
doc/ref/api-macros.texi | 10 +-
doc/ref/api-memory.texi | 2 +-
doc/ref/api-modules.texi | 6 +-
doc/ref/api-procedures.texi | 39 ++++----
doc/ref/api-regex.texi | 4 +-
doc/ref/api-scheduling.texi | 48 ++++----
doc/ref/api-utility.texi | 8 +-
doc/ref/goops.texi | 71 +++++++------
doc/ref/match.texi | 20 ++--
doc/ref/misc-modules.texi | 20 ++--
doc/ref/posix.texi | 20 ++--
doc/ref/r6rs.texi | 35 ++++---
doc/ref/scheme-using.texi | 4 +-
doc/ref/srfi-modules.texi | 245 ++++++++++++++++++++++---------------------
doc/ref/sxml-match.texi | 2 +-
libguile/continuations.c | 35 +++---
libguile/control.c | 35 +++---
25 files changed, 462 insertions(+), 441 deletions(-)
diff --git a/acinclude.m4 b/acinclude.m4
index f9603d9..0edd4b8 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -614,7 +614,8 @@ AC_DEFUN([gl_CLOCK_TIME],
AC_SEARCH_LIBS([clock_getcpuclockid], [rt posix4],
[test "$ac_cv_search_clock_getcpuclockid"
= "none required" \
||
LIB_CLOCK_GETTIME=$ac_cv_search_clock_getcpuclockid],
-
[LIB_CLOCK_GETTIME=$ac_cv_search_clock_gettime])
+ [test "$ac_cv_search_clock_gettime" =
"none required" \
+ ||
LIB_CLOCK_GETTIME=$ac_cv_search_clock_gettime])
else
LIB_CLOCK_GETTIME=$ac_cv_search_clock_gettime
fi])
diff --git a/doc/ref/api-compound.texi b/doc/ref/api-compound.texi
index 765d5d4..6fc5b2e 100644
--- a/doc/ref/api-compound.texi
+++ b/doc/ref/api-compound.texi
@@ -326,7 +326,7 @@ the last pair of the list.
@c no-op since it does nothing but return the list the caller must
@c have already created.
@c
address@hidden {Scheme Procedure} list elem1 @dots{} elemN
address@hidden {Scheme Procedure} list elem @dots{}
@deffnx {C Function} scm_list_1 (elem1)
@deffnx {C Function} scm_list_2 (elem1, elem2)
@deffnx {C Function} scm_list_3 (elem1, elem2, elem3)
@@ -334,11 +334,11 @@ the last pair of the list.
@deffnx {C Function} scm_list_5 (elem1, elem2, elem3, elem4, elem5)
@deffnx {C Function} scm_list_n (elem1, @dots{}, elemN, @nicode{SCM_UNDEFINED})
@rnindex list
-Return a new list containing elements @var{elem1} to @var{elemN}.
+Return a new list containing elements @var{elem} @enddots{}.
@code{scm_list_n} takes a variable number of arguments, terminated by
the special @code{SCM_UNDEFINED}. That final @code{SCM_UNDEFINED} is
-not included in the list. None of @var{elem1} to @var{elemN} can
+not included in the list. None of @var{elem} @dots{} can
themselves be @code{SCM_UNDEFINED}, or @code{scm_list_n} will
terminate at that point.
@end deffn
@@ -430,12 +430,14 @@ pairs. This is why you should be careful when using the
side-effecting
variants.
@rnindex append
address@hidden {Scheme Procedure} append lst1 @dots{} lstN
address@hidden {Scheme Procedure} append! lst1 @dots{} lstN
address@hidden {Scheme Procedure} append lst @dots{} obj
address@hidden {Scheme Procedure} append
address@hidden {Scheme Procedure} append! lst @dots{} obj
address@hidden {Scheme Procedure} append!
@deffnx {C Function} scm_append (lstlst)
@deffnx {C Function} scm_append_x (lstlst)
-Return a list comprising all the elements of lists @var{lst1} to
address@hidden
+Return a list comprising all the elements of lists @var{lst} @dots{}
address@hidden If called with no arguments, return the empty list.
@lisp
(append '(x) '(y)) @result{} (x y)
@@ -443,7 +445,7 @@ Return a list comprising all the elements of lists
@var{lst1} to
(append '(a (b)) '((c))) @result{} (a (b) (c))
@end lisp
-The last argument @var{lstN} may actually be any object; an improper
+The last argument @var{obj} may actually be any object; an improper
list results if the last argument is not a proper list.
@lisp
@@ -452,11 +454,11 @@ list results if the last argument is not a proper list.
@end lisp
@code{append} doesn't modify the given lists, but the return may share
-structure with the final @var{lstN}. @code{append!} modifies the
+structure with the final @var{obj}. @code{append!} modifies the
given lists to form its return.
For @code{scm_append} and @code{scm_append_x}, @var{lstlst} is a list
-of the list operands @var{lst1} @dots{} @var{lstN}. That @var{lstlst}
+of the list operands @var{lst} @dots{} @var{obj}. That @var{lstlst}
itself is not modified or used in the return.
@end deffn
@@ -709,7 +711,7 @@ thus created is determined implicitly by the number of
arguments given.
@rnindex vector
@rnindex list->vector
address@hidden {Scheme Procedure} vector . l
address@hidden {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} list->vector l
@deffnx {C Function} scm_vector (l)
Return a newly allocated vector composed of the
@@ -775,7 +777,7 @@ in the vector.
@rnindex vector-length
@deffn {Scheme Procedure} vector-length vector
address@hidden {C Function} scm_vector_length vector
address@hidden {C Function} scm_vector_length (vector)
Return the number of elements in @var{vector} as an exact integer.
@end deffn
@@ -785,7 +787,7 @@ Return the number of elements in @var{vec} as a
@code{size_t}.
@rnindex vector-ref
@deffn {Scheme Procedure} vector-ref vec k
address@hidden {C Function} scm_vector_ref vec k
address@hidden {C Function} scm_vector_ref (vec, k)
Return the contents of position @var{k} of @var{vec}.
@var{k} must be a valid index of @var{vec}.
@lisp
@@ -814,7 +816,7 @@ error.
@rnindex vector-set!
@deffn {Scheme Procedure} vector-set! vec k obj
address@hidden {C Function} scm_vector_set_x vec k obj
address@hidden {C Function} scm_vector_set_x (vec, k, obj)
Store @var{obj} in position @var{k} of @var{vec}.
@var{k} must be a valid index of @var{vec}.
The value returned by @samp{vector-set!} is unspecified.
@@ -1010,7 +1012,7 @@ Like @code{scm_make_bitvector}, but the length is given
as a
@code{size_t}.
@end deftypefn
address@hidden {Scheme Procedure} bitvector . bits
address@hidden {Scheme Procedure} bitvector bit @dots{}
@deffnx {C Function} scm_bitvector (bits)
Create a new bitvector with the arguments as elements.
@end deffn
@@ -1546,7 +1548,7 @@ is unspecified.
@end deffn
@c begin (texi-doc-string "guile" "array-equal?")
address@hidden {Scheme Procedure} array-equal? array1 array2 @dots{}
address@hidden {Scheme Procedure} array-equal? array @dots{}
Return @code{#t} if all arguments are arrays with the same shape, the
same type, and have corresponding elements which are either
@code{equal?} or @code{array-equal?}. This function differs from
@@ -1563,7 +1565,7 @@ same type, and have corresponding elements which are
either
@c at least vaguely matches array-map!, but is it meant to be a
@c documented feature?
address@hidden {Scheme Procedure} array-map! dst proc src1 @dots{} srcN
address@hidden {Scheme Procedure} array-map! dst proc src @dots{}
@deffnx {Scheme Procedure} array-map-in-order! dst proc src1 @dots{} srcN
@deffnx {C Function} scm_array_map_x (dst, proc, srclist)
Set each element of the @var{dst} array to values obtained from calls
@@ -1580,10 +1582,10 @@ range in @var{dst}. This ensures all @var{dst} indices
are valid in
each @var{src}.
@end deffn
address@hidden {Scheme Procedure} array-for-each proc src1 @dots{} srcN
address@hidden {Scheme Procedure} array-for-each proc src1 src2 @dots{}
@deffnx {C Function} scm_array_for_each (proc, src1, srclist)
-Apply @var{proc} to each tuple of elements of @var{src1} @dots{}
address@hidden, in row-major order. The value returned is unspecified.
+Apply @var{proc} to each tuple of elements of @var{src1} @var{src2}
address@hidden, in row-major order. The value returned is unspecified.
@end deffn
@deffn {Scheme Procedure} array-index-map! dst proc
@@ -1793,7 +1795,7 @@ be returned only if its elements are stored internally
contiguous in
memory.
@end deffn
address@hidden {Scheme Procedure} transpose-array array dim1 @dots{}
address@hidden {Scheme Procedure} transpose-array array dim1 dim2 @dots{}
@deffnx {C Function} scm_transpose_array (array, dimlist)
Return an array sharing contents with @var{array}, but with
dimensions arranged in a different order. There must be one
@@ -2235,7 +2237,7 @@ Return a new vlist, as for SRFI-1 @code{unfold} and
@code{unfold-right}
(@pxref{SRFI-1, @code{unfold}}).
@end deffn
address@hidden {Scheme Procedure} vlist-append vlists ...
address@hidden {Scheme Procedure} vlist-append vlist @dots{}
Append the given vlists and return the resulting vlist.
@end deffn
@@ -2465,7 +2467,7 @@ This section describes the basic procedures for working
with
structures. @code{make-struct} creates a structure, and
@code{struct-ref} and @code{struct-set!} access write fields.
address@hidden {Scheme Procedure} make-struct vtable tail-size [init...]
address@hidden {Scheme Procedure} make-struct vtable tail-size init @dots{}
@deffnx {C Function} scm_make_struct (vtable, tail_size, init_list)
Create a new structure, with layout per the given @var{vtable}
(@pxref{Vtables}).
diff --git a/doc/ref/api-control.texi b/doc/ref/api-control.texi
index 7935d56..fc59350 100644
--- a/doc/ref/api-control.texi
+++ b/doc/ref/api-control.texi
@@ -44,7 +44,7 @@ If the test is true, we want to display ``greater'' to the
current
output port, then display a newline. We use @code{begin} to form a
compound expression out of this sequence of sub-expressions.
address@hidden syntax begin expr1 expr2 @dots{}
address@hidden syntax begin expr @dots{}
The expression(s) are evaluated in left-to-right order and the value of
the last expression is returned as the value of the
@code{begin}-expression. This expression type is used when the
@@ -277,7 +277,7 @@ Scheme programs is normally expressed using recursion.
Nevertheless,
R5RS defines a construct for programming loops, calling @code{do}. In
addition, Guile has an explicit looping syntax called @code{while}.
address@hidden syntax do ((variable init [step]) @dots{}) (test [expr @dots{}])
body @dots{}
address@hidden syntax do ((variable init [step]) @dots{}) (test expr @dots{})
body @dots{}
Bind @var{variable}s and evaluate @var{body} until @var{test} is true.
The return value is the last @var{expr} after @var{test}, if given. A
simple example will illustrate the basic form,
@@ -348,7 +348,7 @@ Run a loop executing the @var{body} forms while @var{cond}
is true.
Within @code{while}, two extra bindings are provided, they can be used
from both @var{cond} and @var{body}.
address@hidden {Scheme Procedure} break break-arg...
address@hidden {Scheme Procedure} break break-arg @dots{}
Break out of the @code{while} form.
@end deffn
@@ -487,7 +487,7 @@ tag allows some useful prompt and abort idioms, discussed
in the next
section.
@end deffn
address@hidden {Scheme Procedure} abort-to-prompt tag val ...
address@hidden {Scheme Procedure} abort-to-prompt tag val1 val2 @dots{}
Unwind the dynamic and control context to the nearest prompt named @var{tag},
also passing the given values.
@end deffn
@@ -599,8 +599,9 @@ The @code{%} symbol is chosen because it looks like a
prompt.
Likewise there is an abbreviation for @code{abort-to-prompt}, which
assumes the default prompt tag:
address@hidden {Scheme Procedure} abort val...
-Abort to the default prompt tag, passing @var{val...} to the handler.
address@hidden {Scheme Procedure} abort val1 val2 @dots{}
+Abort to the default prompt tag, passing @var{val1} @var{val2} @dots{}
+to the handler.
@end deffn
As mentioned before, @code{(ice-9 control)} also provides other
@@ -627,19 +628,22 @@ If both continuation and handler implicitly add prompts,
then the
operator is @dfn{+F+}. @code{shift} and @code{reset} are such
operators.
address@hidden {Scheme Syntax} reset body...
-Establish a prompt, and evaluate @var{body...} within that prompt.
address@hidden {Scheme Syntax} reset body1 body2 @dots{}
+Establish a prompt, and evaluate @var{body1} @var{body2} @dots{} within
+that prompt.
The prompt handler is designed to work with @code{shift}, described
below.
@end deffn
address@hidden {Scheme Syntax} shift cont body...
-Abort to the nearest @code{reset}, and evaluate @var{body...} in a
-context in which the captured continuation is bound to @var{cont}.
address@hidden {Scheme Syntax} shift cont body1 body2 @dots{}
+Abort to the nearest @code{reset}, and evaluate @var{body1} @var{body2}
address@hidden in a context in which the captured continuation is bound to
address@hidden
-As mentioned above, both the @var{body...} expression and invocations of
address@hidden implicitly establish a prompt.
+As mentioned above, taken together, the @var{body1} @var{body2} @dots{}
+expressions and the invocations of @var{cont} implicitly establish a
+prompt.
@end deffn
Interested readers are invited to explore Oleg Kiselyov's wonderful web
@@ -803,7 +807,7 @@ multiple values with a procedure which accepts these values
as
parameters.
@rnindex values
address@hidden {Scheme Procedure} values arg1 @dots{} argN
address@hidden {Scheme Procedure} values arg @dots{}
@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,
@@ -1220,10 +1224,10 @@ depends on the exception type. The documentation for
each possible type
of exception should specify the additional arguments that are expected
for that kind of exception.
address@hidden {Scheme Procedure} throw key . args
address@hidden {Scheme Procedure} throw key arg @dots{}
@deffnx {C Function} scm_throw (key, args)
-Invoke the catch form matching @var{key}, passing @var{args} to the
address@hidden
+Invoke the catch form matching @var{key}, passing @var{arg} @dots{} to
+the @var{handler}.
@var{key} is a symbol. It will match catches of the same symbol or of
@code{#t}.
@@ -1312,9 +1316,9 @@ Guile provides a set of convenience procedures for
signaling error
conditions that are implemented on top of the exception primitives just
described.
address@hidden {Scheme Procedure} error msg args @dots{}
address@hidden {Scheme Procedure} error msg arg @dots{}
Raise an error with key @code{misc-error} and a message constructed by
-displaying @var{msg} and writing @var{args}.
+displaying @var{msg} and writing @var{arg} @enddots{}.
@end deffn
@deffn {Scheme Procedure} scm-error key subr message args data
diff --git a/doc/ref/api-data.texi b/doc/ref/api-data.texi
index 2cbbdd2..4fc11c8 100644
--- a/doc/ref/api-data.texi
+++ b/doc/ref/api-data.texi
@@ -2324,12 +2324,12 @@ Return @code{#t} if @var{obj} is a character set,
@code{#f}
otherwise.
@end deffn
address@hidden {Scheme Procedure} char-set= . char_sets
address@hidden {Scheme Procedure} char-set= char_set @dots{}
@deffnx {C Function} scm_char_set_eq (char_sets)
Return @code{#t} if all given character sets are equal.
@end deffn
address@hidden {Scheme Procedure} char-set<= . char_sets
address@hidden {Scheme Procedure} char-set<= char_set @dots{}
@deffnx {C Function} scm_char_set_leq (char_sets)
Return @code{#t} if every character set @var{char_set}i is a subset
of character set @var{char_set}i+1.
@@ -2339,7 +2339,7 @@ of character set @var{char_set}i+1.
@deffnx {C Function} scm_char_set_hash (cs, bound)
Compute a hash value for the character set @var{cs}. If
@var{bound} is given and non-zero, it restricts the
-returned value to the range 0 @dots{} @var{bound - 1}.
+returned value to the range 0 @dots{} @var{bound} - 1.
@end deffn
@c ===================================================================
@@ -2443,8 +2443,8 @@ Return a newly allocated character set containing all
characters in @var{cs}.
@end deffn
address@hidden {Scheme Procedure} char-set . rest
address@hidden {C Function} scm_char_set (rest)
address@hidden {Scheme Procedure} char-set chr @dots{}
address@hidden {C Function} scm_char_set (chrs)
Return a character set containing all given characters.
@end deffn
@@ -2607,26 +2607,26 @@ such as union, complement, intersection etc. All of
these procedures
provide side-effecting variants, which modify their character set
argument(s).
address@hidden {Scheme Procedure} char-set-adjoin cs . rest
address@hidden {C Function} scm_char_set_adjoin (cs, rest)
address@hidden {Scheme Procedure} char-set-adjoin cs chr @dots{}
address@hidden {C Function} scm_char_set_adjoin (cs, chrs)
Add all character arguments to the first argument, which must
be a character set.
@end deffn
address@hidden {Scheme Procedure} char-set-delete cs . rest
address@hidden {C Function} scm_char_set_delete (cs, rest)
address@hidden {Scheme Procedure} char-set-delete cs chr @dots{}
address@hidden {C Function} scm_char_set_delete (cs, chrs)
Delete all character arguments from the first argument, which
must be a character set.
@end deffn
address@hidden {Scheme Procedure} char-set-adjoin! cs . rest
address@hidden {C Function} scm_char_set_adjoin_x (cs, rest)
address@hidden {Scheme Procedure} char-set-adjoin! cs chr @dots{}
address@hidden {C Function} scm_char_set_adjoin_x (cs, chrs)
Add all character arguments to the first argument, which must
be a character set.
@end deffn
address@hidden {Scheme Procedure} char-set-delete! cs . rest
address@hidden {C Function} scm_char_set_delete_x (cs, rest)
address@hidden {Scheme Procedure} char-set-delete! cs chr @dots{}
address@hidden {C Function} scm_char_set_delete_x (cs, chrs)
Delete all character arguments from the first argument, which
must be a character set.
@end deffn
@@ -2642,28 +2642,28 @@ characters). It may be helpful to modify the output of
@code{char-set-complement} by computing its intersection with the set
of designated code points, @code{char-set:designated}.
address@hidden {Scheme Procedure} char-set-union . rest
address@hidden {C Function} scm_char_set_union (rest)
address@hidden {Scheme Procedure} char-set-union cs @dots{}
address@hidden {C Function} scm_char_set_union (char_sets)
Return the union of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-intersection . rest
address@hidden {C Function} scm_char_set_intersection (rest)
address@hidden {Scheme Procedure} char-set-intersection cs @dots{}
address@hidden {C Function} scm_char_set_intersection (char_sets)
Return the intersection of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-difference cs1 . rest
address@hidden {C Function} scm_char_set_difference (cs1, rest)
address@hidden {Scheme Procedure} char-set-difference cs1 cs @dots{}
address@hidden {C Function} scm_char_set_difference (cs1, char_sets)
Return the difference of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-xor . rest
address@hidden {C Function} scm_char_set_xor (rest)
address@hidden {Scheme Procedure} char-set-xor cs @dots{}
address@hidden {C Function} scm_char_set_xor (char_sets)
Return the exclusive-or of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-diff+intersection cs1 . rest
address@hidden {C Function} scm_char_set_diff_plus_intersection (cs1, rest)
address@hidden {Scheme Procedure} char-set-diff+intersection cs1 cs @dots{}
address@hidden {C Function} scm_char_set_diff_plus_intersection (cs1, char_sets)
Return the difference and the intersection of all argument
character sets.
@end deffn
@@ -2673,28 +2673,28 @@ character sets.
Return the complement of the character set @var{cs}.
@end deffn
address@hidden {Scheme Procedure} char-set-union! cs1 . rest
address@hidden {C Function} scm_char_set_union_x (cs1, rest)
address@hidden {Scheme Procedure} char-set-union! cs1 cs @dots{}
address@hidden {C Function} scm_char_set_union_x (cs1, char_sets)
Return the union of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-intersection! cs1 . rest
address@hidden {C Function} scm_char_set_intersection_x (cs1, rest)
address@hidden {Scheme Procedure} char-set-intersection! cs1 cs @dots{}
address@hidden {C Function} scm_char_set_intersection_x (cs1, char_sets)
Return the intersection of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-difference! cs1 . rest
address@hidden {C Function} scm_char_set_difference_x (cs1, rest)
address@hidden {Scheme Procedure} char-set-difference! cs1 cs @dots{}
address@hidden {C Function} scm_char_set_difference_x (cs1, char_sets)
Return the difference of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-xor! cs1 . rest
address@hidden {C Function} scm_char_set_xor_x (cs1, rest)
address@hidden {Scheme Procedure} char-set-xor! cs1 cs @dots{}
address@hidden {C Function} scm_char_set_xor_x (cs1, char_sets)
Return the exclusive-or of all argument character sets.
@end deffn
address@hidden {Scheme Procedure} char-set-diff+intersection! cs1 cs2 . rest
address@hidden {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2,
rest)
address@hidden {Scheme Procedure} char-set-diff+intersection! cs1 cs2 cs @dots{}
address@hidden {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2,
char_sets)
Return the difference and the intersection of all argument
character sets.
@end deffn
@@ -3404,11 +3404,11 @@ comparison. See @xref{Text Collation, the @code{(ice-9
i18n)} module}, for locale-dependent string comparison.
@rnindex string=?
address@hidden {Scheme Procedure} string=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_equal_p (s1, s2, rest)
-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}.
+Lexicographic equality predicate; return @code{#t} if all strings are
+the same length and contain the same characters in the same positions,
+otherwise return @code{#f}.
The procedure @code{string-ci=?} treats upper and lower case
letters as though they were the same character, but
@@ -3417,72 +3417,80 @@ characters.
@end deffn
@rnindex string<?
address@hidden {Scheme Procedure} string<? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_less_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically less than @var{s2}.
+Lexicographic ordering predicate; return @code{#t} if, for every pair of
+consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
+lexicographically less than @var{str_i+1}.
@end deffn
@rnindex string<=?
address@hidden {Scheme Procedure} string<=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_leq_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically less than or equal to @var{s2}.
+Lexicographic ordering predicate; return @code{#t} if, for every pair of
+consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
+lexicographically less than or equal to @var{str_i+1}.
@end deffn
@rnindex string>?
address@hidden {Scheme Procedure} string>? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_gr_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically greater than @var{s2}.
+Lexicographic ordering predicate; return @code{#t} if, for every pair of
+consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
+lexicographically greater than @var{str_i+1}.
@end deffn
@rnindex string>=?
address@hidden {Scheme Procedure} string>=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_geq_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically greater than or equal to @var{s2}.
+Lexicographic ordering predicate; return @code{#t} if, for every pair of
+consecutive string arguments @var{str_i} and @var{str_i+1}, @var{str_i} is
+lexicographically greater than or equal to @var{str_i+1}.
@end deffn
@rnindex string-ci=?
address@hidden {Scheme Procedure} string-ci=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string-ci=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_equal_p (s1, s2, rest)
Case-insensitive string equality predicate; return @code{#t} if
-the two strings are the same length and their component
+all strings are the same length and their component
characters match (ignoring case) at each position; otherwise
return @code{#f}.
@end deffn
@rnindex string-ci<?
address@hidden {Scheme Procedure} string-ci<? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string-ci<? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_less_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically less than @var{s2}
+Case insensitive lexicographic ordering predicate; return @code{#t} if,
+for every pair of consecutive string arguments @var{str_i} and
address@hidden, @var{str_i} is lexicographically less than @var{str_i+1}
regardless of case.
@end deffn
@rnindex string<=?
address@hidden {Scheme Procedure} string-ci<=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string-ci<=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_leq_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically less than or equal
-to @var{s2} regardless of case.
+Case insensitive lexicographic ordering predicate; return @code{#t} if,
+for every pair of consecutive string arguments @var{str_i} and
address@hidden, @var{str_i} is lexicographically less than or equal to
address@hidden regardless of case.
@end deffn
@rnindex string-ci>?
address@hidden {Scheme Procedure} string-ci>? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string-ci>? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_gr_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically greater than
address@hidden regardless of case.
+Case insensitive lexicographic ordering predicate; return @code{#t} if,
+for every pair of consecutive string arguments @var{str_i} and
address@hidden, @var{str_i} is lexicographically greater than
address@hidden regardless of case.
@end deffn
@rnindex string-ci>=?
address@hidden {Scheme Procedure} string-ci>=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string-ci>=? s1 s2 s3 @dots{}
@deffnx {C Function} scm_i_string_ci_geq_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically greater than or
-equal to @var{s2} regardless of case.
+Case insensitive lexicographic ordering predicate; return @code{#t} if,
+for every pair of consecutive string arguments @var{str_i} and
address@hidden, @var{str_i} is lexicographically greater than or equal to
address@hidden regardless of case.
@end deffn
@deffn {Scheme Procedure} string-compare s1 s2 proc_lt proc_eq proc_gt [start1
[end1 [start2 [end2]]]]
@@ -3934,10 +3942,10 @@ operate on. The return value is unspecified.
@end deffn
@rnindex string-append
address@hidden {Scheme Procedure} string-append . args
address@hidden {Scheme Procedure} string-append arg @dots{}
@deffnx {C Function} scm_string_append (args)
Return a newly allocated string whose characters form the
-concatenation of the given strings, @var{args}.
+concatenation of the given strings, @var{arg} @enddots{}.
@example
(let ((h "hello "))
@@ -3946,17 +3954,16 @@ concatenation of the given strings, @var{args}.
@end example
@end deffn
address@hidden {Scheme Procedure} string-append/shared . rest
address@hidden {C Function} scm_string_append_shared (rest)
address@hidden {Scheme Procedure} string-append/shared arg @dots{}
address@hidden {C Function} scm_string_append_shared (args)
Like @code{string-append}, but the result may share memory
with the argument strings.
@end deffn
@deffn {Scheme Procedure} string-concatenate ls
@deffnx {C Function} scm_string_concatenate (ls)
-Append the elements of @var{ls} (which must be strings)
-together into a single string. Guaranteed to return a freshly
-allocated string.
+Append the elements (which must be strings) of @var{ls} together into a
+single string. Guaranteed to return a freshly allocated string.
@end deffn
@deffn {Scheme Procedure} string-concatenate-reverse ls [final_string [end]]
@@ -5181,9 +5188,9 @@ Return a newly allocated symbol made from a list of
characters.
@end deffn
@rnindex symbol-append
address@hidden {Scheme Procedure} symbol-append . args
address@hidden {Scheme Procedure} symbol-append arg @dots{}
Return a newly allocated symbol whose characters form the
-concatenation of the given symbols, @var{args}.
+concatenation of the given symbols, @var{arg} @enddots{}.
@example
(let ((h 'hello))
@@ -5253,15 +5260,15 @@ When you want to do more from C, you should convert
between symbols
and strings using @code{scm_symbol_to_string} and
@code{scm_string_to_symbol} and work with the strings.
address@hidden {C Function} scm_from_latin1_symbol (const char *name)
address@hidden {C Function} scm_from_utf8_symbol (const char *name)
address@hidden {C Function} scm_from_latin1_symbol (const char *name)
address@hidden {C Function} scm_from_utf8_symbol (const char *name)
Construct and return a Scheme symbol whose name is specified by the
null-terminated C string @var{name}. These are appropriate when
the C string is hard-coded in the source code.
address@hidden deffn
address@hidden deftypefn
address@hidden {C Function} scm_from_locale_symbol (const char *name)
address@hidden {C Function} scm_from_locale_symboln (const char *name, size_t
len)
address@hidden {C Function} scm_from_locale_symbol (const char *name)
address@hidden {C Function} scm_from_locale_symboln (const char *name, size_t
len)
Construct and return a Scheme symbol whose name is specified by
@var{name}. For @code{scm_from_locale_symbol}, @var{name} must be null
terminated; for @code{scm_from_locale_symboln} the length of @var{name} is
@@ -5271,7 +5278,7 @@ Note that these functions should @emph{not} be used when
@var{name} is a
C string constant, because there is no guarantee that the current locale
will match that of the source code. In such cases, use
@code{scm_from_latin1_symbol} or @code{scm_from_utf8_symbol}.
address@hidden deffn
address@hidden deftypefn
@deftypefn {C Function} SCM scm_take_locale_symbol (char *str)
@deftypefnx {C Function} SCM scm_take_locale_symboln (char *str, size_t len)
diff --git a/doc/ref/api-debug.texi b/doc/ref/api-debug.texi
index 57c7533..cf9ea5a 100644
--- a/doc/ref/api-debug.texi
+++ b/doc/ref/api-debug.texi
@@ -80,15 +80,15 @@ describes the Scheme stack at that point.
Use @code{start-stack} to limit the stack extent captured by future
@code{make-stack} calls.
address@hidden {Scheme Procedure} make-stack obj . args
address@hidden {Scheme Procedure} make-stack obj arg @dots{}
@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
a continuation or a frame object).
address@hidden should be a list containing any combination of
-integer, procedure, prompt tag and @code{#t} values.
address@hidden @dots{} can be any combination of integer, procedure, prompt
+tag and @code{#t} values.
These values specify various ways of cutting away uninteresting
stack frames from the top and bottom of the stack that
diff --git a/doc/ref/api-evaluation.texi b/doc/ref/api-evaluation.texi
index 8aa3888..6112832 100644
--- a/doc/ref/api-evaluation.texi
+++ b/doc/ref/api-evaluation.texi
@@ -504,23 +504,22 @@ eval-string)}, evaluating within @var{module} or the
current module.
of an @code{SCM}.
@end deftypefn
address@hidden {Scheme Procedure} apply proc arg1 @dots{} argN arglst
address@hidden {Scheme Procedure} apply proc arg @dots{} arglst
@deffnx {C Function} scm_apply_0 (proc, arglst)
@deffnx {C Function} scm_apply_1 (proc, arg1, arglst)
@deffnx {C Function} scm_apply_2 (proc, arg1, arg2, arglst)
@deffnx {C Function} scm_apply_3 (proc, arg1, arg2, arg3, arglst)
@deffnx {C Function} scm_apply (proc, arg, rest)
@rnindex apply
-Call @var{proc} with arguments @var{arg1} @dots{} @var{argN} plus the
+Call @var{proc} with arguments @var{arg} @dots{} and the
elements of the @var{arglst} list.
@code{scm_apply} takes parameters corresponding to a Scheme level
address@hidden(lambda (proc arg . rest) ...)}. So @var{arg} and all but the
-last element of the @var{rest} list make up
address@hidden@address@hidden and the last element of @var{rest} is the
address@hidden list. Or if @var{rest} is the empty list @code{SCM_EOL}
-then there's no @address@hidden@var{argN} and @var{arg} is the
address@hidden
address@hidden(lambda (proc arg1 . rest) ...)}. So @var{arg1} and all but the
+last element of the @var{rest} list make up @var{arg} @dots{}, and the
+last element of @var{rest} is the @var{arglst} list. Or if @var{rest}
+is the empty list @code{SCM_EOL} then there's no @var{arg} @dots{}, and
+(@var{arg1}) is the @var{arglst}.
@var{arglst} is not modified, but the @var{rest} list passed to
@code{scm_apply} is modified.
@@ -1013,7 +1012,7 @@ by @code{file-encoding}, if any, again by using
@code{set-port-encoding!}. Then the code can be read as normal.
@deffn {Scheme Procedure} file-encoding port
address@hidden {C Function} scm_file_encoding port
address@hidden {C Function} scm_file_encoding (port)
Scan the port for an Emacs-like character coding declaration near the
top of the contents of a port with random-accessible contents
(@pxref{Recognize Coding, how Emacs recognizes file encoding,, emacs,
diff --git a/doc/ref/api-foreign.texi b/doc/ref/api-foreign.texi
index 6ece7f8..2e60d8a 100644
--- a/doc/ref/api-foreign.texi
+++ b/doc/ref/api-foreign.texi
@@ -540,7 +540,7 @@ A value returned by @code{dynamic-pointer} is a Scheme
wrapper for a C
pointer.
@deffn {Scheme Procedure} pointer-address pointer
address@hidden {C Function} scm_pointer_address pointer
address@hidden {C Function} scm_pointer_address (pointer)
Return the numerical value of @var{pointer}.
@example
@@ -594,7 +594,7 @@ module contains procedures that can be used to convert byte
sequences to
Scheme objects such as strings, floating point numbers, or integers.
@deffn {Scheme Procedure} pointer->bytevector pointer len [offset [uvec_type]]
address@hidden {C Function} scm_foreign_to_bytevector pointer len offset
uvec_type
address@hidden {C Function} scm_foreign_to_bytevector (pointer, len, offset,
uvec_type)
Return a bytevector aliasing the @var{len} bytes pointed to by
@var{pointer}.
@@ -614,7 +614,7 @@ Mutating the returned bytevector mutates the memory pointed
to by
@end deffn
@deffn {Scheme Procedure} bytevector->pointer bv [offset]
address@hidden {C Function} scm_bytevector_to_pointer bv offset
address@hidden {C Function} scm_bytevector_to_pointer (bv, offset)
Return a pointer pointer aliasing the memory pointed to by @var{bv} or
@var{offset} bytes after @var{bv} when @var{offset} is passed.
@end deffn
@@ -740,7 +740,7 @@ its type, offset, and alignment. Guile has some primitives
to support
this.
@deffn {Scheme Procedure} sizeof type
address@hidden {C Function} scm_sizeof type
address@hidden {C Function} scm_sizeof (type)
Return the size of @var{type}, in bytes.
@var{type} should be a valid C type, like @code{int}.
@@ -751,7 +751,7 @@ also be a list of types, in which case the size of a
@end deffn
@deffn {Scheme Procedure} alignof type
address@hidden {C Function} scm_alignof type
address@hidden {C Function} scm_alignof (type)
Return the alignment of @var{type}, in bytes.
@var{type} should be a valid C type, like @code{int}.
@@ -801,7 +801,7 @@ Of course, the land of C is not all nouns and no verbs:
there are
functions too, and Guile allows you to call them.
@deffn {Scheme Procedure} pointer->procedure return_type func_ptr arg_types
address@hidden {C Procedure} scm_pointer_to_procedure return_type func_ptr
arg_types
address@hidden {C Procedure} scm_pointer_to_procedure (return_type, func_ptr,
arg_types)
Make a foreign function.
Given the foreign void pointer @var{func_ptr}, its argument and
diff --git a/doc/ref/api-io.texi b/doc/ref/api-io.texi
index 9b52766..24c2706 100644
--- a/doc/ref/api-io.texi
+++ b/doc/ref/api-io.texi
@@ -129,7 +129,7 @@ this fluid otherwise.
@end defvr
@deffn {Scheme Procedure} port-encoding port
address@hidden {C Function} scm_port_encoding
address@hidden {C Function} scm_port_encoding (port)
Returns, as a string, the character encoding that @var{port} uses to interpret
its input and output. The value @code{#f} is equivalent to
@code{"ISO-8859-1"}.
@end deffn
diff --git a/doc/ref/api-macros.texi b/doc/ref/api-macros.texi
index f6a03bc..347d025 100644
--- a/doc/ref/api-macros.texi
+++ b/doc/ref/api-macros.texi
@@ -81,8 +81,9 @@ source code will invoke the syntax transformer defined by
@var{transformer}.
One can also establish local syntactic bindings with @code{let-syntax}.
address@hidden {Syntax} let-syntax ((keyword transformer) ...) exp...
-Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}.
address@hidden {Syntax} let-syntax ((keyword transformer) @dots{}) exp1 exp2
@dots{}
+Bind each @var{keyword} to its corresponding @var{transformer} while
+expanding @var{exp1} @var{exp2} @enddots{}.
A @code{let-syntax} binding only exists at expansion-time.
@@ -104,8 +105,9 @@ top-level, or locally. Just as a local @code{define}
expands out to an instance
of @code{letrec}, a local @code{define-syntax} expands out to
@code{letrec-syntax}.
address@hidden {Syntax} letrec-syntax ((keyword transformer) ...) exp...
-Bind @var{keyword...} to @var{transformer...} while expanding @var{exp...}.
address@hidden {Syntax} letrec-syntax ((keyword transformer) @dots{}) exp1 exp2
@dots{}
+Bind each @var{keyword} to its corresponding @var{transformer} while
+expanding @var{exp1} @var{exp2} @enddots{}.
In the spirit of @code{letrec} versus @code{let}, an expansion produced by
@var{transformer} may reference a @var{keyword} bound by the
diff --git a/doc/ref/api-memory.texi b/doc/ref/api-memory.texi
index 6dca7a2..ff202e0 100644
--- a/doc/ref/api-memory.texi
+++ b/doc/ref/api-memory.texi
@@ -398,7 +398,7 @@ set to @var{fill}. The default value for @var{fill} is the
empty list.
@end deffn
address@hidden {Scheme Procedure} weak-vector . l
address@hidden {Scheme Procedure} weak-vector elem @dots{}
@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
diff --git a/doc/ref/api-modules.texi b/doc/ref/api-modules.texi
index 8afe728..c91c2d4 100644
--- a/doc/ref/api-modules.texi
+++ b/doc/ref/api-modules.texi
@@ -250,7 +250,7 @@ Export all bindings which should be in the public
interface, either
by using @code{define-public} or @code{export} (both documented below).
@end itemize
address@hidden syntax define-module module-name [options @dots{}]
address@hidden syntax define-module module-name option @dots{}
@var{module-name} is a list of one or more symbols.
@lisp
@@ -260,8 +260,8 @@ by using @code{define-public} or @code{export} (both
documented below).
@code{define-module} makes this module available to Guile programs under
the given @var{module-name}.
-The @var{options} are keyword/value pairs which specify more about the
-defined module. The recognized options and their meaning is shown in
address@hidden @dots{} are keyword/value pairs which specify more about the
+defined module. The recognized options and their meaning are shown in
the following table.
@table @code
diff --git a/doc/ref/api-procedures.texi b/doc/ref/api-procedures.texi
index aaad0cc..0e0ad15 100644
--- a/doc/ref/api-procedures.texi
+++ b/doc/ref/api-procedures.texi
@@ -418,8 +418,8 @@ elements. @code{let-optional} binds all variables
simultaneously, while
@code{let-optional*} binds them sequentially, consistent with @code{let}
and @code{let*} (@pxref{Local Bindings}).
address@hidden {library syntax} let-optional rest-arg (binding @dots{}) expr
@dots{}
address@hidden {library syntax} let-optional* rest-arg (binding @dots{}) expr
@dots{}
address@hidden {library syntax} let-optional rest-arg (binding @dots{}) body1
body2 @dots{}
address@hidden {library syntax} let-optional* rest-arg (binding @dots{}) body1
body2 @dots{}
These two macros give you an optional argument interface that is very
@dfn{Schemey} and introduces no fancy syntax. They are compatible with
the scsh macros of the same name, but are slightly extended. Each of
@@ -431,22 +431,22 @@ runs out, the remaining vars are bound either to the
default values or
@code{#f} if no default value was specified. @var{rest-arg} remains
bound to whatever may have been left of @var{rest-arg}.
-After binding the variables, the expressions @var{expr} @dots{} are
-evaluated in order.
+After binding the variables, the expressions @var{body1} @var{body2} @dots{}
+are evaluated in order.
@end deffn
Similarly, @code{let-keywords} and @code{let-keywords*} extract values
from keyword style argument lists, binding local variables to those
values or to defaults.
address@hidden {library syntax} let-keywords args allow-other-keys? (binding
@dots{}) body @dots{}
address@hidden {library syntax} let-keywords* args allow-other-keys? (binding
@dots{}) body @dots{}
address@hidden {library syntax} let-keywords args allow-other-keys? (binding
@dots{}) body1 body2 @dots{}
address@hidden {library syntax} let-keywords* args allow-other-keys? (binding
@dots{}) body1 body2 @dots{}
@var{args} is evaluated and should give a list of the form
@code{(#:keyword1 value1 #:keyword2 value2 @dots{})}. The
address@hidden are variables and default expressions, with the
-variables to be set (by name) from the keyword values. The @var{body}
-forms are then evaluated and the last is the result. An example will
-make the syntax clearest,
address@hidden are variables and default expressions, with the variables
+to be set (by name) from the keyword values. The @var{body1}
address@hidden @dots{} forms are then evaluated and the last is the
+result. An example will make the syntax clearest,
@example
(define args '(#:xyzzy "hello" #:foo "world"))
@@ -478,12 +478,12 @@ exist for defining macros with the improved argument list
handling
possibilities. The @code{-public} versions not only define the
procedures/macros, but also export them from the current module.
address@hidden {library syntax} define*-public formals body
address@hidden {library syntax} define*-public formals body1 body2 @dots{}
Like a mix of @code{define*} and @code{define-public}.
@end deffn
address@hidden {library syntax} defmacro* name formals body
address@hidden {library syntax} defmacro*-public name formals body
address@hidden {library syntax} defmacro* name formals body1 body2 @dots{}
address@hidden {library syntax} defmacro*-public name formals body1 body2
@dots{}
These are just like @code{defmacro} and @code{defmacro-public} except that they
take @code{lambda*}-style extended parameter lists, where @code{#:optional},
@code{#:key}, @code{#:allow-other-keys} and @code{#:rest} are allowed with the
usual
@@ -611,10 +611,11 @@ Return a procedure with the same arity as @var{proc} that
returns the
@end lisp
@end deffn
address@hidden {Scheme Procedure} compose proc rest ...
-Compose @var{proc} with the procedures in @var{rest}, such that the last
-one in @var{rest} is applied first and @var{proc} last, and return the
-resulting procedure. The given procedures must have compatible arity.
address@hidden {Scheme Procedure} compose proc1 proc2 @dots{}
+Compose @var{proc1} with the procedures @var{proc2} @dots{} such that
+the last @var{proc} argument is applied first and @var{proc1} last, and
+return the resulting procedure. The given procedures must have
+compatible arity.
@lisp
(procedure? (compose 1+ 1-)) @result{} #t
@@ -835,9 +836,9 @@ making large procedures inlinable will probably result in
an increase in
code size. Additionally, the elimination of the call overhead rarely
matters for large procedures.
address@hidden {Scheme Syntax} define-inlinable (name parameter ...) body ...
address@hidden {Scheme Syntax} define-inlinable (name parameter @dots{}) body1
body2 @dots{}
Define @var{name} as a procedure with parameters @var{parameter}s and
-body @var{body}.
+bodies @var{body1}, @var{body2}, @enddots{}.
@end deffn
@c Local Variables:
diff --git a/doc/ref/api-regex.texi b/doc/ref/api-regex.texi
index 1435aeb..11a31fc 100644
--- a/doc/ref/api-regex.texi
+++ b/doc/ref/api-regex.texi
@@ -228,7 +228,7 @@ and replace them with the contents of another string. The
following
functions are convenient ways to do this.
@c begin (scm-doc-string "regex.scm" "regexp-substitute")
address@hidden {Scheme Procedure} regexp-substitute port match address@hidden
address@hidden {Scheme Procedure} regexp-substitute port match item @dots{}
Write to @var{port} selected parts of the match structure @var{match}.
Or if @var{port} is @code{#f} then form a string from those parts and
return that.
@@ -276,7 +276,7 @@ re-ordering and hyphenating the fields.
@c begin (scm-doc-string "regex.scm" "regexp-substitute")
address@hidden {Scheme Procedure} regexp-substitute/global port regexp target
address@hidden
address@hidden {Scheme Procedure} regexp-substitute/global port regexp target
address@hidden
@cindex search and replace
Write to @var{port} selected parts of matches of @var{regexp} in
@var{target}. If @var{port} is @code{#f} then form a string from
diff --git a/doc/ref/api-scheduling.texi b/doc/ref/api-scheduling.texi
index 9320cb5..a301663 100644
--- a/doc/ref/api-scheduling.texi
+++ b/doc/ref/api-scheduling.texi
@@ -323,8 +323,8 @@ the error to the current error port. The @var{arg} @dots{}
expressions are evaluated in the new thread.
@end deffn
address@hidden macro begin-thread first address@hidden
-Evaluate forms @var{first} and @var{rest} in a new thread formed by
address@hidden macro begin-thread expr1 expr2 @dots{}
+Evaluate forms @var{expr1} @var{expr2} @dots{} in a new thread formed by
@code{call-with-new-thread} using a default error handler that display
the error to the current error port.
@end deffn
@@ -353,10 +353,10 @@ Acquiring requisite mutexes in a fixed order (like always
A before B)
in all threads is one way to avoid such problems.
@sp 1
address@hidden {Scheme Procedure} make-mutex . flags
address@hidden {Scheme Procedure} make-mutex flag @dots{}
@deffnx {C Function} scm_make_mutex ()
@deffnx {C Function} scm_make_mutex_with_flags (SCM flags)
-Return a new mutex. It is initially unlocked. If @var{flags} is
+Return a new mutex. It is initially unlocked. If @var{flag} @dots{} is
specified, it must be a list of symbols specifying configuration flags
for the newly-created mutex. The supported flags are:
@table @code
@@ -523,25 +523,25 @@ available from
(use-modules (ice-9 threads))
@end example
address@hidden macro with-mutex mutex address@hidden
-Lock @var{mutex}, evaluate the @var{body} forms, then unlock
address@hidden The return value is the return from the last @var{body}
-form.
address@hidden macro with-mutex mutex body1 body2 @dots{}
+Lock @var{mutex}, evaluate the body @var{body1} @var{body2} @dots{},
+then unlock @var{mutex}. The return value is that returned by the last
+body form.
The lock, body and unlock form the branches of a @code{dynamic-wind}
(@pxref{Dynamic Wind}), so @var{mutex} is automatically unlocked if an
-error or new continuation exits @var{body}, and is re-locked if
address@hidden is re-entered by a captured continuation.
+error or new continuation exits the body, and is re-locked if
+the body is re-entered by a captured continuation.
@end deffn
address@hidden macro monitor address@hidden
-Evaluate the @var{body} forms, with a mutex locked so only one thread
-can execute that code at any one time. The return value is the return
-from the last @var{body} form.
address@hidden macro monitor body1 body2 @dots{}
+Evaluate the body form @var{body1} @var{body2} @dots{} with a mutex
+locked so only one thread can execute that code at any one time. The
+return value is the return from the last body form.
Each @code{monitor} form has its own private mutex and the locking and
evaluation is as per @code{with-mutex} above. A standard mutex
-(@code{make-mutex}) is used, which means @var{body} must not
+(@code{make-mutex}) is used, which means the body must not
recursively re-enter the @code{monitor} form.
The term ``monitor'' comes from operating system theory, where it
@@ -890,11 +890,11 @@ canonical form. For example,
@end example
@end defun
address@hidden {Scheme Syntax} parameterize ((param value) @dots{}) body @dots{}
address@hidden {library syntax} parameterize ((param value) @dots{}) body1
body2 @dots{}
Establish a new dynamic scope with the given @var{param}s bound to new
-locations and set to the given @var{value}s. @var{body} is evaluated
-in that environment, the result is the return from the last form in
address@hidden
+locations and set to the given @var{value}s. @var{body1} @var{body2}
address@hidden is evaluated in that environment. The value returned is that of
+last body form.
Each @var{param} is an expression which is evaluated to get the
parameter object. Often this will just be the name of a variable
@@ -1058,8 +1058,8 @@ the results to the corresponding @var{var} variables, and
then evaluate
expressions for the bindings are evaluated in parallel.
@end deffn
address@hidden {Scheme Procedure} par-map proc lst1 @dots{} lstN
address@hidden {Scheme Procedure} par-for-each proc lst1 @dots{} lstN
address@hidden {Scheme Procedure} par-map proc lst1 lst2 @dots{}
address@hidden {Scheme Procedure} par-for-each proc lst1 lst2 @dots{}
Call @var{proc} on the elements of the given lists. @code{par-map}
returns a list comprising the return values from @var{proc}.
@code{par-for-each} returns an unspecified value, but waits for all
@@ -1084,8 +1084,8 @@ completion, which makes them quite expensive.
Therefore, they should be avoided.
address@hidden {Scheme Procedure} n-par-map n proc lst1 @dots{} lstN
address@hidden {Scheme Procedure} n-par-for-each n proc lst1 @dots{} lstN
address@hidden {Scheme Procedure} n-par-map n proc lst1 lst2 @dots{}
address@hidden {Scheme Procedure} n-par-for-each n proc lst1 lst2 @dots{}
Call @var{proc} on the elements of the given lists, in the same way as
@code{par-map} and @code{par-for-each} above, but use no more than
@var{n} threads at any one time. The order in which calls are
@@ -1097,7 +1097,7 @@ a dual-CPU system for instance @address@hidden might be
enough to
keep the CPUs utilized, and not consume too much memory.
@end deffn
address@hidden {Scheme Procedure} n-for-each-par-map n sproc pproc lst1 @dots{}
lstN
address@hidden {Scheme Procedure} n-for-each-par-map n sproc pproc lst1 lst2
@dots{}
Apply @var{pproc} to the elements of the given lists, and apply
@var{sproc} to each result returned by @var{pproc}. The final return
value is unspecified, but all calls will have been completed before
diff --git a/doc/ref/api-utility.texi b/doc/ref/api-utility.texi
index ba6139f..9ab1eee 100644
--- a/doc/ref/api-utility.texi
+++ b/doc/ref/api-utility.texi
@@ -583,11 +583,11 @@ value of this procedure is not specified.
Convert the procedure list of @var{hook} to a list.
@end deffn
address@hidden {Scheme Procedure} run-hook hook . args
address@hidden {Scheme Procedure} run-hook hook arg @dots{}
@deffnx {C Function} scm_run_hook (hook, args)
-Apply all procedures from the hook @var{hook} to the arguments
address@hidden The order of the procedure application is first to
-last. The return value of this procedure is not specified.
+Apply all procedures from the hook @var{hook} to the arguments @var{arg}
address@hidden The order of the procedure application is first to last.
+The return value of this procedure is not specified.
@end deffn
If, in C code, you are certain that you have a hook object and well
diff --git a/doc/ref/goops.texi b/doc/ref/goops.texi
index 10192eb..bc04985 100644
--- a/doc/ref/goops.texi
+++ b/doc/ref/goops.texi
@@ -97,11 +97,12 @@ Class options, slot descriptions and inheritance are
discussed more
below.
@cindex slot
address@hidden syntax define-class name (super @dots{}) slot-definition @dots{}
. options
address@hidden syntax define-class name (super @dots{}) @
+ slot-definition @dots{} class-option @dots{}
Define a class called @var{name} that inherits from @var{super}s, with
-direct slots defined by @var{slot-definition}s and class options
address@hidden The newly created class is bound to the variable name
address@hidden in the current environment.
+direct slots defined by @var{slot-definition}s and @var{class-option}s.
+The newly created class is bound to the variable name @var{name} in the
+current environment.
Each @var{slot-definition} is either a symbol that names the slot or a
list,
@@ -115,8 +116,7 @@ list with an even number of elements. The even-numbered
elements of
@var{slot-options} (counting from zero) are slot option keywords; the
odd-numbered elements are the corresponding values for those keywords.
address@hidden is a similarly structured list containing class option
-keywords and corresponding values.
+Each @var{class-option} is an option keyword and corresponding value.
@end deffn
As an example, let us define a type for representing a complex number
@@ -183,13 +183,13 @@ creates a new @code{<my-complex>} object and binds it to
the Scheme
variable @code{c}.
@deffn generic make
address@hidden method make (class <class>) . initargs
address@hidden method make (class <class>) initarg @dots{}
Create and return a new instance of class @var{class}, initialized using
address@hidden
address@hidden @enddots{}.
-In theory, @var{initargs} can have any structure that is understood by
-whatever methods get applied when the @code{initialize} generic function
-is applied to the newly allocated instance.
+In theory, @var{initarg} @dots{} can have any structure that is
+understood by whatever methods get applied when the @code{initialize}
+generic function is applied to the newly allocated instance.
In practice, specialized @code{initialize} methods would normally call
@code{(next-method)}, and so eventually the standard GOOPS
@@ -206,7 +206,7 @@ instance's class. Any unprocessed keyword value pairs are
ignored.
@end deffn
@deffn generic make-instance
address@hidden method make-instance (class <class>) . initargs
address@hidden method make-instance (class <class>) initarg @dots{}
@code{make-instance} is an alias for @code{make}.
@end deffn
@@ -674,9 +674,9 @@ setter). Any other previous value, including an existing
generic
function, is discarded and replaced by a new, empty generic function.
@end deffn
address@hidden syntax define-method (generic parameter @dots{}) . body
address@hidden syntax define-method (generic parameter @dots{}) body @dots{}
Define a method for the generic function or accessor @var{generic} with
-parameters @var{parameter}s and body @var{body}.
+parameters @var{parameter}s and body @var{body} @enddots{}.
@var{generic} is a generic function. If @var{generic} is a variable
which is not yet bound to a generic function object, the expansion of
@@ -688,12 +688,12 @@ generic-with-setter object, the expansion will include a
call to
Each @var{parameter} must be either a symbol or a two-element list
@code{(@var{symbol} @var{class})}. The symbols refer to variables in
-the @var{body} that will be bound to the parameters supplied by the
+the body forms that will be bound to the parameters supplied by the
caller when calling this method. The @var{class}es, if present,
specify the possible combinations of parameters to which this method
can be applied.
address@hidden is the body of the method definition.
address@hidden @dots{} are the bodies of the method definition.
@end deffn
@code{define-method} expressions look a little like Scheme procedure
@@ -1698,10 +1698,10 @@ If you customize these functions for particular classes
or metaclasses,
you may still want to use @code{goops-error} to signal any error
conditions that you detect.
address@hidden procedure goops-error format-string . args
address@hidden procedure goops-error format-string arg @dots{}
Raise an error with key @code{goops-error} and error message constructed
-from @var{format-string} and @var{args}. Error message formatting is
-as done by @code{scm-error}.
+from @var{format-string} and @var{arg} @enddots{}. Error message
+formatting is as done by @code{scm-error}.
@end deffn
@@ -2228,11 +2228,12 @@ handles the redefinition by invoking
@code{class-redefinition}
(@pxref{Redefining a Class}).
@end itemize
address@hidden syntax class name (super @dots{}) slot-definition @dots{} .
options
address@hidden syntax class name (super @dots{}) @
+ slot-definition @dots{} class-option @dots{}
Return a newly created class that inherits from @var{super}s, with
-direct slots defined by @var{slot-definition}s and class options
address@hidden For the format of @var{slot-definition}s and
address@hidden, see @ref{Class Definition,, define-class}.
+direct slots defined by @var{slot-definition}s and @var{class-option}s.
+For the format of @var{slot-definition}s and @var{class-option}s, see
address@hidden Definition,, define-class}.
@end deffn
@noindent @code{class} expands to an expression which
@@ -2250,13 +2251,12 @@ calls @code{make-class} to create the class with the
processed and
evaluated parameters.
@end itemize
address@hidden procedure make-class supers slots . options
address@hidden procedure make-class supers slots class-option @dots{}
Return a newly created class that inherits from @var{supers}, with
-direct slots defined by @var{slots} and class options @var{options}.
-For the format of @var{slots} and @var{options}, see @ref{Class
+direct slots defined by @var{slots} and @var{class-option}s. For the
+format of @var{slots} and @var{class-option}s, see @ref{Class
Definition,, define-class}, except note that for @code{make-class},
address@hidden and @var{options} are separate list parameters: @var{slots}
-here is a list of slot definitions.
address@hidden is a separate list of slot definitions.
@end deffn
@noindent @code{make-class}
@@ -2307,18 +2307,19 @@ has to be created once.
The @code{env} parameter is ignored.
@end deffn
address@hidden generic make metaclass @dots{}
address@hidden generic make metaclass initarg @dots{}
@var{metaclass} is the metaclass of the class being defined, either
taken from the @code{#:metaclass} class option or computed by
@code{ensure-metaclass}. The applied method must create and return the
fully initialized class metaobject for the new class definition.
@end deffn
-The @code{(make @var{metaclass} @dots{})} invocation is a particular
-case of the instance creation protocol covered in the previous section.
-It will create an class metaobject with metaclass @var{metaclass}. By
-default, this metaobject will be initialized by the @code{initialize}
-method that is specialized for instances of type @code{<class>}.
+The @code{(make @var{metaclass} @var{initarg} @dots{})} invocation is a
+particular case of the instance creation protocol covered in the
+previous section. It will create an class metaobject with metaclass
address@hidden By default, this metaobject will be initialized by the
address@hidden method that is specialized for instances of type
address@hidden<class>}.
The @code{initialize} method for classes (signature @code{(initialize
<class> initargs)}) calls the following generic functions.
@@ -2565,7 +2566,7 @@ calls @code{add-method!} to add this method to the
relevant generic
function.
@end itemize
address@hidden syntax method (parameter @dots{}) . body
address@hidden syntax method (parameter @dots{}) body @dots{}
Make a method whose specializers are defined by the classes in
@var{parameter}s and whose procedure definition is constructed from the
@var{parameter} symbols and @var{body} forms.
diff --git a/doc/ref/match.texi b/doc/ref/match.texi
index d1618ce..40b5be8 100644
--- a/doc/ref/match.texi
+++ b/doc/ref/match.texi
@@ -64,16 +64,16 @@ bound to, respectively, the first and second element of
@var{l}.
The pattern matcher is defined as follows:
address@hidden {Scheme Syntax} match exp clause ...
-Match object @var{exp} against the patterns in the given @var{clause}s,
-in the order in which they appear. Return the value produced by the
-first matching clause. If no @var{clause} matches, throw an exception
-with key @code{match-error}.
-
-Each @var{clause} has the form @code{(pattern body)}. Each
address@hidden must follow the syntax described below. Each @var{body}
-is an arbitrary Scheme expression, possibly referring to pattern
-variables of @var{pattern}.
address@hidden {Scheme Syntax} match exp clause1 clause2 @dots{}
+Match object @var{exp} against the patterns in @var{clause1}
address@hidden @dots{} in the order in which they appear. Return the
+value produced by the first matching clause. If no clause matches,
+throw an exception with key @code{match-error}.
+
+Each clause has the form @code{(pattern body1 body2 @dots{})}. Each
address@hidden must follow the syntax described below. Each body is an
+arbitrary Scheme expression, possibly referring to pattern variables of
address@hidden
@end deffn
@c FIXME: Document other forms:
diff --git a/doc/ref/misc-modules.texi b/doc/ref/misc-modules.texi
index 022b7cb..cf1e0e4 100644
--- a/doc/ref/misc-modules.texi
+++ b/doc/ref/misc-modules.texi
@@ -156,7 +156,7 @@ C programmers will note the similarity between
@code{format} and
instead of @nicode{%}, and are more powerful.
@sp 1
address@hidden {Scheme Procedure} format dest fmt address@hidden
address@hidden {Scheme Procedure} format dest fmt arg @dots{}
Write output specified by the @var{fmt} string to @var{dest}.
@var{dest} can be an output port, @code{#t} for
@code{current-output-port} (@pxref{Default Ports}), or @code{#f} to
@@ -1695,35 +1695,35 @@ secondly the number of elements in that list.
Return a vector which is the entire contents of @var{stream}.
@end deffn
address@hidden {Scheme Procedure} stream-fold proc init stream0 @dots{} streamN
address@hidden stream-fold proc init stream1 stream2 @dots{}
Apply @var{proc} successively over the elements of the given streams,
from first to last until the end of the shortest stream is reached.
Return the result from the last @var{proc} call.
-Each call is @code{(@var{proc} elem0 @dots{} elemN prev)}, where each
+Each call is @code{(@var{proc} elem1 elem2 @dots{} prev)}, where each
@var{elem} is from the corresponding @var{stream}. @var{prev} is the
return from the previous @var{proc} call, or the given @var{init} for
the first call.
address@hidden deffn
address@hidden defun
address@hidden {Scheme Procedure} stream-for-each proc stream0 @dots{} streamN
address@hidden stream-for-each proc stream1 stream2 @dots{}
Call @var{proc} on the elements from the given @var{stream}s. The
return value is unspecified.
-Each call is @code{(@var{proc} elem0 @dots{} elemN)}, where each
+Each call is @code{(@var{proc} elem1 elem2 @dots{})}, where each
@var{elem} is from the corresponding @var{stream}.
@code{stream-for-each} stops when it reaches the end of the shortest
@var{stream}.
address@hidden deffn
address@hidden defun
address@hidden {Scheme Procedure} stream-map proc stream0 @dots{} streamN
address@hidden stream-map proc stream1 stream2 @dots{}
Return a new stream which is the results of applying @var{proc} to the
elements of the given @var{stream}s.
-Each call is @code{(@var{proc} elem0 @dots{} elemN)}, where each
+Each call is @code{(@var{proc} elem1 elem2 @dots{})}, where each
@var{elem} is from the corresponding @var{stream}. The new stream
ends when the end of the shortest given @var{stream} is reached.
address@hidden deffn
address@hidden defun
@node Buffered Input
diff --git a/doc/ref/posix.texi b/doc/ref/posix.texi
index 9933495..0a688e9 100644
--- a/doc/ref/posix.texi
+++ b/doc/ref/posix.texi
@@ -953,7 +953,7 @@ which is usual for ordinary file creation,
@end deffn
@deffn {Scheme Procedure} tmpfile
address@hidden {C Function} scm_tmpfile
address@hidden {C Function} scm_tmpfile ()
Return an input/output port to a unique temporary file
named using the path prefix @code{P_tmpdir} defined in
@file{stdio.h}.
@@ -1698,12 +1698,12 @@ If @code{system} is called without arguments, return a
boolean
indicating whether the command processor is available.
@end deffn
address@hidden {Scheme Procedure} system* . args
address@hidden {Scheme Procedure} system* arg1 arg2 @dots{}
@deffnx {C Function} scm_system_star (args)
-Execute the command indicated by @var{args}. The first element must
-be a string indicating the command to be executed, and the remaining
-items must be strings representing each of the arguments to that
-command.
+Execute the command indicated by @var{arg1} @var{arg2} @enddots{}. The
+first element must be a string indicating the command to be executed,
+and the remaining items must be strings representing each of the
+arguments to that command.
This function returns the exit status of the command as provided by
@code{waitpid}. This value can be handled with @code{status:exit-val}
@@ -1743,7 +1743,7 @@ in the child would upset the protocol in the parent, so
@code{primitive-_exit} should be used to exit without that.
@end deffn
address@hidden {Scheme Procedure} execl filename . args
address@hidden {Scheme Procedure} execl filename arg @dots{}
@deffnx {C Function} scm_execl (filename, args)
Executes the file named by @var{filename} as a new process image.
The remaining arguments are supplied to the process; from a C program
@@ -1758,7 +1758,7 @@ This procedure is currently implemented using the
@code{execv} system
call, but we call it @code{execl} because of its Scheme calling interface.
@end deffn
address@hidden {Scheme Procedure} execlp filename . args
address@hidden {Scheme Procedure} execlp filename arg @dots{}
@deffnx {C Function} scm_execlp (filename, args)
Similar to @code{execl}, however if
@var{filename} does not contain a slash
@@ -1769,7 +1769,7 @@ This procedure is currently implemented using the
@code{execvp} system
call, but we call it @code{execlp} because of its Scheme calling interface.
@end deffn
address@hidden {Scheme Procedure} execle filename env . args
address@hidden {Scheme Procedure} execle filename env arg @dots{}
@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
@@ -2841,7 +2841,7 @@ created with,
@deffn {Scheme Procedure} make-socket-address AF_INET ipv4addr port
@deffnx {Scheme Procedure} make-socket-address AF_INET6 ipv6addr port
[flowinfo [scopeid]]
@deffnx {Scheme Procedure} make-socket-address AF_UNIX path
address@hidden {C Function} scm_make_socket_address family address arglist
address@hidden {C Function} scm_make_socket_address (family, address, arglist)
Return a new socket address object. The first argument is the address
family, one of the @code{AF} constants, then the arguments vary
according to the family.
diff --git a/doc/ref/r6rs.texi b/doc/ref/r6rs.texi
index df14cc0..f9bc9e9 100644
--- a/doc/ref/r6rs.texi
+++ b/doc/ref/r6rs.texi
@@ -273,8 +273,10 @@ grouped below by the existing manual sections to which
they correspond.
@end deffn
@deffn {Scheme Syntax} define-syntax keyword expression
address@hidden {Scheme Syntax} let-syntax ((keyword transformer) ...) exp ...
address@hidden {Scheme Syntax} letrec-syntax ((keyword transformer) ...) exp ...
address@hidden {Scheme Syntax} let-syntax ((keyword transformer) @dots{})
+ exp1 exp2 @dots{}
address@hidden {Scheme Syntax} letrec-syntax ((keyword transformer) @dots{})
+ exp1 exp2 @dots{}
@xref{Defining Macros}, for documentation.
@end deffn
@@ -403,7 +405,7 @@ grouped below by the existing manual sections to which they
correspond.
@xref{SRFI-1 Fold and Map}, for documentation.
@end deffn
address@hidden {Scheme Procedure} list elem1 ... elemN
address@hidden {Scheme Procedure} list elem @dots{}
@xref{List Constructors}, for documentation.
@end deffn
@@ -413,7 +415,8 @@ grouped below by the existing manual sections to which they
correspond.
@xref{List Selection}, for documentation.
@end deffn
address@hidden {Scheme Procedure} append lst1 ... lstN
address@hidden {Scheme Procedure} append lst @dots{} obj
address@hidden {Scheme Procedure} append
@deffnx {Scheme Procedure} reverse lst
@xref{Append/Reverse}, for documentation.
@end deffn
@@ -440,15 +443,15 @@ grouped below by the existing manual sections to which
they correspond.
@xref{String Selection}, for documentation.
@end deffn
address@hidden {Scheme Procedure} string=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string<=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string>=? [s1 [s2 . rest]]
address@hidden {Scheme Procedure} string=? s1 s2 s3 @dots{}
address@hidden {Scheme Procedure} string<? s1 s2 s3 @dots{}
address@hidden {Scheme Procedure} string>? s1 s2 s3 @dots{}
address@hidden {Scheme Procedure} string<=? s1 s2 s3 @dots{}
address@hidden {Scheme Procedure} string>=? s1 s2 s3 @dots{}
@xref{String Comparison}, for documentation.
@end deffn
address@hidden {Scheme Procedure} string-append . args
address@hidden {Scheme Procedure} string-append arg @dots{}
@xref{Reversing and Appending Strings}, for documentation.
@end deffn
@@ -579,7 +582,7 @@ These procedures implement the @code{map} and
@code{for-each} contracts
over vectors.
@end deffn
address@hidden {Scheme Procedure} vector . l
address@hidden {Scheme Procedure} vector arg @dots{}
@deffnx {Scheme Procedure} vector? obj
@deffnx {Scheme Procedure} make-vector len
@deffnx {Scheme Procedure} make-vector len fill
@@ -600,7 +603,7 @@ over vectors.
@xref{Continuations}, for documentation.
@end deffn
address@hidden {Scheme Procedure} values arg1 ... argN
address@hidden {Scheme Procedure} values arg @dots{}
@deffnx {Scheme Procedure} call-with-values producer consumer
@xref{Multiple Values}, for documentation.
@end deffn
@@ -609,7 +612,7 @@ over vectors.
@xref{Dynamic Wind}, for documentation.
@end deffn
address@hidden {Scheme Procedure} apply proc arg1 ... argN arglst
address@hidden {Scheme Procedure} apply proc arg @dots{} arglst
@xref{Fly Evaluation}, for documentation.
@end deffn
@@ -717,8 +720,8 @@ These procedures are identical to the ones provided by
SRFI-1.
@xref{SRFI-1 Filtering and Partitioning}, for @code{partition}.
@end deffn
address@hidden {Scheme Procedure} fold-left combine nil list1 list2 ... listn
address@hidden {Scheme Procedure} fold-right combine nil list1 list2 ... listn
address@hidden {Scheme Procedure} fold-left combine nil list1 list2 @dots{}
address@hidden {Scheme Procedure} fold-right combine nil list1 list2 @dots{}
These procedures are identical to the @code{fold} and @code{fold-right}
procedures provided by SRFI-1. @xref{SRFI-1 Fold and Map}, for
documentation.
@@ -903,7 +906,7 @@ compatible with either.
The @code{(rnrs records syntactic (6))} library exports the syntactic
API for working with R6RS records.
address@hidden {Scheme Syntax} define-record-type name-spec record-clause*
address@hidden {Scheme Syntax} define-record-type name-spec record-clause
@dots{}
Defines a new record type, introducing bindings for a record-type
descriptor, a record constructor descriptor, a constructor procedure,
a record predicate, and accessor and mutator procedures for the new
diff --git a/doc/ref/scheme-using.texi b/doc/ref/scheme-using.texi
index 64510ca..3d43913 100644
--- a/doc/ref/scheme-using.texi
+++ b/doc/ref/scheme-using.texi
@@ -230,7 +230,7 @@ Show description/documentation.
Change modules / Show current module.
@end deffn
address@hidden {REPL Command} import [module ...]
address@hidden {REPL Command} import module @dots{}
Import modules / List those imported.
@end deffn
@@ -247,7 +247,7 @@ List current bindings.
@end deffn
@deffn {REPL Command} in module expression
address@hidden {REPL Command} in module command [args ...]
address@hidden {REPL Command} in module command arg @dots{}
Evaluate an expression, or alternatively, execute another meta-command
in the context of a module. For example, @samp{,in (foo bar) ,binding}
will show the bindings in the module @code{(foo bar)}.
diff --git a/doc/ref/srfi-modules.texi b/doc/ref/srfi-modules.texi
index cb29f18..fdc316f 100644
--- a/doc/ref/srfi-modules.texi
+++ b/doc/ref/srfi-modules.texi
@@ -475,15 +475,14 @@ first containing the first elements of each lists and the
second
containing the second elements of each lists, and so on.
@end deffn
address@hidden {Scheme Procedure} count pred lst1 @dots{} lstN
address@hidden {Scheme Procedure} count pred lst1 lst2 @dots{}
Return a count of the number of times @var{pred} returns true when
called on elements from the given lists.
@var{pred} is called with @var{N} parameters @code{(@var{pred}
address@hidden @dots{} @var{elemN})}, each element being from the
-corresponding @var{lst1} @dots{} @var{lstN}. The first call is with
-the first element of each list, the second with the second element
-from each, and so on.
address@hidden @dots{} @var{elemN} )}, each element being from the
+corresponding list. The first call is with the first element of each
+list, the second with the second element from each, and so on.
Counting stops when the end of the shortest list is reached. At least
one list must be non-circular.
@@ -497,14 +496,14 @@ one list must be non-circular.
@c FIXME::martin: Review me!
address@hidden {Scheme Procedure} fold proc init lst1 @dots{} lstN
address@hidden {Scheme Procedure} fold-right proc init lst1 @dots{} lstN
-Apply @var{proc} to the elements of @var{lst1} @dots{} @var{lstN} to
address@hidden {Scheme Procedure} fold proc init lst1 lst2 @dots{}
address@hidden {Scheme Procedure} fold-right proc init lst1 lst2 @dots{}
+Apply @var{proc} to the elements of @var{lst1} @var{lst2} @dots{} to
build a result, and return that result.
-Each @var{proc} call is @code{(@var{proc} @var{elem1} @dots{}
address@hidden @var{previous})}, where @var{elem1} is from @var{lst1},
-through @var{elemN} from @var{lstN}. @var{previous} is the return
+Each @var{proc} call is @code{(@var{proc} @var{elem1} @var{elem2}
address@hidden @var{previous})}, where @var{elem1} is from @var{lst1},
address@hidden is from @var{lst2}, and so on. @var{previous} is the return
from the previous call to @var{proc}, or the given @var{init} for the
first call. If any list is empty, just @var{init} is returned.
@@ -534,11 +533,11 @@ string, and the last among equal longest,
@result{} "xyz"
@end example
-If @var{lst1} through @var{lstN} have different lengths, @code{fold}
+If @var{lst1} @var{lst2} @dots{} have different lengths, @code{fold}
stops when the end of the shortest is reached; @code{fold-right}
-commences at the last element of the shortest. Ie.@: elements past
-the length of the shortest are ignored in the other @var{lst}s. At
-least one @var{lst} must be non-circular.
+commences at the last element of the shortest. Ie.@: elements past the
+length of the shortest are ignored in the other @var{lst}s. At least
+one @var{lst} must be non-circular.
@code{fold} should be preferred over @code{fold-right} if the order of
processing doesn't matter, or can be arranged either way, since
@@ -567,8 +566,8 @@ a variable in which to build the result, but a
self-contained
@code{for-each} would have to be written out each time.
@end deffn
address@hidden {Scheme Procedure} pair-fold proc init lst1 @dots{} lstN
address@hidden {Scheme Procedure} pair-fold-right proc init lst1 @dots{} lstN
address@hidden {Scheme Procedure} pair-fold proc init lst1 lst2 @dots{}
address@hidden {Scheme Procedure} pair-fold-right proc init lst1 lst2 @dots{}
The same as @code{fold} and @code{fold-right}, but apply @var{proc} to
the pairs of the lists instead of the list elements.
@end deffn
@@ -839,48 +838,51 @@ wanting to use @code{break} from within a @code{while}
loop will need
to make a new define under a different name.
@end deffn
address@hidden {Scheme Procedure} any pred lst1 lst2 @dots{} lstN
-Test whether any set of elements from @var{lst1} @dots{} lstN
-satisfies @var{pred}. If so the return value is the return from the
-successful @var{pred} call, or if not the return is @code{#f}.
address@hidden {Scheme Procedure} any pred lst1 lst2 @dots{}
+Test whether any set of elements from @var{lst1} @var{lst2} @dots{}
+satisfies @var{pred}. If so, the return value is the return value from
+the successful @var{pred} call, or if not, the return value is
address@hidden
-Each @var{pred} call is @code{(@var{pred} @var{elem1} @dots{}
address@hidden)} taking an element from each @var{lst}. The calls are
-made successively for the first, second, etc elements of the lists,
-stopping when @var{pred} returns address@hidden, or when the end of the
-shortest list is reached.
+If there are n list arguments, then @var{pred} must be a predicate
+taking n arguments. Each @var{pred} call is @code{(@var{pred}
address@hidden @var{elem2} @dots{} )} taking an element from each
address@hidden The calls are made successively for the first, second, etc.
+elements of the lists, stopping when @var{pred} returns address@hidden,
+or when the end of the shortest list is reached.
-The @var{pred} call on the last set of elements (ie.@: when the end of
+The @var{pred} call on the last set of elements (i.e., when the end of
the shortest list has been reached), if that point is reached, is a
tail call.
@end deffn
address@hidden {Scheme Procedure} every pred lst1 lst2 @dots{} lstN
-Test whether every set of elements from @var{lst1} @dots{} lstN
-satisfies @var{pred}. If so the return value is the return from the
-final @var{pred} call, or if not the return is @code{#f}.
address@hidden {Scheme Procedure} every pred lst1 lst2 @dots{}
+Test whether every set of elements from @var{lst1} @var{lst2} @dots{}
+satisfies @var{pred}. If so, the return value is the return from the
+final @var{pred} call, or if not, the return value is @code{#f}.
-Each @var{pred} call is @code{(@var{pred} @var{elem1} @dots{}
address@hidden)} taking an element from each @var{lst}. The calls are
-made successively for the first, second, etc elements of the lists,
-stopping if @var{pred} returns @code{#f}, or when the end of any of
-the lists is reached.
+If there are n list arguments, then @var{pred} must be a predicate
+taking n arguments. Each @var{pred} call is @code{(@var{pred}
address@hidden @var{elem2 @dots{}})} taking an element from each
address@hidden The calls are made successively for the first, second, etc.
+elements of the lists, stopping if @var{pred} returns @code{#f}, or when
+the end of any of the lists is reached.
-The @var{pred} call on the last set of elements (ie.@: when the end of
+The @var{pred} call on the last set of elements (i.e., when the end of
the shortest list has been reached) is a tail call.
-If one of @var{lst1} @dots{} @var{lstN} is empty then no calls to
address@hidden are made, and the return is @code{#t}.
+If one of @var{lst1} @var{lst2} @dots{}is empty then no calls to
address@hidden are made, and the return value is @code{#t}.
@end deffn
address@hidden {Scheme Procedure} list-index pred lst1 @dots{} lstN
address@hidden {Scheme Procedure} list-index pred lst1 lst2 @dots{}
Return the index of the first set of elements, one from each of
address@hidden@address@hidden, which satisfies @var{pred}.
address@hidden @var{lst2} @dots{}, which satisfies @var{pred}.
address@hidden is called as @code{(@var{pred} elem1 @dots{} elemN)}.
address@hidden is called as @code{(@var{elem1} @var{elem2 @dots{}})}.
Searching stops when the end of the shortest @var{lst} is reached.
The return index starts from 0 for the first set of elements. If no
-set of elements pass then the return is @code{#f}.
+set of elements pass, then the return value is @code{#f}.
@example
(list-index odd? '(2 4 6 9)) @result{} 3
@@ -1045,11 +1047,11 @@ sameness. This predicate must be consistent with
@code{eq?}
@code{eq?} then they must also be equal under the predicate. This
simply means a given object must be equal to itself.
address@hidden {Scheme Procedure} lset<= = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset<= = list @dots{}
Return @code{#t} if each list is a subset of the one following it.
-Ie.@: @var{list1} a subset of @var{list2}, @var{list2} a subset of
address@hidden, etc, for as many lists as given. If only one list or no
-lists are given then the return is @code{#t}.
+I.e., @var{list1} is a subset of @var{list2}, @var{list2} is a subset of
address@hidden, etc., for as many lists as given. If only one list or no
+lists are given, the return value is @code{#t}.
A list @var{x} is a subset of @var{y} if each element of @var{x} is
equal to some element in @var{y}. Elements are compared using the
@@ -1062,11 +1064,11 @@ given @var{=} procedure, called as @code{(@var{=} xelem
yelem)}.
@end example
@end deffn
address@hidden {Scheme Procedure} lset= = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset= = list @dots{}
Return @code{#t} if all argument lists are set-equal. @var{list1} is
-compared to @var{list2}, @var{list2} to @var{list3}, etc, for as many
-lists as given. If only one list or no lists are given then the
-return is @code{#t}.
+compared to @var{list2}, @var{list2} to @var{list3}, etc., for as many
+lists as given. If only one list or no lists are given, the return
+value is @code{#t}.
Two lists @var{x} and @var{y} are set-equal if each element of @var{x}
is equal to some element of @var{y} and conversely each element of
@@ -1082,14 +1084,14 @@ yelem)}, but exactly which calls are made is
unspecified.
@end example
@end deffn
address@hidden {Scheme Procedure} lset-adjoin = list elem1 @dots{}
-Add to @var{list} any of the given @var{elem}s not already in the
-list. @var{elem}s are @code{cons}ed onto the start of @var{list} (so
-the return shares a common tail with @var{list}), but the order
-they're added is unspecified.
address@hidden {Scheme Procedure} lset-adjoin = list elem @dots{}
+Add to @var{list} any of the given @var{elem}s not already in the list.
address@hidden are @code{cons}ed onto the start of @var{list} (so the
+return value shares a common tail with @var{list}), but the order that
+the @var{elem}s are added is unspecified.
The given @var{=} procedure is used for comparing elements, called as
address@hidden(@var{=} listelem elem)}, ie.@: the second argument is one of
address@hidden(@var{=} listelem elem)}, i.e., the second argument is one of
the given @var{elem} parameters.
@example
@@ -1097,11 +1099,11 @@ the given @var{elem} parameters.
@end example
@end deffn
address@hidden {Scheme Procedure} lset-union = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset-union! = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset-union = list @dots{}
address@hidden {Scheme Procedure} lset-union! = list @dots{}
Return the union of the argument list sets. The result is built by
taking the union of @var{list1} and @var{list2}, then the union of
-that with @var{list3}, etc, for as many lists as given. For one list
+that with @var{list3}, etc., for as many lists as given. For one list
argument that list itself is the result, for no list arguments the
result is the empty list.
@@ -1197,8 +1199,8 @@ a tail with @var{list1}. @code{lset-diff+intersection!}
may modify
@var{list1} to form its results.
@end deffn
address@hidden {Scheme Procedure} lset-xor = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset-xor! = list1 list2 @dots{}
address@hidden {Scheme Procedure} lset-xor = list @dots{}
address@hidden {Scheme Procedure} lset-xor! = list @dots{}
Return an XOR of the argument lists. For two lists this means those
elements which are in exactly one of the lists. For more than two
lists it means those elements which appear in an odd number of the
@@ -1461,18 +1463,18 @@ indicated type.
@deffnx {Scheme Procedure} make-f64vector n [value]
@deffnx {Scheme Procedure} make-c32vector n [value]
@deffnx {Scheme Procedure} make-c64vector n [value]
address@hidden {C Function} scm_make_u8vector n [value]
address@hidden {C Function} scm_make_s8vector n [value]
address@hidden {C Function} scm_make_u16vector n [value]
address@hidden {C Function} scm_make_s16vector n [value]
address@hidden {C Function} scm_make_u32vector n [value]
address@hidden {C Function} scm_make_s32vector n [value]
address@hidden {C Function} scm_make_u64vector n [value]
address@hidden {C Function} scm_make_s64vector n [value]
address@hidden {C Function} scm_make_f32vector n [value]
address@hidden {C Function} scm_make_f64vector n [value]
address@hidden {C Function} scm_make_c32vector n [value]
address@hidden {C Function} scm_make_c64vector n [value]
address@hidden {C Function} scm_make_u8vector (n, value)
address@hidden {C Function} scm_make_s8vector (n, value)
address@hidden {C Function} scm_make_u16vector (n, value)
address@hidden {C Function} scm_make_s16vector (n, value)
address@hidden {C Function} scm_make_u32vector (n, value)
address@hidden {C Function} scm_make_s32vector (n, value)
address@hidden {C Function} scm_make_u64vector (n, value)
address@hidden {C Function} scm_make_s64vector (n, value)
address@hidden {C Function} scm_make_f32vector (n, value)
address@hidden {C Function} scm_make_f64vector (n, value)
address@hidden {C Function} scm_make_c32vector (n, value)
address@hidden {C Function} scm_make_c64vector (n, value)
Return a newly allocated homogeneous numeric vector holding @var{n}
elements of the indicated type. If @var{value} is given, the vector
is initialized with that value, otherwise the contents are
@@ -1547,18 +1549,18 @@ Return the number of elements in @var{vec}.
@deffnx {Scheme Procedure} f64vector-ref vec i
@deffnx {Scheme Procedure} c32vector-ref vec i
@deffnx {Scheme Procedure} c64vector-ref vec i
address@hidden {C Function} scm_u8vector_ref (vec i)
address@hidden {C Function} scm_s8vector_ref (vec i)
address@hidden {C Function} scm_u16vector_ref (vec i)
address@hidden {C Function} scm_s16vector_ref (vec i)
address@hidden {C Function} scm_u32vector_ref (vec i)
address@hidden {C Function} scm_s32vector_ref (vec i)
address@hidden {C Function} scm_u64vector_ref (vec i)
address@hidden {C Function} scm_s64vector_ref (vec i)
address@hidden {C Function} scm_f32vector_ref (vec i)
address@hidden {C Function} scm_f64vector_ref (vec i)
address@hidden {C Function} scm_c32vector_ref (vec i)
address@hidden {C Function} scm_c64vector_ref (vec i)
address@hidden {C Function} scm_u8vector_ref (vec, i)
address@hidden {C Function} scm_s8vector_ref (vec, i)
address@hidden {C Function} scm_u16vector_ref (vec, i)
address@hidden {C Function} scm_s16vector_ref (vec, i)
address@hidden {C Function} scm_u32vector_ref (vec, i)
address@hidden {C Function} scm_s32vector_ref (vec, i)
address@hidden {C Function} scm_u64vector_ref (vec, i)
address@hidden {C Function} scm_s64vector_ref (vec, i)
address@hidden {C Function} scm_f32vector_ref (vec, i)
address@hidden {C Function} scm_f64vector_ref (vec, i)
address@hidden {C Function} scm_c32vector_ref (vec, i)
address@hidden {C Function} scm_c64vector_ref (vec, i)
Return the element at index @var{i} in @var{vec}. The first element
in @var{vec} is index 0.
@end deffn
@@ -1575,18 +1577,18 @@ in @var{vec} is index 0.
@deffnx {Scheme Procedure} f64vector-set! vec i value
@deffnx {Scheme Procedure} c32vector-set! vec i value
@deffnx {Scheme Procedure} c64vector-set! vec i value
address@hidden {C Function} scm_u8vector_set_x (vec i value)
address@hidden {C Function} scm_s8vector_set_x (vec i value)
address@hidden {C Function} scm_u16vector_set_x (vec i value)
address@hidden {C Function} scm_s16vector_set_x (vec i value)
address@hidden {C Function} scm_u32vector_set_x (vec i value)
address@hidden {C Function} scm_s32vector_set_x (vec i value)
address@hidden {C Function} scm_u64vector_set_x (vec i value)
address@hidden {C Function} scm_s64vector_set_x (vec i value)
address@hidden {C Function} scm_f32vector_set_x (vec i value)
address@hidden {C Function} scm_f64vector_set_x (vec i value)
address@hidden {C Function} scm_c32vector_set_x (vec i value)
address@hidden {C Function} scm_c64vector_set_x (vec i value)
address@hidden {C Function} scm_u8vector_set_x (vec, i, value)
address@hidden {C Function} scm_s8vector_set_x (vec, i, value)
address@hidden {C Function} scm_u16vector_set_x (vec, i, value)
address@hidden {C Function} scm_s16vector_set_x (vec, i, value)
address@hidden {C Function} scm_u32vector_set_x (vec, i, value)
address@hidden {C Function} scm_s32vector_set_x (vec, i, value)
address@hidden {C Function} scm_u64vector_set_x (vec, i, value)
address@hidden {C Function} scm_s64vector_set_x (vec, i, value)
address@hidden {C Function} scm_f32vector_set_x (vec, i, value)
address@hidden {C Function} scm_f64vector_set_x (vec, i, value)
address@hidden {C Function} scm_c32vector_set_x (vec, i, value)
address@hidden {C Function} scm_c64vector_set_x (vec, i, value)
Set the element at index @var{i} in @var{vec} to @var{value}. The
first element in @var{vec} is index 0. The return value is
unspecified.
@@ -1734,13 +1736,13 @@ Return the number of elements in @var{vec}.
@end deffn
@deffn {Scheme Procedure} uniform-vector-ref vec i
address@hidden {C Function} scm_uniform_vector_ref (vec i)
address@hidden {C Function} scm_uniform_vector_ref (vec, i)
Return the element at index @var{i} in @var{vec}. The first element
in @var{vec} is index 0.
@end deffn
@deffn {Scheme Procedure} uniform-vector-set! vec i value
address@hidden {C Function} scm_uniform_vector_set_x (vec i value)
address@hidden {C Function} scm_uniform_vector_set_x (vec, i, value)
Set the element at index @var{i} in @var{vec} to @var{value}. The
first element in @var{vec} is index 0. The return value is
unspecified.
@@ -3156,10 +3158,10 @@ parameters of a function. It can be used with,
(use-modules (srfi srfi-26))
@end example
address@hidden {library syntax} cut slot @dots{}
address@hidden {library syntax} cute slot @dots{}
-Return a new procedure which will make a call (@var{slot} @dots{}) but
-with selected parameters specialized to given expressions.
address@hidden {library syntax} cut slot1 slot2 @dots{}
address@hidden {library syntax} cute slot1 slot2 @dots{}
+Return a new procedure which will make a call (@var{slot1} @var{slot2}
address@hidden) but with selected parameters specialized to given expressions.
An example will illustrate the idea. The following is a
specialization of @code{write}, sending output to
@@ -3517,7 +3519,7 @@ values as in the following example:
Note that all fields of @var{type} and its supertypes must be specified.
@end deffn
address@hidden {Scheme Procedure} make-compound-condition . conditions
address@hidden {Scheme Procedure} make-compound-condition condition1 condition2
@dots{}
Return a new compound condition composed of @var{conditions}. The
returned condition has the type of each condition of @var{conditions}
(per @code{condition-has-type?}).
@@ -3569,13 +3571,14 @@ The example below defines condition type @code{&foo},
inheriting from
@end lisp
@end deffn
address@hidden {library syntax} condition type-field-bindings...
-Return a new condition, or compound condition, initialized according to
address@hidden Each @var{type-field-binding} must have the
-form @code{(type field-specs...)}, where @var{type} is the name of a
-variable bound to condition type; each @var{field-spec} must have the
-form @code{(field-name value)} where @var{field-name} is a symbol
-denoting the field being initialized to @var{value}. As for
address@hidden {library syntax} condition type-field-binding1
type-field-binding2 @dots{}
+Return a new condition or compound condition, initialized according to
address@hidden @var{type-field-binding2} @enddots{}. Each
address@hidden must have the form @code{(type
+field-specs...)}, where @var{type} is the name of a variable bound to a
+condition type; each @var{field-spec} must have the form
address@hidden(field-name value)} where @var{field-name} is a symbol denoting
+the field being initialized to @var{value}. As for
@code{make-condition}, all fields must be specified.
The following example returns a simple condition:
@@ -3703,12 +3706,12 @@ Return the specified field of @var{opt}, an option
object, as
described above for @code{option}.
@end deffn
address@hidden {Scheme Procedure} args-fold args options
unrecognized-option-proc operand-proc seeds @dots{}
-Process @var{args}, a list of program arguments such as that returned
-by @code{(cdr (program-arguments))}, in order against @var{options}, a
-list of option objects as described above. All functions called take
-the ``seeds'', or the last multiple-values as multiple arguments,
-starting with @var{seeds}, and must return the new seeds. Return the
address@hidden {Scheme Procedure} args-fold args options
unrecognized-option-proc operand-proc seed @dots{}
+Process @var{args}, a list of program arguments such as that returned by
address@hidden(cdr (program-arguments))}, in order against @var{options}, a list
+of option objects as described above. All functions called take the
+``seeds'', or the last multiple-values as multiple arguments, starting
+with @var{seed} @dots{}, and must return the new seeds. Return the
final seeds.
Call @code{unrecognized-option-proc}, which is like an option object's
@@ -4021,9 +4024,9 @@ SRFI-55 provides @code{require-extension} which is a
portable
mechanism to load selected SRFI modules. This is implemented in the
Guile core, there's no module needed to get SRFI-55 itself.
address@hidden {library syntax} require-extension address@hidden
-Require each of the given @var{clause} features, throwing an error if
-any are unavailable.
address@hidden {library syntax} require-extension clause1 clause2 @dots{}
+Require the features of @var{clause1} @var{clause2} @dots{} , throwing
+an error if any are unavailable.
A @var{clause} is of the form @code{(@var{identifier} arg...)}. The
only @var{identifier} currently supported is @code{srfi} and the
diff --git a/doc/ref/sxml-match.texi b/doc/ref/sxml-match.texi
index cf5c5d3..7a1a9ac 100644
--- a/doc/ref/sxml-match.texi
+++ b/doc/ref/sxml-match.texi
@@ -64,7 +64,7 @@ Dybvig at Indiana University.
@code{sxml-match} provides @code{case}-like form for pattern matching of XML
nodes.
address@hidden {Scheme Syntax} sxml-match input-expression clause ...
address@hidden {Scheme Syntax} sxml-match input-expression clause1 clause2
@dots{}
Match @var{input-expression}, an SXML tree, according to the given
@var{clause}s
(one or more), each consisting of a pattern and one or more expressions to be
evaluated if the pattern match succeeds. Optionally, each @var{clause} within
diff --git a/libguile/continuations.c b/libguile/continuations.c
index cf8b6ac..d991278 100644
--- a/libguile/continuations.c
+++ b/libguile/continuations.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 1995,1996,1998,2000,2001,2004, 2006, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1998,2000,2001,2004, 2006, 2008, 2009, 2010, 2011,
2012 Free Software Foundation, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
@@ -71,36 +71,35 @@ static scm_t_bits tc16_continuation;
#define META_HEADER(meta) meta, 0, 0, 0, 0, 0, 0, 0
#endif
-#define ALIGN_PTR(type,p,align) (type*)(ROUND_UP (((scm_t_bits)p), align))
+#define OBJCODE_TAG SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_STATIC, 0)
-#ifdef SCM_ALIGNED
+#if defined (SCM_ALIGNED) && 0
#define SCM_DECLARE_STATIC_ALIGNED_ARRAY(type, sym) \
static const type sym[]
#define SCM_STATIC_ALIGNED_ARRAY(alignment, type, sym) \
static SCM_ALIGNED (alignment) const type sym[]
-#else
-#define SCM_DECLARE_STATIC_ALIGNED_ARRAY(type, sym) \
-static type *sym
-#define SCM_STATIC_ALIGNED_ARRAY(alignment, type, sym) \
-SCM_SNARF_INIT(sym = scm_malloc_pointerless (sizeof(sym##__unaligned)); \
- memcpy (sym, sym##__unaligned, sizeof(sym##__unaligned));) \
-static type *sym = NULL; \
-static const type sym##__unaligned[]
-#endif
-
-#define STATIC_OBJCODE_TAG \
- SCM_PACK (SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_STATIC, 0))
-
#define SCM_STATIC_OBJCODE(sym) \
SCM_DECLARE_STATIC_ALIGNED_ARRAY (scm_t_uint8, sym##__bytecode); \
SCM_STATIC_ALIGNED_ARRAY (8, scm_t_cell, sym##__cells) = { \
- { STATIC_OBJCODE_TAG, SCM_PACK (sym##__bytecode) }, \
+ { SCM_PACK (OBJCODE_TAG), SCM_PACK (sym##__bytecode) }, \
{ SCM_BOOL_F, SCM_PACK (0) } \
}; \
static const SCM sym = SCM_PACK (sym##__cells); \
SCM_STATIC_ALIGNED_ARRAY (8, scm_t_uint8, sym##__bytecode)
+#else
+#define SCM_STATIC_OBJCODE(sym) \
+static SCM sym; \
+static scm_t_uint8 *sym##_bytecode; \
+SCM_SNARF_INIT(sym##_bytecode = scm_gc_malloc_pointerless
(sizeof(sym##_bytecode__unaligned), "partial continuation stub"); \
+ memcpy (sym##_bytecode, sym##_bytecode__unaligned,
sizeof(sym##_bytecode__unaligned));) \
+SCM_SNARF_INIT(sym = scm_double_cell (OBJCODE_TAG, \
+ (scm_t_bits)sym##_bytecode, \
+ SCM_UNPACK (SCM_BOOL_F), \
+ 0);) \
+static const scm_t_uint8 sym##_bytecode__unaligned[]
+#endif
+
-
SCM_STATIC_OBJCODE (cont_objcode) = {
/* This code is the same as in gsubr.c, except we use continuation_call
instead of subr_call. */
diff --git a/libguile/control.c b/libguile/control.c
index 661de8f..f8d2d60 100644
--- a/libguile/control.c
+++ b/libguile/control.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010, 2011 Free Software Foundation, Inc.
+/* Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
@@ -81,36 +81,35 @@ scm_i_prompt_pop_abort_args_x (SCM vm)
#define META_HEADER(meta) meta, 0, 0, 0, 0, 0, 0, 0
#endif
-#define ALIGN_PTR(type,p,align) (type*)(ROUND_UP (((scm_t_bits)p), align))
+#define OBJCODE_TAG SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_STATIC, 0)
-#ifdef SCM_ALIGNED
+#if defined (SCM_ALIGNED)
#define SCM_DECLARE_STATIC_ALIGNED_ARRAY(type, sym) \
static const type sym[]
#define SCM_STATIC_ALIGNED_ARRAY(alignment, type, sym) \
static SCM_ALIGNED (alignment) const type sym[]
-#else
-#define SCM_DECLARE_STATIC_ALIGNED_ARRAY(type, sym) \
-static type *sym
-#define SCM_STATIC_ALIGNED_ARRAY(alignment, type, sym) \
-SCM_SNARF_INIT(sym = scm_malloc_pointerless (sizeof(sym##__unaligned); \
- memcpy (sym, sym##__unaligned, sizeof(sym##__unaligned));) \
-static type *sym = NULL; \
-static const type sym##__unaligned[]
-#endif
-
-#define STATIC_OBJCODE_TAG \
- SCM_PACK (SCM_MAKE_OBJCODE_TAG (SCM_OBJCODE_TYPE_STATIC, 0))
-
#define SCM_STATIC_OBJCODE(sym) \
SCM_DECLARE_STATIC_ALIGNED_ARRAY (scm_t_uint8, sym##__bytecode); \
SCM_STATIC_ALIGNED_ARRAY (8, scm_t_cell, sym##__cells) = { \
- { STATIC_OBJCODE_TAG, SCM_PACK (sym##__bytecode) }, \
+ { SCM_PACK (OBJCODE_TAG), SCM_PACK (sym##__bytecode) }, \
{ SCM_BOOL_F, SCM_PACK (0) } \
}; \
static const SCM sym = SCM_PACK (sym##__cells); \
SCM_STATIC_ALIGNED_ARRAY (8, scm_t_uint8, sym##__bytecode)
+#else
+#define SCM_STATIC_OBJCODE(sym) \
+static SCM sym; \
+static scm_t_uint8 *sym##_bytecode; \
+SCM_SNARF_INIT(sym##_bytecode = scm_gc_malloc_pointerless
(sizeof(sym##_bytecode__unaligned), "partial continuation stub"); \
+ memcpy (sym##_bytecode, sym##_bytecode__unaligned,
sizeof(sym##_bytecode__unaligned));) \
+SCM_SNARF_INIT(sym = scm_double_cell (OBJCODE_TAG, \
+ (scm_t_bits)sym##_bytecode, \
+ SCM_UNPACK (SCM_BOOL_F), \
+ 0);) \
+static const scm_t_uint8 sym##_bytecode__unaligned[]
+#endif
+
-
SCM_STATIC_OBJCODE (cont_objcode) = {
/* Like in continuations.c, but with partial-cont-call. */
OBJCODE_HEADER (8, 19),
hooks/post-receive
--
GNU Guile
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Guile-commits] GNU Guile branch, stable-2.0, updated. v2.0.5-27-gbc02028,
Andy Wingo <=