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=3323ec063ccc87b210e6da04c57c625af270b230 The branch, master has been updated via 3323ec063ccc87b210e6da04c57c625af270b230 (commit) from 211a5b04251424f17f659257718329af7a3cdc0c (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 3323ec063ccc87b210e6da04c57c625af270b230 Author: Neil Jerram <n...@ossau.uklinux.net> Date: Sun Dec 27 23:24:09 2009 +0000 Automatic manual updates following libguile docstring changes Affecting the following procedures: * doc/ref/api-compound.texi (Uniform Numeric Vectors): uniform-array-read! * doc/ref/api-data.texi (Complex): make-rectangular, string=?, string<?, string<=?, string>?, string>=?, string-ci=?, string-ci<?, string-ci<=?, string-ci>?, string-ci>=?, string-append/shared * doc/ref/api-evaluation.texi (Reader Extensions): read-hash-extend * doc/ref/api-procedures.texi (Procedures with Setters): procedure, macro?, macro-type * doc/ref/api-undocumented.texi: module-import-interface, %method-more-specific? * doc/ref/new-docstrings.texi: uniform-array->bytevector, %start-stack, guardian-destroyed?, guardian-greedy?, destroy-guardian!, gc-dump, gc-disable, gc-enable, make-generalized-vector, set-primitive-generic!, nl-langinfo, %warn-autocompilation-enabled, make-syncase-macro, make-extended-syncase-macro, syncase-macro-type, syncase-macro-binding, memoize-expression, unmemoize-expression, memoized-expression-typecode, memoized-expression-data, memoized-typecode, memoize-variable-access!, module-local-variable, module-variable, eval-closure-module, module-transformer, module-public-interface, define!, module-reverse-lookup, cddr, make-promise, %get-stack-size, %string-dump, %symbol-dump, string-bytes-per-char, uniform-vector-element-type, uniform-vector-element-size, canonicalize-path, getrlimit, setrlimit * doc/maint/guile.texi: Corresponding tracking updates. ----------------------------------------------------------------------- Summary of changes: doc/maint/guile.texi | 109 +++++++++-------- doc/ref/api-compound.texi | 37 +++---- doc/ref/api-data.texi | 46 +++++--- doc/ref/api-evaluation.texi | 4 +- doc/ref/api-procedures.texi | 18 ++-- doc/ref/api-undocumented.texi | 4 +- doc/ref/new-docstrings.texi | 271 +++++++++++++++++++++++++++++++++++++++++ 7 files changed, 385 insertions(+), 104 deletions(-) diff --git a/doc/maint/guile.texi b/doc/maint/guile.texi index 127f0bb..d521f98 100644 --- a/doc/maint/guile.texi +++ b/doc/maint/guile.texi @@ -2130,7 +2130,7 @@ all necessary initialization information. @c snarfed from goops.c:2318 @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs) - +Return true if method @var{m1} is more specific than @var{m2} given the argument types (classes) listed in @var{targs}. @end deffn %goops-loaded @@ -3220,19 +3220,19 @@ environment. For example: @c snarfed from macros.c:165 @deffn {Scheme Procedure} macro? obj @deffnx {C Function} scm_macro_p (obj) -Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a -syntax transformer. +Return @code{#t} if @var{obj} is a regular macro, a memoizing macro, a +syntax transformer, or a syntax-case macro. @end deffn macro-type @c snarfed from macros.c:186 @deffn {Scheme Procedure} macro-type m @deffnx {C Function} scm_macro_type (m) -Return one of the symbols @code{syntax}, @code{macro} or -...@code{macro!}, depending on whether @var{m} is a syntax -transformer, a regular macro, or a memoizing macro, -respectively. If @var{m} is not a macro, @code{#f} is -returned. +Return one of the symbols @code{syntax}, @code{macro}, +...@code{macro!}, or @code{syntax-case}, depending on whether +...@var{m} is a syntax transformer, a regular macro, a memoizing +macro, or a syntax-case macro, respectively. If @var{m} is +not a macro, @code{#f} is returned. @end deffn macro-name @@ -3300,7 +3300,7 @@ Return a interface eval closure for the module @var{module}. Such a closure does @c snarfed from modules.c:399 @deffn {Scheme Procedure} module-import-interface module sym @deffnx {C Function} scm_module_import_interface (module, sym) - +Return the module or interface from which @var{sym} is imported in @var{module}. If @var{sym} is not imported (i.e., it is not defined in @var{module} or it is a module-local binding instead of an imported one), then @code{#f} is returned. @end deffn %get-pre-modules-obarray @@ -3689,10 +3689,9 @@ procedure does not accept complex arguments. make-rectangular @c snarfed from numbers.c:5286 -...@deffn {Scheme Procedure} make-rectangular real imaginary -...@deffnx {C Function} scm_make_rectangular (real, imaginary) -Return a complex number constructed of the given @var{real} and -...@var{imaginary} parts. +...@deffn {Scheme Procedure} make-rectangular real_part imaginary_part +...@deffnx {C Function} scm_make_rectangular (real_part, imaginary_part) +Return a complex number constructed of the given @var{real-part} and @var{imaginary-part} parts. @end deffn make-polar @@ -4361,8 +4360,8 @@ with the associated setter @var{setter}. @c snarfed from procs.c:308 @deffn {Scheme Procedure} procedure proc @deffnx {C Function} scm_procedure (proc) -Return the procedure of @var{proc}, which must be either a -procedure with setter, or an operator struct. +Return the procedure of @var{proc}, which must be an +applicable struct. @end deffn primitive-make-property @@ -4566,7 +4565,9 @@ Install the procedure @var{proc} for reading expressions starting with the character sequence @code{#} and @var{chr}. @var{proc} will be called with two arguments: the character @var{chr} and the port to read further data from. The object -returned will be the return value of @code{read}. +returned will be the return value of @code{read}. +Passing @code{#f} for @var{proc} will remove a previous setting. + @end deffn call-with-dynamic-root @@ -5438,30 +5439,23 @@ Return the number of elements in the uniform vector @var{v}. uniform-vector-read! @c snarfed from srfi-4.c:845 -...@deffn {Scheme Procedure} uniform-vector-read! uvec [port_or_fd [start [end]]] -...@deffnx {C Function} scm_uniform_vector_read_x (uvec, port_or_fd, start, end) -Fill the elements of @var{uvec} by reading -raw bytes from @var{port-or-fdes}, using host byte order. +...@deffn {Scheme Procedure} uniform-array-read! ura [port_or_fd [start [end]]] +...@deffnx {Scheme Procedure} uniform-vector-read! uve [port-or-fdes] [start] [end] +...@deffnx {C Function} scm_uniform_array_read_x (ura, port_or_fd, start, end) +Attempt to read all elements of @var{ura}, in lexicographic order, as +binary objects from @var{port-or-fdes}. +If an end of file is encountered, +the objects up to that point are put into @var{ura} +(starting at the beginning) and the remainder of the array is +unchanged. -The optional arguments @var{start} (inclusive) and @var{end} -(exclusive) allow a specified region to be read, +The optional arguments @var{start} and @var{end} allow +a specified region of a vector (or linearized array) to be read, leaving the remainder of the vector unchanged. -When @var{port-or-fdes} is a port, all specified elements -of @var{uvec} are attempted to be read, potentially blocking -while waiting formore input or end-of-file. -When @var{port-or-fd} is an integer, a single call to -read(2) is made. - -An error is signalled when the last element has only -been partially filled before reaching end-of-file or in -the single call to read(2). - -...@code{uniform-vector-read!} returns the number of elements -read. - -...@var{port-or-fdes} may be omitted, in which case it defaults -to the value returned by @code{(current-input-port)}. +...@code{uniform-array-read!} returns the number of objects read. +...@var{port-or-fdes} may be omitted, in which case it defaults to the value +returned by @code{(current-input-port)}. @end deffn uniform-vector-write @@ -6671,8 +6665,9 @@ mismatch index, depending upon whether @var{s1} is less than, equal to, or greater than @var{s2}. The mismatch index is the largest index @var{i} such that for every 0 <= @var{j} < @var{i}, @var{s...@var{j}] = @var{s...@var{j}] -- that is, -...@var{i} is the first position that does not match. The -character comparison is done case-insensitively. +...@var{i} is the first position where the lowercased letters +do not match. + @end deffn string= @@ -7090,8 +7085,8 @@ operate on. The return value is unspecified. string-append/shared @c snarfed from srfi-13.c:2635 -...@deffn {Scheme Procedure} string-append/shared . ls -...@deffnx {C Function} scm_string_append_shared (ls) +...@deffn {Scheme Procedure} string-append/shared . rest +...@deffnx {C Function} scm_string_append_shared (rest) Like @code{string-append}, but the result may share memory with the argument strings. @end deffn @@ -7749,7 +7744,8 @@ character sets. string=? @c snarfed from strorder.c:50 -...@deffn {Scheme Procedure} string=? s1 s2 +...@deffn {Scheme Procedure} string=? [s1 [s2 . rest]] +...@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}. @@ -7762,7 +7758,8 @@ characters. string-ci=? @c snarfed from strorder.c:62 -...@deffn {Scheme Procedure} string-ci=? s1 s2 +...@deffn {Scheme Procedure} string-ci=? [s1 [s2 . rest]] +...@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 characters match (ignoring case) at each position; otherwise @@ -7771,35 +7768,40 @@ return @code{#f}. string<? @c snarfed from strorder.c:72 -...@deffn {Scheme Procedure} string<? s1 s2 +...@deffn {Scheme Procedure} string<? [s1 [s2 . rest]] +...@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}. @end deffn string<=? @c snarfed from strorder.c:82 -...@deffn {Scheme Procedure} string<=? s1 s2 +...@deffn {Scheme Procedure} string<=? [s1 [s2 . rest]] +...@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}. @end deffn string>? @c snarfed from strorder.c:92 -...@deffn {Scheme Procedure} string>? s1 s2 +...@deffn {Scheme Procedure} string>? [s1 [s2 . rest]] +...@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}. @end deffn string>=? @c snarfed from strorder.c:102 -...@deffn {Scheme Procedure} string>=? s1 s2 +...@deffn {Scheme Procedure} string>=? [s1 [s2 . rest]] +...@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}. @end deffn string-ci<? @c snarfed from strorder.c:113 -...@deffn {Scheme Procedure} string-ci<? s1 s2 +...@deffn {Scheme Procedure} string-ci<? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_less_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically less than @var{s2} regardless of case. @@ -7807,7 +7809,8 @@ regardless of case. string-ci<=? @c snarfed from strorder.c:124 -...@deffn {Scheme Procedure} string-ci<=? s1 s2 +...@deffn {Scheme Procedure} string-ci<=? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_leq_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically less than or equal to @var{s2} regardless of case. @@ -7815,7 +7818,8 @@ to @var{s2} regardless of case. string-ci>? @c snarfed from strorder.c:135 -...@deffn {Scheme Procedure} string-ci>? s1 s2 +...@deffn {Scheme Procedure} string-ci>? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_gr_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically greater than @var{s2} regardless of case. @@ -7823,7 +7827,8 @@ Case insensitive lexicographic ordering predicate; return string-ci>=? @c snarfed from strorder.c:146 -...@deffn {Scheme Procedure} string-ci>=? s1 s2 +...@deffn {Scheme Procedure} string-ci>=? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_geq_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically greater than or equal to @var{s2} regardless of case. diff --git a/doc/ref/api-compound.texi b/doc/ref/api-compound.texi index 5c1bd88..33ccdfe 100644 --- a/doc/ref/api-compound.texi +++ b/doc/ref/api-compound.texi @@ -1411,30 +1411,23 @@ be more convenient for binary input/output since they provide more flexibility in the interpretation of raw byte sequences (@pxref{Bytevectors}). -...@deffn {Scheme Procedure} uniform-vector-read! uvec [port_or_fd [start [end]]] -...@deffnx {C Function} scm_uniform_vector_read_x (uvec, port_or_fd, start, end) -Fill the elements of @var{uvec} by reading -raw bytes from @var{port-or-fdes}, using host byte order. +...@deffn {Scheme Procedure} uniform-array-read! ura [port_or_fd [start [end]]] +...@deffnx {Scheme Procedure} uniform-vector-read! uve [port-or-fdes] [start] [end] +...@deffnx {C Function} scm_uniform_array_read_x (ura, port_or_fd, start, end) +Attempt to read all elements of @var{ura}, in lexicographic order, as +binary objects from @var{port-or-fdes}. +If an end of file is encountered, +the objects up to that point are put into @var{ura} +(starting at the beginning) and the remainder of the array is +unchanged. -The optional arguments @var{start} (inclusive) and @var{end} -(exclusive) allow a specified region to be read, +The optional arguments @var{start} and @var{end} allow +a specified region of a vector (or linearized array) to be read, leaving the remainder of the vector unchanged. -When @var{port-or-fdes} is a port, all specified elements -of @var{uvec} are attempted to be read, potentially blocking -while waiting formore input or end-of-file. -When @var{port-or-fd} is an integer, a single call to -read(2) is made. - -An error is signalled when the last element has only -been partially filled before reaching end-of-file or in -the single call to read(2). - -...@code{uniform-vector-read!} returns the number of elements -read. - -...@var{port-or-fdes} may be omitted, in which case it defaults -to the value returned by @code{(current-input-port)}. +...@code{uniform-array-read!} returns the number of objects read. +...@var{port-or-fdes} may be omitted, in which case it defaults to the value +returned by @code{(current-input-port)}. @end deffn @deffn {Scheme Procedure} uniform-vector-write uvec [port_or_fd [start [end]]] diff --git a/doc/ref/api-data.texi b/doc/ref/api-data.texi index b959ab9..61f941a 100755 --- a/doc/ref/api-data.texi +++ b/doc/ref/api-data.texi @@ -1054,10 +1054,9 @@ locale-dependent parsing). @rnindex magnitude @rnindex angle -...@deffn {Scheme Procedure} make-rectangular real imaginary -...@deffnx {C Function} scm_make_rectangular (real, imaginary) -Return a complex number constructed of the given @var{real} and -...@var{imaginary} parts. +...@deffn {Scheme Procedure} make-rectangular real_part imaginary_part +...@deffnx {C Function} scm_make_rectangular (real_part, imaginary_part) +Return a complex number constructed of the given @var{real-part} and @var{imaginary-part} parts. @end deffn @deffn {Scheme Procedure} make-polar x y @@ -3072,7 +3071,8 @@ comparison. See @xref{Text Collation, the @code{(ice-9 i18n)} module}, for locale-dependent string comparison. @rnindex string=? -...@deffn {Scheme Procedure} string=? s1 s2 +...@deffn {Scheme Procedure} string=? [s1 [s2 . rest]] +...@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}. @@ -3084,31 +3084,36 @@ characters. @end deffn @rnindex string<? -...@deffn {Scheme Procedure} string<? s1 s2 +...@deffn {Scheme Procedure} string<? [s1 [s2 . rest]] +...@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}. @end deffn @rnindex string<=? -...@deffn {Scheme Procedure} string<=? s1 s2 +...@deffn {Scheme Procedure} string<=? [s1 [s2 . rest]] +...@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}. @end deffn @rnindex string>? -...@deffn {Scheme Procedure} string>? s1 s2 +...@deffn {Scheme Procedure} string>? [s1 [s2 . rest]] +...@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}. @end deffn @rnindex string>=? -...@deffn {Scheme Procedure} string>=? s1 s2 +...@deffn {Scheme Procedure} string>=? [s1 [s2 . rest]] +...@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}. @end deffn @rnindex string-ci=? -...@deffn {Scheme Procedure} string-ci=? s1 s2 +...@deffn {Scheme Procedure} string-ci=? [s1 [s2 . rest]] +...@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 characters match (ignoring case) at each position; otherwise @@ -3116,28 +3121,32 @@ return @code{#f}. @end deffn @rnindex string-ci<? -...@deffn {Scheme Procedure} string-ci<? s1 s2 +...@deffn {Scheme Procedure} string-ci<? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_less_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically less than @var{s2} regardless of case. @end deffn @rnindex string<=? -...@deffn {Scheme Procedure} string-ci<=? s1 s2 +...@deffn {Scheme Procedure} string-ci<=? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_leq_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically less than or equal to @var{s2} regardless of case. @end deffn @rnindex string-ci>? -...@deffn {Scheme Procedure} string-ci>? s1 s2 +...@deffn {Scheme Procedure} string-ci>? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_gr_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically greater than @var{s2} regardless of case. @end deffn @rnindex string-ci>=? -...@deffn {Scheme Procedure} string-ci>=? s1 s2 +...@deffn {Scheme Procedure} string-ci>=? [s1 [s2 . rest]] +...@deffnx {C Function} scm_i_string_ci_geq_p (s1, s2, rest) Case insensitive lexicographic ordering predicate; return @code{#t} if @var{s1} is lexicographically greater than or equal to @var{s2} regardless of case. @@ -3160,8 +3169,9 @@ mismatch index, depending upon whether @var{s1} is less than, equal to, or greater than @var{s2}. The mismatch index is the largest index @var{i} such that for every 0 <= @var{j} < @var{i}, @var{s...@var{j}] = @var{s...@var{j}] -- that is, -...@var{i} is the first position that does not match. The -character comparison is done case-insensitively. +...@var{i} is the first position where the lowercased letters +do not match. + @end deffn @deffn {Scheme Procedure} string= s1 s2 [start1 [end1 [start2 [end2]]]] @@ -3526,8 +3536,8 @@ concatenation of the given strings, @var{args}. @end example @end deffn -...@deffn {Scheme Procedure} string-append/shared . ls -...@deffnx {C Function} scm_string_append_shared (ls) +...@deffn {Scheme Procedure} string-append/shared . rest +...@deffnx {C Function} scm_string_append_shared (rest) Like @code{string-append}, but the result may share memory with the argument strings. @end deffn diff --git a/doc/ref/api-evaluation.texi b/doc/ref/api-evaluation.texi index fda0291..f1aeace 100644 --- a/doc/ref/api-evaluation.texi +++ b/doc/ref/api-evaluation.texi @@ -292,7 +292,9 @@ Install the procedure @var{proc} for reading expressions starting with the character sequence @code{#} and @var{chr}. @var{proc} will be called with two arguments: the character @var{chr} and the port to read further data from. The object -returned will be the return value of @code{read}. +returned will be the return value of @code{read}. +Passing @code{#f} for @var{proc} will remove a previous setting. + @end deffn diff --git a/doc/ref/api-procedures.texi b/doc/ref/api-procedures.texi index 0f89612..4639881 100644 --- a/doc/ref/api-procedures.texi +++ b/doc/ref/api-procedures.texi @@ -768,8 +768,8 @@ associated setter procedure. @deffn {Scheme Procedure} procedure proc @deffnx {C Function} scm_procedure (proc) -Return the procedure of @var{proc}, which must be either a -procedure with setter, or an operator struct. +Return the procedure of @var{proc}, which must be an +applicable struct. @end deffn @deffn {Scheme Procedure} setter proc @@ -1031,17 +1031,17 @@ as @dfn{syntax transformers}. @deffn {Scheme Procedure} macro? obj @deffnx {C Function} scm_macro_p (obj) -Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a -syntax transformer. +Return @code{#t} if @var{obj} is a regular macro, a memoizing macro, a +syntax transformer, or a syntax-case macro. @end deffn @deffn {Scheme Procedure} macro-type m @deffnx {C Function} scm_macro_type (m) -Return one of the symbols @code{syntax}, @code{macro} or -...@code{macro!}, depending on whether @var{m} is a syntax -transformer, a regular macro, or a memoizing macro, -respectively. If @var{m} is not a macro, @code{#f} is -returned. +Return one of the symbols @code{syntax}, @code{macro}, +...@code{macro!}, or @code{syntax-case}, depending on whether +...@var{m} is a syntax transformer, a regular macro, a memoizing +macro, or a syntax-case macro, respectively. If @var{m} is +not a macro, @code{#f} is returned. @end deffn @deffn {Scheme Procedure} macro-name m diff --git a/doc/ref/api-undocumented.texi b/doc/ref/api-undocumented.texi index ef1df19..cae96bc 100644 --- a/doc/ref/api-undocumented.texi +++ b/doc/ref/api-undocumented.texi @@ -155,7 +155,7 @@ has been passed to scm_register_module_xxx. @deffn {Scheme Procedure} module-import-interface module sym @deffnx {C Function} scm_module_import_interface (module, sym) - +Return the module or interface from which @var{sym} is imported in @var{module}. If @var{sym} is not imported (i.e., it is not defined in @var{module} or it is a module-local binding instead of an imported one), then @code{#f} is returned. @end deffn @@ -623,7 +623,7 @@ on the C level which depends on the loaded GOOPS modules. @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs) - +Return true if method @var{m1} is more specific than @var{m2} given the argument types (classes) listed in @var{targs}. @end deffn @deffn {Scheme Procedure} find-method . l diff --git a/doc/ref/new-docstrings.texi b/doc/ref/new-docstrings.texi index c8f16a3..65dda6e 100644 --- a/doc/ref/new-docstrings.texi +++ b/doc/ref/new-docstrings.texi @@ -1,3 +1,274 @@ @c module-for-docstring (guile) + +...@deffn {Scheme Procedure} uniform-array->bytevector array +...@deffnx {C Function} scm_uniform_array_to_bytevector (array) +Return a newly allocated bytevector whose contents +will be copied from the uniform array @var{array}. +...@end deffn + +...@deffn {Scheme Procedure} %start-stack id thunk +...@deffnx {C Function} scm_sys_start_stack (id, thunk) +Call @var{thunk} on an evaluator stack tagged with @var{id}. +...@end deffn + +...@deffn {Scheme Procedure} guardian-destroyed? guardian +...@deffnx {C Function} scm_guardian_destroyed_p (guardian) +Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}. +...@end deffn + +...@deffn {Scheme Procedure} guardian-greedy? guardian +...@deffnx {C Function} scm_guardian_greedy_p (guardian) +Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}. +...@end deffn + +...@deffn {Scheme Procedure} destroy-guardian! guardian +...@deffnx {C Function} scm_destroy_guardian_x (guardian) +Destroys @var{guardian}, by making it impossible to put any more +objects in it or get any objects from it. It also unguards any +objects guarded by @var{guardian}. +...@end deffn + +...@deffn {Scheme Procedure} gc-dump +...@deffnx {C Function} scm_gc_dump () +Dump information about the garbage collector's internal data structures and memory usage to the standard output. +...@end deffn + +...@deffn {Scheme Procedure} gc-disable +...@deffnx {C Function} scm_gc_disable () +Disables the garbage collector. Nested calls are permitted. GC is re-enabled once @code{gc-enable} has been called the same number of times @code{gc-disable} was called. +...@end deffn + +...@deffn {Scheme Procedure} gc-enable +...@deffnx {C Function} scm_gc_enable () +Enables the garbage collector. +...@end deffn + +...@deffn {Scheme Procedure} make-generalized-vector type len [fill] +...@deffnx {C Function} scm_make_generalized_vector (type, len, fill) +Make a generalized vector +...@end deffn + +...@deffn {Scheme Procedure} set-primitive-generic! subr generic +...@deffnx {C Function} scm_set_primitive_generic_x (subr, generic) + +...@end deffn + +...@deffn {Scheme Procedure} nl-langinfo item [locale] +...@deffnx {C Function} scm_nl_langinfo (item, locale) +Return a string denoting locale information for @var{item} in the current locale or that specified by @var{locale}. The semantics and arguments are the same as those of the X/Open @code{nl_langinfo} function (@pxref{The Elegant and Fast Way, @code{nl_langinfo},, libc, The GNU C Library Reference Manual}). +...@end deffn + +...@deffn {Scheme Procedure} %warn-autocompilation-enabled +...@deffnx {C Function} scm_sys_warn_autocompilation_enabled () + +...@end deffn + +...@deffn {Scheme Procedure} make-syncase-macro type binding +...@deffnx {C Function} scm_make_syncase_macro (type, binding) +Return a @dfn{macro} that requires expansion by syntax-case. +While users should not call this function, it is useful to know +that syntax-case macros are represented as Guile primitive macros. +...@end deffn + +...@deffn {Scheme Procedure} make-extended-syncase-macro m type binding +...@deffnx {C Function} scm_make_extended_syncase_macro (m, type, binding) +Extend a core macro @var{m} with a syntax-case binding. +...@end deffn + +...@deffn {Scheme Procedure} syncase-macro-type m +...@deffnx {C Function} scm_syncase_macro_type (m) +Return the type of the macro @var{m}. +...@end deffn + +...@deffn {Scheme Procedure} syncase-macro-binding m +...@deffnx {C Function} scm_syncase_macro_binding (m) +Return the binding of the macro @var{m}. +...@end deffn + +...@deffn {Scheme Procedure} memoize-expression exp +...@deffnx {C Function} scm_memoize_expression (exp) +Memoize the expression @var{exp}. +...@end deffn + +...@deffn {Scheme Procedure} unmemoize-expression m +...@deffnx {C Function} scm_unmemoize_expression (m) +Unmemoize the memoized expression @var{m}. +...@end deffn + +...@deffn {Scheme Procedure} memoized-expression-typecode m +...@deffnx {C Function} scm_memoized_expression_typecode (m) +Return the typecode from the memoized expression @var{m}. +...@end deffn + +...@deffn {Scheme Procedure} memoized-expression-data m +...@deffnx {C Function} scm_memoized_expression_data (m) +Return the data from the memoized expression @var{m}. +...@end deffn + +...@deffn {Scheme Procedure} memoized-typecode sym +...@deffnx {C Function} scm_memoized_typecode (sym) +Return the memoized typecode corresponding to the symbol @var{sym}. +...@end deffn + +...@deffn {Scheme Procedure} memoize-variable-access! m mod +...@deffnx {C Function} scm_memoize_variable_access_x (m, mod) +Look up and cache the variable that @var{m} will access, returning the variable. +...@end deffn + +...@deffn {Scheme Procedure} module-local-variable module sym +...@deffnx {C Function} scm_module_local_variable (module, sym) +Return the variable bound to @var{sym} in @var{module}. Return @code{#f} is @var{sym} is not bound locally in @var{module}. +...@end deffn + +...@deffn {Scheme Procedure} module-variable module sym +...@deffnx {C Function} scm_module_variable (module, sym) +Return the variable bound to @var{sym} in @var{module}. This may be both a local variable or an imported variable. Return @code{#f} is @var{sym} is not bound in @var{module}. +...@end deffn + +...@deffn {Scheme Procedure} eval-closure-module eval_closure +...@deffnx {C Function} scm_eval_closure_module (eval_closure) +Return the module associated with this eval closure. +...@end deffn + +...@deffn {Scheme Procedure} module-transformer module +...@deffnx {C Function} scm_module_transformer (module) +Returns the syntax expander for the given module. +...@end deffn + +...@deffn {Scheme Procedure} module-public-interface module +...@deffnx {C Function} scm_module_public_interface (module) +Return the public interface of @var{module}. + +If @var{module} has no public interface, @code{#f} is returned. +...@end deffn + +...@deffn {Scheme Procedure} define! sym value +...@deffnx {C Function} scm_define (sym, value) +Define @var{sym} to be @var{value} in the current module.Returns the variable itself. Note that this is a procedure, not a macro. +...@end deffn + +...@deffn {Scheme Procedure} module-reverse-lookup module variable +...@deffnx {C Function} scm_module_reverse_lookup (module, variable) +Return the symbol under which @var{variable} is bound in @var{module} or @var{#f} if @var{variable} is not visible from @var{module}. If @var{module} is @code{#f}, then the pre-module obarray is used. +...@end deffn + +...@deffn {Scheme Procedure} cddr x +...@deffnx {C Function} scm_cddr (x) + +...@end deffn + +...@deffn {Scheme Procedure} make-promise thunk +...@deffnx {C Function} scm_make_promise (thunk) +Create a new promise object. + +...@code{make-promise} is a procedural form of @code{delay}. +These two expressions are equivalent: +...@lisp +(delay @var{exp}) +(make-promise (lambda () @var{exp})) +...@end lisp + +...@end deffn + +...@deffn {Scheme Procedure} %get-stack-size +...@deffnx {C Function} scm_sys_get_stack_size () +Return the current thread's C stack size (in Scheme objects). +...@end deffn + +...@deffn {Scheme Procedure} %string-dump str +...@deffnx {C Function} scm_sys_string_dump (str) +Returns an association list containing debugging information +for @var{str}. The association list has the following entri...@table @code +...@item string +The string itself. +...@item start +The start index of the string into its stringbuf +...@item length +The length of the string +...@item shared +If this string is a substring, it returns its parent string. +Otherwise, it returns @code{#f} +...@item read-only +...@code{#t} if the string is read-only +...@item stringbuf-chars +A new string containing this string's stringbuf's characters +...@item stringbuf-length +The number of characters in this stringbuf +...@item stringbuf-shared +...@code{#t} if this stringbuf is shared +...@item stringbuf-wide +...@code{#t} if this stringbuf's characters are stored in a +32-bit buffer, or @code{#f} if they are stored in an 8-bit +buffer +...@end table +...@end deffn + +...@deffn {Scheme Procedure} %symbol-dump sym +...@deffnx {C Function} scm_sys_symbol_dump (sym) +Returns an association list containing debugging information +for @var{sym}. The association list has the following entri...@table @code +...@item symbol +The symbol itself +...@item hash +Its hash value +...@item interned +...@code{#t} if it is an interned symbol +...@item stringbuf-chars +A new string containing this symbols's stringbuf's characters +...@item stringbuf-length +The number of characters in this stringbuf +...@item stringbuf-shared +...@code{#t} if this stringbuf is shared +...@item stringbuf-wide +...@code{#t} if this stringbuf's characters are stored in a +32-bit buffer, or @code{#f} if they are stored in an 8-bit +buffer +...@end table +...@end deffn + +...@deffn {Scheme Procedure} string-bytes-per-char string +...@deffnx {C Function} scm_string_bytes_per_char (string) +Return the bytes used to represent a character in @var{string}.This will return 1 or 4. +...@end deffn + +...@deffn {Scheme Procedure} uniform-vector-element-type v +...@deffnx {C Function} scm_uniform_vector_element_type (v) +Return the type of the elements in the uniform vector, @var{v}. +...@end deffn + +...@deffn {Scheme Procedure} uniform-vector-element-size v +...@deffnx {C Function} scm_uniform_vector_element_size (v) +Return the number of bytes allocated to each element in the +uniform vector, @var{v}. +...@end deffn + +...@deffn {Scheme Procedure} canonicalize-path path +...@deffnx {C Function} scm_canonicalize_path (path) +Return the canonical path of @var{path}. A canonical path has +no @code{.} or @code{..} components, nor any repeated path +separators (@code{/}) nor symlinks. + +Raises an error if any component of @var{path} does not exist. +...@end deffn + +...@deffn {Scheme Procedure} getrlimit resource +...@deffnx {C Function} scm_getrlimit (resource) +Get a resource limit for this process. @var{resource} identifies the resource, +either as an integer or as a symbol. For example, @code{(getrlimit 'stack)} +gets the limits associated with @code{RLIMIT_STACK}. + +...@code{getrlimit} returns two values, the soft and the hard limit. If no +limit is set for the resource in question, the returned limit will be @code{#f}. +...@end deffn + +...@deffn {Scheme Procedure} setrlimit resource soft hard +...@deffnx {C Function} scm_setrlimit (resource, soft, hard) +Set a resource limit for this process. @var{resource} identifies the resource, +either as an integer or as a symbol. @var{soft} and @var{hard} should be integers, +or @code{#f} to indicate no limit (i.e., @code{RLIM_INFINITY}). + +For example, @code{(setrlimit 'stack 150000 300000)} sets the @code{RLIMIT_STACK} +limit to 150 kilobytes, with a hard limit of 300 kB. +...@end deffn hooks/post-receive -- GNU Guile
