
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                                                                                                                                                                                                   
(acons key value alist)
Adds a new key-value pair to @var{alist}.  A new pair is
created whose car is @var{key} and whose cdr is @var{value}, and the
pair is consed onto @var{alist}, and the new list is returned.  This
function is @emph{not} destructive; @var{alist} is not modified.
[alist.c:61]

(sloppy-assq key alist)
Behaves like @code{assq} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:84]

(sloppy-assv key alist)
Behaves like @code{assv} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:102]

(sloppy-assoc key alist)
Behaves like @code{assoc} but does not do any error checking.
Recommended only for use in Guile internals.
[alist.c:120]

(assq key alist)
@deffnx primitive assv key alist
@deffnx primitive assoc key alist
Fetches the entry in @var{alist} that is associated with @var{key}.  To
decide whether the argument @var{key} matches a particular entry in
@var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
cannot be found in @var{alist} (according to whichever equality
predicate is in use), then @code{#f} is returned.  These functions
return the entire alist entry found (i.e. both the key and the value).
[alist.c:147]

(assv key alist)
Behaves like @code{assq} but uses @code{eqv?} for key comparison.
[alist.c:165]

(assoc key alist)
Behaves like @code{assq} but uses @code{equal?} for key comparison.
[alist.c:183]

(assq-ref alist key)
@deffnx primitive assv-ref alist key
@deffnx primitive assoc-ref alist key
Like @code{assq}, @code{assv} and @code{assoc}, except that only the
value associated with @var{key} in @var{alist} is returned.  These
functions are equivalent to

@lisp
(let ((ent (@var{associator} @var{key} @var{alist})))
  (and ent (cdr ent)))
@end lisp

where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
[alist.c:212]

(assv-ref alist key)
Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
[alist.c:229]

(assoc-ref alist key)
Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
[alist.c:246]

(assq-set! alist key val)
@deffnx primitive assv-set! alist key value
@deffnx primitive assoc-set! alist key value
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.

These functions do not attempt to verify the structure of @var{alist},
and so may cause unusual results if passed an object that is not an
association list.
[alist.c:275]

(assv-set! alist key val)
Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
[alist.c:293]

(assoc-set! alist key val)
Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
[alist.c:311]

(assq-remove! alist key)
@deffnx primitive assv-remove! alist key
@deffnx primitive assoc-remove! alist key
Delete any entry in @var{alist} associated with @var{key}, and return
the resulting alist.
[alist.c:335]

(assv-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
[alist.c:353]

(assoc-remove! alist key)
Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
[alist.c:371]

(make-arbiter name)
Returns an object of type arbiter and name name. Its state is initially unlocked.
Arbiters are a way to achieve process synchronization.
[arbiters.c:84]

(try-arbiter arb)
Returns #t and locks arbiter if arbiter was unlocked. Otherwise, returns #f.
[arbiters.c:93]

(release-arbiter arb)
Returns #t and unlocks arbiter if arbiter was locked. Otherwise, returns #f.
[arbiters.c:113]

(async thunk)
[async.c:305]

(system-async thunk)
[async.c:314]

(async-mark a)
[async.c:331]

(system-async-mark a)
[async.c:347]

(run-asyncs list_of_a)
[async.c:367]

(noop args)
[async.c:400]

(unmask-signals)
[async.c:480]

(mask-signals)
[async.c:491]

(display-error stack port subr message args rest)
[backtrace.c:226]

(display-application frame port indent)
[backtrace.c:367]

(display-backtrace stack port first depth)
[backtrace.c:581]

(backtrace)
[backtrace.c:603]

(not x)
Return #t iff X is #f, else return #f.
[boolean.c:57]

(boolean? obj)
Return #t iff OBJ is either #t or #f.
[boolean.c:67]

(char? x)
Return #t iff X is a character, else #f.
[chars.c:57]

(char=? x y)
Return #t iff X is the same character as Y, else #f.
[chars.c:66]

(char<? x y)
Return #t iff X is less than Y in the Ascii sequence, else #f.
[chars.c:78]

(char<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence, else #f.
[chars.c:89]

(char>? x y)
Return #t iff X is greater than Y in the Ascii sequence, else #f.
[chars.c:100]

(char>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence, else #f.
[chars.c:111]

(char-ci=? x y)
Return #t iff X is the same character as Y ignoring case, else #f.
[chars.c:122]

(char-ci<? x y)
Return #t iff X is less than Y in the Ascii sequence ignoring case, else #f.
[chars.c:133]

(char-ci<=? x y)
Return #t iff X is less than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:144]

(char-ci>? x y)
Return #t iff X is greater than Y in the Ascii sequence ignoring case, else #f.
[chars.c:155]

(char-ci>=? x y)
Return #t iff X is greater than or equal to Y in the Ascii sequence ignoring case, else #f.
[chars.c:166]

(char-alphabetic? chr)
Return #t iff CHR is alphabetic, else #f.
Alphabetic means the same thing as the isalpha C library function.
[chars.c:179]

(char-numeric? chr)
Return #t iff CHR is numeric, else #f.
Numeric means the same thing as the isdigit C library function.
[chars.c:190]

(char-whitespace? chr)
Return #t iff CHR is whitespace, else #f.
Whitespace means the same thing as the isspace C library function.
[chars.c:201]

(char-upper-case? chr)
Return #t iff CHR is uppercase, else #f.
Uppercase means the same thing as the isupper C library function.
[chars.c:214]

(char-lower-case? chr)
Return #t iff CHR is lowercase, else #f.
Lowercase means the same thing as the islower C library function.
[chars.c:226]

(char-is-both? chr)
Return #t iff CHR is either uppercase or lowercase, else #f.
Uppercase and lowercase are as defined by the isupper and islower
C library functions.
[chars.c:240]

(char->integer chr)
Return the number corresponding to ordinal position of CHR in the Ascii sequence.
[chars.c:253]

(integer->char n)
Return the character at position N in the Ascii sequence.
[chars.c:265]

(char-upcase chr)
Return the uppercase character version of CHR.
[chars.c:276]

(char-downcase chr)
Return the lowercase character version of CHR.
[chars.c:287]

(malloc-stats)
Return an alist ((WHAT . N) ...) describing number of malloced objects.
WHAT is the second argument to scm_must_malloc, N is the number of objects
of that type currently allocated.
[debug-malloc.c:231]

(debug-options-interface setting)
[debug.c:78]

(with-traps thunk)
[debug.c:126]

(memoized? obj)
[debug.c:167]

(unmemoize m)
[debug.c:369]

(memoized-environment m)
[debug.c:379]

(procedure-name proc)
[debug.c:389]

(procedure-source proc)
[debug.c:415]

(procedure-environment proc)
[debug.c:450]

(local-eval exp env)
Evaluate @var{exp} in its environment.  If @var{env} is supplied,
it is the environment in which to evaluate @var{exp}.  Otherwise,
@var{exp} must be a memoized code object (in which case, its environment
is implicit).
[debug.c:483]

(debug-object? obj)
[debug.c:570]

(c-registered-modules)
Return a list of the object code modules that have been imported into
the current Guile process.  Each element of the list is a pair whose
car is the name of the module, and whose cdr is the function handle
for that module's initializer function.  The name is the string that
has been passed to scm_register_module_xxx.
[dynl.c:185]

(c-clear-registered-modules)
Destroy the list of modules registered with the current Guile process.
The return value is unspecified.  @strong{Warning:} this function does
not actually unlink or deallocate these modules, but only destroys the
records of which modules have been loaded.  It should therefore be used
only by module bookkeeping operations.
[dynl.c:206]

(dynamic-link fname)
Open the dynamic library @var{library-file}.  A library handle
representing the opened library is returned; this handle should be used
as the @var{lib} argument to the following functions.
[dynl.c:357]

(dynamic-object? obj)
Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
otherwise.
[dynl.c:372]

(dynamic-unlink dobj)
Unlink the library represented by @var{library-handle},
and remove any imported symbols from the address space.
GJB:FIXME:DOC: 2nd version below:
Unlink the indicated object file from the application.  The
argument @var{dynobj} must have been obtained by a call to
@code{dynamic-link}.  After @code{dynamic-unlink} has been
called on @var{dynobj}, its content is no longer accessible.
[dynl.c:388]

(dynamic-func symb dobj)
Import the symbol @var{func} from @var{lib} (a dynamic library handle).
A @dfn{function handle} representing the imported function is returned.
GJB:FIXME:DOC: 2nd version below
Search the C function indicated by @var{function} (a string or symbol)
in @var{dynobj} and return some Scheme object that can later be used
with @code{dynamic-call} to actually call this function.  Right now,
these Scheme objects are formed by casting the address of the function
to @code{long} and converting this number to its Scheme representation.

Regardless whether your C compiler prepends an underscore @samp{_} to
the global names in a program, you should @strong{not} include this
underscore in @var{function}.  Guile knows whether the underscore is
needed or not and will add it when necessary.

[dynl.c:420]

(dynamic-call func dobj)
Call @var{lib-thunk}, a procedure of no arguments.  If @var{lib-thunk}
is a string, it is assumed to be a symbol found in the dynamic library
@var{lib} and is fetched with @code{dynamic-func}.  Otherwise, it should
be a function handle returned by a previous call to @code{dynamic-func}.
The return value is unspecified.
GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}.  The
function is passed no arguments and its return value is ignored.  When
@var{function} is something returned by @code{dynamic-func}, call that
function and ignore @var{dynobj}.  When @var{function} is a string (or
symbol, etc.), look it up in @var{dynobj}; this is equivalent to

@smallexample
(dynamic-call (dynamic-func @var{function} @var{dynobj} #f))
@end smallexample

Interrupts are deferred while the C function is executing (with
@code{SCM_DEFER_INTS}/@code{SCM_ALLOW_INTS}).
[dynl.c:460]

(dynamic-args-call func dobj args)
Call @var{proc}, a dynamically loaded function, passing it the argument
list @var{args} (a list of strings).  As with @code{dynamic-call},
@var{proc} should be either a function handle or a string, in which case
it is first fetched from @var{lib} with @code{dynamic-func}.

@var{proc} is assumed to return an integer, which is used as the return
value from @code{dynamic-args-call}.

GJB:FIXME:DOC 2nd version below
Call the C function indicated by @var{function} and @var{dynobj}, just
like @code{dynamic-call}, but pass it some arguments and return its
return value.  The C function is expected to take two arguments and
return an @code{int}, just like @code{main}:

@smallexample
int c_func (int argc, char **argv);
@end smallexample

The parameter @var{args} must be a list of strings and is converted into
an array of @code{char *}.  The array is passed in @var{argv} and its
size in @var{argc}.  The return value is converted to a Scheme number
and returned from the call to @code{dynamic-args-call}.

[dynl.c:495]

(dynamic-wind thunk1 thunk2 thunk3)
All three arguments must be 0-argument procedures.

@var{in-guard} is called, then @var{thunk}, then @var{out-guard}.

If, any time during the execution of @var{thunk}, the continuation
of the @code{dynamic-wind} expression is escaped non-locally, @var{out-guard}
is called.   If the continuation of the dynamic-wind is re-entered,
@var{in-guard} is called.   Thus @var{in-guard} and @var{out-guard} may
be called any number of times.

@example
(define x 'normal-binding)
@result{} x

(define a-cont  (call-with-current-continuation
		  (lambda (escape)
		     (let ((old-x x))
		       (dynamic-wind
			  ;; in-guard:
			  ;;
			  (lambda () (set! x 'special-binding))

			  ;; thunk
			  ;;
		 	  (lambda () (display x) (newline)
				     (call-with-current-continuation escape)
				     (display x) (newline)
				     x)

			  ;; out-guard:
			  ;;
			  (lambda () (set! x old-x)))))))

;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont

x
@result{} normal-binding

(a-cont #f)
;; Prints:
special-binding
;; Evaluates to:
@result{} a-cont  ;; the value of the (define a-cont...)

x
@result{} normal-binding

a-cont
@result{} special-binding
@end example
[dynwind.c:117]

(eq? x y)
Return #t iff X references the same object as Y.
`eq?' is similar to `eqv?' except that in some cases
it is capable of discerning distinctions finer than
those detectable by `eqv?'.
[eq.c:65]

(eqv? x y)
The `eqv?' procedure defines a useful equivalence relation on objects.
Briefly, it returns #t if X and Y should normally be
regarded as the same object.  This relation is left
slightly open to interpretation, but works for comparing
immediate integers, characters, and inexact numbers.
[eq.c:79]

(equal? x y)
Return #t iff X and Y are recursively `eqv?' equivalent.
`equal?' recursively compares the contents of pairs, vectors, and
strings, applying `eqv?' on other objects such as numbers and
symbols.  A rule of thumb is that objects are generally `equal?'
if they print the same.  `Equal?' may fail to terminate if its
arguments are circular data structures.
[eq.c:128]

(scm-error key subr message args rest)
Raise an error with key @var{key}.  @var{subr} can be a string naming
the procedure associated with the error, or @code{#f}.  @var{message}
is the error message string, 	  (lambda (text cont?)
	    (if (not cont?)
		(set! completions
		      (map symbol->string
			   (apropos-internal
			    (string-append "^" (regexp-quote text))))))
	    (if (null? completions)
		#f
		(let ((retval (car completions)))
		  (begin (set! completions (cdr completions))
			 retval))))))

      (set! *readline-completion-function* apropos-completion-function)
      ))

(define-public (activate-readline)
  (if (and (isatty? (current-input-port))
	   (not (and (module-defined? the-root-module
				      'use-emacs-interface)
		     use-emacs-interface)))
      (let ((read-hook (lambda () (run-hook before-read-hook))))
	(set-current-input-port (readline-port))
	(set! repl-reader
	      (lambda (prompt)
		(dynamic-wind
		    (lambda ()
		      (set-readline-prompt! prompt "... ")
		      (set-readline-read-hook! read-hook))
		    (lambda () (read))
		    (lambda ()
		      (set-readline-prompt! "" "")
		      (set-readline-read-hook! #f)))))
	(set! (using-readline?) #t))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ./usr/share/guile/guile-procedures.txt                                                              0100644 0000000 0000000 00000437543 07450443522 016776  0                                                                                                    ustar   root                            root                                             