Exchange of manual enhancements between stable and unstable branches.

doc/ref/ChangeLog

@@ -1,8 +1,34 @@
+2002-03-27  Neil Jerram  <neil@ossau.uklinux.net>
+
+	* Makefile.am (guile_TEXINFOS): Remove appendices.texi, add
+	debugging.texi.
+
 2002-03-24  Neil Jerram  <neil@ossau.uklinux.net>
 
+	* scheme-data.texi (Pairs, Lists, Vectors, Records, Structures,
+	Arrays, Association Lists and Hash Tables): Move into a new
+	chapter ...
+	(Data Types): Renamed `Simple Data Types'; improvements ported
+	from unstable branch.
+	(Symbols and Variables): Renamed `Symbols'; improvements ported
+	from unstable branch.  `Variables' subsection moved to
+	scheme-modules.texi.
+	
+	* scheme-compound.texi: New file.
+	
+	* scheme-data.texi (Rx Regexps): Move section so that it becomes a
+	chapter in misc-modules.texi, in the Modules section of the manual.
+
+	* guile.texi (Top): Remove anything to do with appendices, as
+	there's no appendix material anymore.
+
+	* appendices.texi (Debugger User Interface): Moved to non-appendix
+	chapter in Part II; file renamed `debugging.texi'.
+
 	* guile.texi (Top), intro.texi (What is Guile?, The Basic Guile
 	Package): Use @ifnottex instead of @ifinfo, so that HTML
 	generation works correctly.
+	(Top): Move scheme-indices.texi after other indices at end.
 
 2002-03-20  Marius Vollmer  <mvo@zagadka.ping.de>
 

doc/ref/Makefile.am

@@ -31,7 +31,7 @@ guile_TEXINFOS = preface.texi intro.texi scheme-intro.texi \
 	scheme-translation.texi scheme-debug.texi deprecated.texi \
 	scheme-reading.texi scheme-indices.texi slib.texi posix.texi \
 	expect.texi scsh.texi tcltk.texi scripts.texi gh.texi scm.texi \
-	appendices.texi indices.texi script-getopt.texi data-rep.texi \
+	debugging.texi indices.texi script-getopt.texi data-rep.texi \
 	autoconf.texi autoconf-macros.texi tools.texi \
 	extend.texi repl-modules.texi srfi-modules.texi misc-modules.texi
 

doc/ref/appendices.texi

@@ -1,177 +0,0 @@
-@page
-@node Debugger User Interface
-@appendix Debugger User Interface
- 
-@c      --- The title and introduction of this appendix need to
-@c          distinguish this clearly from the chapter on the internal
-@c          debugging interface.
- 
-When debugging a program, programmers often find it helpful to examine
-the program's internal status while it runs: the values of internal
-variables, the choices made in @code{if} and @code{cond} statements, and
-so forth.  Guile Scheme provides a debugging interface that programmers
-can use to single-step through Scheme functions and examine symbol
-bindings.  This is different from the @ref{Debugging}, which permits
-programmers to debug the Guile interpreter itself.  Most programmers
-will be more interested in debugging their own Scheme programs than the
-interpreter which evaluates them.
- 
-[FIXME: should we include examples of traditional debuggers
-and explain why they can't be used to debug interpreted Scheme or Lisp?]
- 
-@menu
-* Single-Step::         Execute a program or function one step at a time.
-* Trace::               Print a report each time a given function is called.
-* Backtrace::           See a list of the statements that caused an error.
-* Stacks and Frames::	Examine the state of an interrupted program.
-@end menu
- 
-@node Single-Step
-@appendixsec Single-Step
- 
-@node Trace
-@appendixsec Trace
-
-When a function is @dfn{traced}, it means that every call to that
-function is reported to the user during a program run.  This can help a
-programmer determine whether a function is being called at the wrong
-time or with the wrong set of arguments.
-
-@defun trace function
-Enable debug tracing on @code{function}.  While a program is being run, Guile
-will print a brief report at each call to a traced function,
-advising the user which function was called and the arguments that were
-passed to it.
-@end defun
-
-@defun untrace function
-Disable debug tracing for @code{function}.
-@end defun
-
-Example:
-
-@lisp
-(define (rev ls)
-  (if (null? ls)
-      '()
-      (append (rev (cdr ls))
-              (cons (car ls) '())))) @result{} rev
-
-(trace rev) @result{} (rev)
-
-(rev '(a b c d e))
-@result{} [rev (a b c d e)]
-   |  [rev (b c d e)]
-   |  |  [rev (c d e)]
-   |  |  |  [rev (d e)]
-   |  |  |  |  [rev (e)]
-   |  |  |  |  |  [rev ()]
-   |  |  |  |  |  ()
-   |  |  |  |  (e)
-   |  |  |  (e d)
-   |  |  (e d c)
-   |  (e d c b)
-   (e d c b a)
-   (e d c b a)
-@end lisp
- 
-Note the way Guile indents the output, illustrating the depth of
-execution at each function call.  This can be used to demonstrate, for
-example, that Guile implements self-tail-recursion properly:
- 
-@lisp
-(define (rev ls sl)
-  (if (null? ls)
-      sl
-      (rev (cdr ls)
-           (cons (car ls) sl)))) @result{} rev
- 
-(trace rev) @result{} (rev)
- 
-(rev '(a b c d e) '())
-@result{} [rev (a b c d e) ()]
-   [rev (b c d e) (a)]
-   [rev (c d e) (b a)]
-   [rev (d e) (c b a)]
-   [rev (e) (d c b a)]
-   [rev () (e d c b a)]
-   (e d c b a)
-   (e d c b a)
-@end lisp
- 
-Since the tail call is effectively optimized to a @code{goto} statement,
-there is no need for Guile to create a new stack frame for each
-iteration.  Using @code{trace} here helps us see why this is so.
- 
-@node Backtrace
-@appendixsec Backtrace
-
-@node Stacks and Frames
-@appendixsec Stacks and Frames
-
-When a running program is interrupted, usually upon reaching an error or
-breakpoint, its state is represented by a @dfn{stack} of suspended
-function calls, each of which is called a @dfn{frame}.  The programmer
-can learn more about the program's state at the point of interruption by
-inspecting and modifying these frames.
-
-@deffn {Scheme Procedure} stack? obj
-Return @code{#t} if @var{obj} is a calling stack.
-@end deffn
-
-@deffn {Scheme Procedure} make-stack
-@end deffn
-
-@deffn syntax start-stack id exp
-Evaluate @var{exp} on a new calling stack with identity @var{id}.  If
-@var{exp} is interrupted during evaluation, backtraces will not display
-frames farther back than @var{exp}'s top-level form.  This macro is a
-way of artificially limiting backtraces and stack procedures, largely as
-a convenience to the user.
-@end deffn
-
-@deffn {Scheme Procedure} stack-id stack
-Return the identifier given to @var{stack} by @code{start-stack}.
-@end deffn
-
-@deffn {Scheme Procedure} stack-ref
-@end deffn
-
-@deffn {Scheme Procedure} stack-length
-@end deffn
-
-@deffn {Scheme Procedure} frame?
-@end deffn
-
-@deffn {Scheme Procedure} last-stack-frame
-@end deffn
-
-@deffn {Scheme Procedure} frame-number
-@end deffn
-
-@deffn {Scheme Procedure} frame-source
-@end deffn
-
-@deffn {Scheme Procedure} frame-procedure
-@end deffn
-
-@deffn {Scheme Procedure} frame-arguments
-@end deffn
-
-@deffn {Scheme Procedure} frame-previous
-@end deffn
-
-@deffn {Scheme Procedure} frame-next
-@end deffn
-
-@deffn {Scheme Procedure} frame-real?
-@end deffn
-
-@deffn {Scheme Procedure} frame-procedure?
-@end deffn
-
-@deffn {Scheme Procedure} frame-evaluating-args?
-@end deffn
-
-@deffn {Scheme Procedure} frame-overflow
-@end deffn

doc/ref/guile.texi

@@ -94,7 +94,7 @@ by the Free Software Foundation.
 @sp 10
 @comment The title is printed in a large font.
 @title Guile Reference Manual
-@subtitle $Id: guile.texi,v 1.2.2.12 2002-03-24 19:07:08 ossau Exp $
+@subtitle $Id: guile.texi,v 1.2.2.13 2002-03-27 21:48:16 ossau Exp $
 @subtitle For use with Guile @value{VERSION}
 
 @c AUTHORS
@@ -211,7 +211,8 @@ Part II: Guile Scheme
 
 * Scheme Intro::                Introduction to Guile Scheme.
 * Basic Ideas::                 Basic ideas in Scheme.
-* Data Types::                  Data types for generic use.
+* Simple Data Types::           Numbers, strings, booleans and so on.
+* Compound Data Types::         Data types for holding other data.
 * Procedures and Macros::       Procedures and macros.
 * Utility Functions::           General utility functions.
 * Binding Constructs::          Definitions and variable bindings.
@@ -226,6 +227,7 @@ Part II: Guile Scheme
 * Translation::                 Support for translating other languages.
 * Debugging::                   Internal debugging interface.
 * Deprecated::                  Features that are planned to disappear.
+* Debugger User Interface::
 * Autoconf Support::            Guile-specific configure.in macros.
 * Miscellaneous Tools::         Snarfing, linting, etc.
 * Further Reading::             Where to find out more about Scheme programming.
@@ -239,6 +241,7 @@ Part III: Guile Modules
 * Value History::               Maintaining a value history in the REPL.
 * Pretty Printing::             Nicely formatting Scheme objects for output.
 * Formatted Output::            The @code{format} procedure.
+* Rx Regexps::                  The Rx regular expression library.
 * Expect::			Controlling interactive programs with Guile.
 * The Scheme shell (scsh)::     Using scsh interfaces in Guile.
 @c * Tcl/Tk Interface::
@@ -255,10 +258,6 @@ Part V: Extending Applications Using Guile
 * Scheme Primitives::           Writing Scheme primitives in C.
 * GH::                          The deprecated GH interface.
 
-Appendices
-
-* Debugger User Interface::
-
 Indices
 
 * Concept Index::
@@ -288,6 +287,7 @@ Indices
 @include scheme-intro.texi
 @include scheme-ideas.texi
 @include scheme-data.texi
+@include scheme-compound.texi
 @include scheme-procedures.texi
 @include scheme-utility.texi
 @include scheme-binding.texi
@@ -302,10 +302,10 @@ Indices
 @include scheme-translation.texi
 @include scheme-debug.texi
 @include deprecated.texi
+@include debugging.texi
 @include autoconf.texi
 @include tools.texi
 @include scheme-reading.texi
-@include scheme-indices.texi
 
 @iftex
 @page
@@ -341,21 +341,13 @@ Indices
 @include scm.texi
 @include gh.texi
 
-@c Appendices
-@iftex
-@page
-@unnumbered{Appendices}
-@end iftex
-
-@include appendices.texi
-
-@c Indices
 @iftex
 @page
 @unnumbered{Indices}
 @end iftex
 
 @include indices.texi
+@include scheme-indices.texi
 
 @contents
 

doc/ref/misc-modules.texi

@@ -287,6 +287,140 @@ large version of @code{format} by default, so that the start-up time
 of the interpreter is not unnecessarily increased.
 
 
+@page
+@node Rx Regexps
+@chapter The Rx Regular Expression Library
+
+[FIXME: this is taken from Gary and Mark's quick summaries and should be
+reviewed and expanded.  Rx is pretty stable, so could already be done!]
+
+@cindex rx
+@cindex finite automaton
+
+The @file{guile-lang-allover} package provides an interface to Tom
+Lord's Rx library (currently only to POSIX regular expressions).  Use of
+the library requires a two step process: compile a regular expression
+into an efficient structure, then use the structure in any number of
+string comparisons.
+
+For example, given the regular expression @samp{abc.} (which matches any
+string containing @samp{abc} followed by any single character):
+
+@smalllisp
+guile> @kbd{(define r (regcomp "abc."))}
+guile> @kbd{r}
+#<rgx abc.>
+guile> @kbd{(regexec r "abc")}
+#f
+guile> @kbd{(regexec r "abcd")}
+#((0 . 4))
+guile>
+@end smalllisp
+
+The definitions of @code{regcomp} and @code{regexec} are as follows:
+
+@deffn {Scheme Procedure} regcomp pattern [flags]
+Compile the regular expression pattern using POSIX rules.  Flags is
+optional and should be specified using symbolic names:
+@defvar REG_EXTENDED
+use extended POSIX syntax
+@end defvar
+@defvar REG_ICASE
+use case-insensitive matching
+@end defvar
+@defvar REG_NEWLINE
+allow anchors to match after newline characters in the
+string and prevents @code{.} or @code{[^...]} from matching newlines.
+@end defvar
+
+The @code{logior} procedure can be used to combine multiple flags.
+The default is to use
+POSIX basic syntax, which makes @code{+} and @code{?}  literals and @code{\+}
+and @code{\?}
+operators.  Backslashes in @var{pattern} must be escaped if specified in a
+literal string e.g., @code{"\\(a\\)\\?"}.
+@end deffn
+
+@deffn {Scheme Procedure} regexec regex string [match-pick] [flags]
+Match @var{string} against the compiled POSIX regular expression
+@var{regex}.
+@var{match-pick} and @var{flags} are optional.  Possible flags (which can be
+combined using the logior procedure) are:
+
+@defvar REG_NOTBOL
+The beginning of line operator won't match the beginning of
+@var{string} (presumably because it's not the beginning of a line)
+@end defvar
+
+@defvar REG_NOTEOL
+Similar to REG_NOTBOL, but prevents the end of line operator
+from matching the end of @var{string}.
+@end defvar
+
+If no match is possible, regexec returns #f.  Otherwise @var{match-pick}
+determines the return value:
+
+@code{#t} or unspecified: a newly-allocated vector is returned,
+containing pairs with the indices of the matched part of @var{string} and any
+substrings.
+
+@code{""}: a list is returned: the first element contains a nested list
+with the matched part of @var{string} surrounded by the the unmatched parts.
+Remaining elements are matched substrings (if any).  All returned
+substrings share memory with @var{string}.
+
+@code{#f}: regexec returns #t if a match is made, otherwise #f.
+
+vector: the supplied vector is returned, with the first element replaced
+by a pair containing the indices of the matched portion of @var{string} and
+further elements replaced by pairs containing the indices of matched
+substrings (if any).
+
+list: a list will be returned, with each member of the list
+specified by a code in the corresponding position of the supplied list:
+
+a number: the numbered matching substring (0 for the entire match).
+
+@code{#\<}: the beginning of @var{string} to the beginning of the part matched
+by regex.
+
+@code{#\>}: the end of the matched part of @var{string} to the end of
+@var{string}.
+
+@code{#\c}: the "final tag", which seems to be associated with the "cut
+operator", which doesn't seem to be available through the posix
+interface.
+
+e.g., @code{(list #\< 0 1 #\>)}.  The returned substrings share memory with
+@var{string}.
+@end deffn
+
+Here are some other procedures that might be used when using regular
+expressions:
+
+@deffn {Scheme Procedure} compiled-regexp? obj
+Test whether obj is a compiled regular expression.
+@end deffn
+
+@deffn {Scheme Procedure} regexp->dfa regex [flags]
+@end deffn
+
+@deffn {Scheme Procedure} dfa-fork dfa
+@end deffn
+
+@deffn {Scheme Procedure} reset-dfa! dfa
+@end deffn
+
+@deffn {Scheme Procedure} dfa-final-tag dfa
+@end deffn
+
+@deffn {Scheme Procedure} dfa-continuable? dfa
+@end deffn
+
+@deffn {Scheme Procedure} advance-dfa! dfa string
+@end deffn
+
+
 @c Local Variables:
 @c TeX-master: "guile.texi"
 @c End:

doc/ref/scheme-compound.texi

@@ -27,8 +27,6 @@ values can be looked up within them.
 @section Pairs
 @tpindex Pairs
 
-@c FIXME::martin: Review me!
-
 Pairs are used to combine two Scheme objects into one compound object.
 Hence the name: A pair stores a pair of objects.
 
@@ -133,8 +131,6 @@ by @code{set-cdr!} is unspecified.
 @section Lists
 @tpindex Lists
 
-@c FIXME::martin: Review me!
-
 A very important data type in Scheme---as well as in all other Lisp
 dialects---is the data type @dfn{list}.@footnote{Strictly speaking,
 Scheme does not have a real datatype @dfn{list}.  Lists are made up of
@@ -173,8 +169,6 @@ or a pair which has a list in its cdr.
 @node List Syntax
 @subsection List Read Syntax
 
-@c FIXME::martin: Review me!
-
 The syntax for lists is an opening parentheses, then all the elements of
 the list (separated by whitespace) and finally a closing
 parentheses.@footnote{Note that there is no separation character between
@@ -208,8 +202,6 @@ applications (@pxref{Simple Invocation}).
 @node List Predicates
 @subsection List Predicates
 
-@c FIXME::martin: Review me!
-
 Often it is useful to test whether a given Scheme object is a list or
 not.  List-processing procedures could use this information to test
 whether their input is valid, or they could do different things
@@ -279,8 +271,6 @@ use the procedure @code{copy-tree} (@pxref{Copying}).
 @node List Selection
 @subsection List Selection
 
-@c FIXME::martin: Review me!
-
 These procedures are used to get some information about a list, or to
 retrieve one or more elements of a list.
 
@@ -323,8 +313,6 @@ return it.
 @node Append/Reverse
 @subsection Append and Reverse
 
-@c FIXME::martin: Review me!
-
 @code{append} and @code{append!} are used to concatenate two or more
 lists in order to form a new list.  @code{reverse} and @code{reverse!}
 return lists with the same elements as their arguments, but in reverse
@@ -356,7 +344,7 @@ if the last argument is not a proper list.
 @deffn {Scheme Procedure} append! . lists
 @deffnx {C Function} scm_append_x (lists)
 A destructive version of @code{append} (@pxref{Pairs and
-Lists,,,r5rs, The Revised^5 Report on Scheme}).  The cdr field
+lists,,,r5rs, The Revised^5 Report on Scheme}).  The cdr field
 of each list's final pair is changed to point to the head of
 the next list, so no consing is performed.  Return a pointer to
 the mutated list.
@@ -372,7 +360,7 @@ in reverse order.
 @c NJFIXME explain new_tail
 @deffn {Scheme Procedure} reverse! lst [new_tail]
 @deffnx {C Function} scm_reverse_x (lst, new_tail)
-A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r5rs,
+A destructive version of @code{reverse} (@pxref{Pairs and lists,,,r5rs,
 The Revised^5 Report on Scheme}).  The cdr of each cell in @var{lst} is
 modified to point to the previous list element.  Return a pointer to the
 head of the reversed list.
@@ -463,8 +451,6 @@ Like @code{delete!}, but only deletes the first occurrence of
 @node List Searching
 @subsection List Searching
 
-@c FIXME::martin: Review me!
-
 The following procedures search lists for particular elements.  They use
 different comparison predicates for comparing list elements with the
 object to be searched.  When they fail, they return @code{#f}, otherwise
@@ -509,18 +495,21 @@ high level at all?  Maybe these docs should be relegated to a "Guile
 Internals" node or something. -twp]
 
 @deffn {Scheme Procedure} sloppy-memq x lst
+@deffnx {C Function} scm_sloppy_memq (x, lst)
 This procedure behaves like @code{memq}, but does no type or error checking.
 Its use is recommended only in writing Guile internals,
 not for high-level Scheme programs.
 @end deffn
 
 @deffn {Scheme Procedure} sloppy-memv x lst
+@deffnx {C Function} scm_sloppy_memv (x, lst)
 This procedure behaves like @code{memv}, but does no type or error checking.
 Its use is recommended only in writing Guile internals,
 not for high-level Scheme programs.
 @end deffn
 
 @deffn {Scheme Procedure} sloppy-member x lst
+@deffnx {C Function} scm_sloppy_member (x, lst)
 This procedure behaves like @code{member}, but does no type or error checking.
 Its use is recommended only in writing Guile internals,
 not for high-level Scheme programs.
@@ -529,8 +518,6 @@ not for high-level Scheme programs.
 @node List Mapping
 @subsection List Mapping
 
-@c FIXME::martin: Review me!
-
 List processing is very convenient in Scheme because the process of
 iterating over the elements of a list can be highly abstracted.  The
 procedures in this section are the most basic iterating procedures for
@@ -565,11 +552,6 @@ return value is not specified.
 @section Vectors
 @tpindex Vectors
 
-@c FIXME::martin: Review me!
-
-@c FIXME::martin: Should the subsections of this section be nodes
-@c of their own, or are the resulting nodes too short, then?
-
 Vectors are sequences of Scheme objects.  Unlike lists, the length of a
 vector, once the vector is created, cannot be changed.  The advantage of
 vectors over lists is that the time required to access one element of a vector
@@ -893,7 +875,7 @@ The field holds a Scheme value and is GC protected.  When a structure is
 created with this type of field, the field is initialized to refer to
 the structure's own handle.  This kind of field is mainly useful when
 mixing Scheme and C code in which the C code may need to compute a
-structure's handle given only the address of its malloc-ed data.
+structure's handle given only the address of its malloc'd data.
 @end itemize
 
 
@@ -1713,19 +1695,19 @@ because association lists are so useful, Guile also provides specific
 procedures for manipulating them.
 
 @menu
-* Alist Key Equality::          
+* Alist Key Equality::
-* Adding or Setting Alist Entries::  
+* Adding or Setting Alist Entries::
-* Retrieving Alist Entries::    
+* Retrieving Alist Entries::
-* Removing Alist Entries::      
+* Removing Alist Entries::
-* Sloppy Alist Functions::      
+* Sloppy Alist Functions::
-* Alist Example::               
+* Alist Example::
 @end menu
 
 @node Alist Key Equality
 @subsubsection Alist Key Equality
 
 All of Guile's dedicated association list procedures, apart from
-@code{acons}, come in three flavors, depending on the level of equality
+@code{acons}, come in three flavours, depending on the level of equality
 that is required to decide whether an existing key in the association
 list is the same as the key that the procedure call uses to identify the
 required entry.
@@ -1864,7 +1846,7 @@ function is @emph{not} destructive; @var{alist} is not modified.
 @deffnx {C Function} scm_assq_set_x (alist, key, val)
 @deffnx {C Function} scm_assv_set_x (alist, key, val)
 @deffnx {C Function} scm_assoc_set_x (alist, key, val)
-Re-associate @var{key} in @var{alist} with @var{value}: find any existing
+Reassociate @var{key} in @var{alist} with @var{value}: find any existing
 @var{alist} entry for @var{key} and associate it with the new
 @var{value}.  If @var{alist} does not contain an entry for @var{key},
 add a new one.  Return the (possibly new) alist.

doc/ref/scheme-modules.texi

@@ -32,10 +32,14 @@ designed languages: ML, Python, Perl, and Modula 3 all allow the
 clutter the global name space.
 @cindex name space - private
 
+In addition, Guile offers variables as first-class objects.  They can
+be used for interacting with the module system.
+
 @menu
 * Scheme and modules::          How modules are handled in standard Scheme.
 * The Guile module system::     How Guile does it.
 * Dynamic Libraries::           Loading libraries of compiled code at run time.
+* Variables::                   First-class variables.
 @end menu
 
 
@@ -624,6 +628,67 @@ the Guile contrib archive to make @file{libffi} accessible from Guile.
 
 XXX - document @code{load-extension}, @code{scm_register_extension}
 
+
+@node Variables
+@section Variables
+@tpindex Variables
+
+Variables are objects with two fields.  They contain a value and they
+can contain a symbol, which is the name of the variable.  A variable is
+said to be bound if it does not contain the object denoting unbound
+variables in the value slot.
+
+Variables do not have a read syntax, they have to be created by calling
+one of the constructor procedures @code{make-variable} or
+@code{make-undefined-variable} or retrieved by @code{builtin-variable}.
+
+First-class variables are especially useful for interacting with the
+current module system (@pxref{The Guile module system}).
+
+@deffn {Scheme Procedure} builtin-variable name
+@deffnx {C Function} scm_builtin_variable (name)
+Return the built-in variable with the name @var{name}.
+@var{name} must be a symbol (not a string).
+Then use @code{variable-ref} to access its value.
+@end deffn
+
+@deffn {Scheme Procedure} make-undefined-variable
+@deffnx {C Function} scm_make_undefined_variable ()
+Return a variable that is initially unbound.
+@end deffn
+
+@deffn {Scheme Procedure} make-variable init
+@deffnx {C Function} scm_make_variable (init)
+Return a variable initialized to value @var{init}.
+@end deffn
+
+@deffn {Scheme Procedure} variable-bound? var
+@deffnx {C Function} scm_variable_bound_p (var)
+Return @code{#t} iff @var{var} is bound to a value.
+Throws an error if @var{var} is not a variable object.
+@end deffn
+
+@deffn {Scheme Procedure} variable-ref var
+@deffnx {C Function} scm_variable_ref (var)
+Dereference @var{var} and return its value.
+@var{var} must be a variable object; see @code{make-variable}
+and @code{make-undefined-variable}.
+@end deffn
+
+@deffn {Scheme Procedure} variable-set! var val
+@deffnx {C Function} scm_variable_set_x (var, val)
+Set the value of the variable @var{var} to @var{val}.
+@var{var} must be a variable object, @var{val} can be any
+value. Return an unspecified value.
+@end deffn
+
+@deffn {Scheme Procedure} variable? obj
+@deffnx {C Function} scm_variable_p (obj)
+Return @code{#t} iff @var{obj} is a variable object, else
+return @code{#f}.
+@end deffn
+
+
 @c Local Variables:
 @c TeX-master: "guile.texi"
 @c End:

guile-config/ChangeLog

@@ -1,3 +1,7 @@
+2002-03-24  Neil Jerram  <neil@ossau.uklinux.net>
+
+	* guile.m4 (GUILE_PROGS): In docstring, change `are' to `is'.
+
 2002-03-03  Rob Browning  <rlb@defaultvalue.org>
 
 	* guile-config.in (build-link): don't output -L/usr/lib.

guile-config/guile.m4

@@ -67,7 +67,7 @@
 # This macro looks for programs @code{guile}, @code{guile-config} and
 # @code{guile-tools}, and sets variables @var{GUILE}, @var{GUILE_CONFIG} and
 # @var{GUILE_TOOLS}, to their paths, respectively.  If either of the first two
-# are not found, signal error.
+# is not found, signal error.
 #
 # The variables are marked for substitution, as by @code{AC_SUBST}.
 #

scripts/ChangeLog

@@ -1,3 +1,8 @@
+2002-03-24  Neil Jerram  <neil@ossau.uklinux.net>
+
+	* snarf-guile-m4-docs (display-texi): Strip off `# ' from start of
+	docstring lines if possible, rather than just `#'.
+
 2002-03-14  Neil Jerram  <neil@ossau.uklinux.net>
 
 	These changes add a @deffnx C function declaration and function

scripts/snarf-guile-m4-docs

@@ -43,9 +43,12 @@ exec ${GUILE-guile} -l $0 -c "(apply $main (cdr (command-line)))" "$@"
 (define (display-texi lines)
   (display "@deffn {Autoconf Macro}")
   (for-each (lambda (line)
-              (display (if (string=? "#" (substring line 0 1))
+              (display (cond ((and (>= (string-length line) 2)
-                           (substring line 1)
+				   (string=? "# " (substring line 0 2)))
-                           line))
+			      (substring line 2))
+			     ((string=? "#" (substring line 0 1))
+			      (substring line 1))
+			     (else line)))
               (newline))
             lines)
   (display "@end deffn")