
(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, possibly containing @code{~S} and @code{~A}
escapes.  When an error is reported, these are replaced by formating the
corresponding members of @var{args}: @code{~A} (was @code{%s}) formats using @code{display}
and @code(~S) (was @code{%S}) formats using @code{write}.  @var{data} is a
list or @code{#f} depending on @var{key}: if @var{key} is
@code{system-error} then it should be a list
containing the Unix @code{errno} value;  If @var{key} is @code{signal} then
it should be a list containing the Unix signal number; otherwise it
will usually be @code{#f}.
[error.c:114]

(strerror err)
Returns the Unix error message corresponding to @var{err}, an integer.
[error.c:131]

(apply:nconc2last lst)
[eval.c:3222]

(force x)
If the promise X has not been computed yet, compute and return
X, otherwise just return the previously computed value.
[eval.c:3738]

(promise? x)
Return true if @var{obj} is a promise, i.e. a delayed computation
(@pxref{Delayed evaluation,,,r4rs.info,The Revised^4 Report on Scheme}).
[eval.c:3761]

(cons-source xorig x y)
[eval.c:3771]

(copy-tree obj)
Recursively copy the data tree that is bound to @var{obj}, and return a
pointer to the new data structure.  @code{copy-tree} recurses down the
contents of both pairs and vectors (since both cons cells and vector
cells may point to arbitrary objects), and stops recursing when it hits
any other object.
[eval.c:3793]

(eval2 obj env_thunk)
Evaluate @var{exp}, a Scheme expression, in the environment designated
by @var{lookup}, a symbol-lookup function.  @code{(eval exp)} is
equivalent to @code{(eval2 exp *top-level-lookup-closure*)}.
[eval.c:3839]

(eval obj)
Evaluate @var{exp}, a list representing a Scheme expression, in the
top-level environment.
[eval.c:3849]

(eval-options-interface setting)
[eval.c:1714]

(evaluator-traps-interface setting)
[eval.c:1731]

(defined? sym env)
Return @code{#t} if @var{sym} is defined in the top-level environment.
[evalext.c:73]

(map-in-order)
scm_map
[evalext.c:152]

(program-arguments)
[feature.c:76]

(chown object owner group)
Change the ownership and group of the file referred to by @var{object} to
the integer values @var{owner} and @var{group}.  @var{object} can be
a string containing a file name or, if the platform
supports fchown, a port or integer file descriptor
which is open on the file.  The return value
is unspecified.

If @var{object} is a symbolic link, either the
ownership of the link or the ownership of the referenced file will be
changed depending on the operating system (lchown is
unsupported at present).  If @var{owner} or @var{group} is specified
as @code{-1}, then that ID is not changed.
[filesys.c:138]

(chmod object mode)
Changes the permissions of the file referred to by @var{obj}.
@var{obj} can be a string containing a file name or a port or integer file
descriptor which is open on a file (in which case @code{fchmod} is used
as the underlying system call).
@var{mode} specifies
the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.
The return value is unspecified.
[filesys.c:178]

(umask mode)
If @var{mode} is omitted, retuns a decimal number representing the current
file creation mask.  Otherwise the file creation mask is set to
@var{mode} and the previous value is returned.

E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.
[filesys.c:212]

(open-fdes path flags mode)
Similar to @code{open} but returns a file descriptor instead of a
port.
[filesys.c:235]

(open path flags mode)
Open the file named by @var{path} for reading and/or writing.
@var{flags} is an integer specifying how the file should be opened.
@var{mode} is an integer specifying the permission bits of the file, if
it needs to be created, before the umask is applied.  The default is 666
(Unix itself has no default).

@var{flags} can be constructed by combining variables using @code{logior}.
Basic flags are:

@defvar O_RDONLY
Open the file read-only.
@end defvar
@defvar O_WRONLY
Open the file write-only.
@end defvar
@defvar O_RDWR
Open the file read/write.
@end defvar
@defvar O_APPEND
Append to the file instead of truncating.
@end defvar
@defvar O_CREAT
Create the file if it does not already exist.
@end defvar

See the Unix documentation of the @code{open} system call
for additional flags.
[filesys.c:278]

(close fd_or_port)
Similar to close-port (@pxref{Generic Port Operations, close-port}),
but also works on file descriptors.  A side
effect of closing a file descriptor is that any ports using that file
descriptor are moved to a different file descriptor and have
their revealed counts set to zero.
[filesys.c:316]

(stat object)
Returns an object containing various information
about the file determined by @var{obj}.
@var{obj} can be a string containing a file name or a port or integer file
descriptor which is open on a file (in which case @code{fstat} is used
as the underlying system call).

The object returned by @code{stat} can be passed as a single parameter
to the following procedures, all of which return integers:

@table @code
@item stat:dev
The device containing the file.
@item stat:ino
The file serial number, which distinguishes this file from all other
files on the same device.
@item stat:mode
The mode of the file.  This includes file type information
and the file permission bits.  See @code{stat:type} and @code{stat:perms}
below.
@item stat:nlink
The number of hard links to the file.
@item stat:uid
The user ID of the file's owner.
@item stat:gid
The group ID of the file.
@item stat:rdev
Device ID; this entry is defined only for character or block
special files.
@item stat:size
The size of a regular file in bytes.
@item stat:atime
The last access time for the file.
@item stat:mtime
The last modification time for the file.
@item stat:ctime
The last modification time for the attributes of the file.
@item stat:blksize
The optimal block size for reading or writing the file, in bytes.
@item stat:blocks
The amount of disk space that the file occupies measured in units of
512 byte blocks.
@end table

In addition, the following procedures return the information
from stat:mode in a more convenient form:

@table @code
@item stat:type
A symbol representing the type of file.  Possible values are
regular, directory, symlink, block-special, char-special,
fifo, socket and unknown
@item stat:perms
An integer representing the access permission bits.
@end table
[filesys.c:494]

(link oldpath newpath)
Creates a new name @var{path-to} in the file system for the file
named by @var{path-from}.  If @var{path-from} is a symbolic link, the
link may or may not be followed depending on the system.
[filesys.c:540]

(rename-file oldname newname)
Renames the file specified by @var{path-from} to @var{path-to}.
The return value is unspecified.
[filesys.c:565]

(delete-file str)
Deletes (or \"unlinks\") the file specified by @var{path}.
[filesys.c:594]

(mkdir path mode)
Create a new directory named by @var{path}.  If @var{mode} is omitted
then the permissions of the directory file are set using the current
umask.  Otherwise they are set to the decimal value specified with
@var{mode}.  The return value is unspecified.
[filesys.c:613]

(rmdir path)
Remove the existing directory named by @var{path}.  The directory must
be empty for this to succeed.  The return value is unspecified.
[filesys.c:642]

(directory-stream? obj)
Returns a boolean indicating whether @var{object} is a directory stream
as returned by @code{opendir}.
[filesys.c:666]

(opendir dirname)
Open the directory specified by @var{path} and return a directory
stream.
[filesys.c:676]

(readdir port)
Return (as a string) the next directory entry from the directory stream
@var{stream}.  If there is no remaining entry to be read then the
end of file object is returned.
[filesys.c:694]

(rewinddir port)
Reset the directory port @var{stream} so that the next call to
@code{readdir} will return the first directory entry.
[filesys.c:713]

(closedir port)
Close the directory stream @var{stream}.
The return value is unspecified.
[filesys.c:727]

(chdir str)
Change the current working directory to @var{path}.
The return value is unspecified.
[filesys.c:777]

(getcwd)
Returns the name of the current working directory.
[filesys.c:794]

(select reads writes excepts secs usecs)
This procedure has a variety of uses: waiting for the ability
to provide input, accept output, or the existance of
exceptional conditions on a collection of ports or file
descriptors, or waiting for a timeout to occur.
It also returns if interrupted by a signal.

@var{reads}, @var{writes} and @var{excepts} can be lists or
vectors, with each member a port or a file descriptor.
The value returned is a list of three corresponding
lists or vectors containing only the members which meet the
specified requirement.  The ability of port buffers to
provide input or accept output is taken into account.
Ordering of the input lists or vectors is not preserved.

The optional arguments @var{secs} and @var{usecs} specify the
timeout.  Either @var{secs} can be specified alone, as
either an integer or a real number, or both @var{secs} and
@var{usecs} can be specified as integers, in which case
@var{usecs} is an additional timeout expressed in
microseconds.  If @var{secs} is omitted or is @code{#f} then
select will wait for as long as it takes for one of the other
conditions to be satisfied.

The scsh version of @code{select} differs as follows:
Only vectors are accepted for the first three arguments.
The @var{usecs} argument is not supported.
Multiple values are returned instead of a list.
Duplicates in the input vectors appear only once in output.
An additional @code{select!} interface is provided.
[filesys.c:991]

(fcntl object cmd value)
Apply @var{command} to the specified file descriptor or the underlying
file descriptor of the specified port.  @var{value} is an optional
integer argument.

Values for @var{command} are:

@table @code
@item F_DUPFD
Duplicate a file descriptor
@item F_GETFD
Get flags associated with the file descriptor.
@item F_SETFD
Set flags associated with the file descriptor to @var{value}.
@item F_GETFL
Get flags associated with the open file.
@item F_SETFL
Set flags associated with the open file to @var{value}
@item F_GETOWN
Get the process ID of a socket's owner, for @code{SIGIO} signals.
@item F_SETOWN
Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.
@item FD_CLOEXEC
The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or"
@code{F_SETFL}."
@end table
[filesys.c:1139]

(fsync object)
Copies any unwritten data for the specified output file descriptor to disk.
If @var{port/fd} is a port, its buffer is flushed before the underlying
file descriptor is fsync'd.
The return value is unspecified.
[filesys.c:1175]

(symlink oldpath newpath)
Create a symbolic link named @var{path-to} with the value (i.e., pointing to)
@var{path-from}.  The return value is unspecified.
[filesys.c:1202]

(readlink path)
Returns the value of the symbolic link named by
@var{path} (a string), i.e., the
file that the link points to.
[filesys.c:1224]

(lstat str)
Similar to @code{stat}, but does not follow symbolic links, i.e.,
it will return information about a symbolic link itself, not the
file it points to.  @var{path} must be a string.
[filesys.c:1254]

(copy-file oldfile newfile)
Copy the file specified by @var{path-from} to @var{path-to}.
The return value is unspecified.
[filesys.c:1280]

(dirname filename)
[filesys.c:1327]

(basename filename suffix)
[filesys.c:1353]

(make-fluid)
Return a newly created fluid.
Fluids are objects of a certain type (a smob) that can hold one SCM
value per dynamic root.  That is, modifications to this value are
only visible to code that executes within the same dynamic root as
the modifying code.  When a new dynamic root is constructed, it
inherits the values from its parent.  Because each thread executes
in its own dynamic root, you can use fluids for thread local storage.
[fluids.c:129]

(fluid? obj)
Return #t iff @var{obj} is a fluid; otherwise, return #f.
[fluids.c:142]

(fluid-ref fluid)
Return the value associated with @var{fluid} in the current dynamic root.
If @var{fluid} has not been set, then this returns #f.
[fluids.c:152]

(fluid-set! fluid value)
Set the value associated with @var{fluid} in the current dynamic root.
[fluids.c:169]

(with-fluids* fluids values thunk)
Set @var{fluids} to @var{values} temporary, and call @var{thunk}.
@var{fluids} must be a list of fluids and @var{values} must be the same
number of their values to be applied.  Each substitution is done
one after another.  @var{thunk} must be a procedure with no argument.
[fluids.c:228]

(setvbuf port mode size)
Set the buffering mode for @var{port}.  @var{mode} can be:
@table @code
@item _IONBF
non-buffered
@item _IOLBF
line buffered
@item _IOFBF
block buffered, using a newly allocated buffer of @var{size} bytes.
If @var{size} is omitted, a default size will be used.
@end table
[fports.c:146]

(open-file filename modes)
Open the file whose name is @var{string}, and return a port
representing that file.  The attributes of the port are
determined by the @var{mode} string.  The way in
which this is interpreted is similar to C stdio:

The first character must be one of the following:

@table @samp
@item r
Open an existing file for input.
@item w
Open a file for output, creating it if it doesn't already exist
or removing its contents if it does.
@item a
Open a file for output, creating it if it doesn't already exist.
All writes to the port will go to the end of the file.
The \"append mode\" can be turned off while the port is in use
@pxref{Ports and File Descriptors, fcntl}
@end table

The following additional characters can be appended:

@table @samp
@item +
Open the port for both input and output.  E.g., @code{r+}: open
an existing file for both input and output.
@item 0
Create an \"unbuffered\" port.  In this case input and output operations
are passed directly to the underlying port implementation without
additional buffering.  This is likely to slow down I/O operations.
The buffering mode can be changed while a port is in use
@pxref{Ports and File Descriptors, setvbuf}
@item l
Add line-buffering to the port.  The port output buffer will be
automatically flushed whenever a newline character is written.
@end table

In theory we could create read/write ports which were buffered in one
direction only.  However this isn't included in the current interfaces.

If a file cannot be opened with the access requested,
@code{open-file} throws an exception.
[fports.c:269]

(gc-stats)
Returns an association list of statistics about Guile's current use of storage.
[gc.c:561]

(object-address obj)
Return an integer that for the lifetime of @var{obj} is uniquely
returned by this function for @var{obj}
[gc.c:634]

(gc)
Scans all of SCM objects and reclaims for further use those that are
no longer accessible.
[gc.c:645]

(unhash-name name)
[gc.c:2049]

(make-guardian)
Create a new guardian.
A guardian protects a set of objects from garbage collection,
allowing a program to apply cleanup or other actions.

make-guardian returns a procedure representing the guardian.
Calling the guardian procedure with an argument adds the
argument to the guardian's set of protected objects.
Calling the guardian procedure without an argument returns
one of the protected objects which are ready for garbage
collection or @code{#f} if no such object is available.
Objects which are returned in this way are removed from
the guardian.
.
See R. Kent Dybvig, Carl Bruggeman, and David Eby (1993)
\"Guardians in a Generation-Based Garbage Collector\".
ACM SIGPLAN Conference on Programming Language Design
and Implementation, June 1993.
[guardians.c:181]

(hashq key size)
Determine a hash value for KEY that is suitable for lookups in
a hashtable of size SIZE, where eq? is used as the equality
predicate.  The function returns an integer in the range 0 to
SIZE - 1.  NOTE that `hashq' may use internal addresses.
Thus two calls to hashq where the keys are eq? are not
guaranteed to deliver the same value if the key object gets
garbage collected in between.  This can happen, for example
with symbols:  (hashq 'foo n) (gc) (hashq 'foo n) may produce two
different values, since 'foo will be garbage collected.
[hash.c:178]

(hashv key size)
Determine a hash value for KEY that is suitable for lookups in
a hashtable of size SIZE, where eqv? is used as the equality
predicate.  The function returns an integer in the range 0 to
SIZE - 1.  NOTE that (hashv key) may use internal addresses.
Thus two calls to hashv where the keys are eqv? are not
guaranteed to deliver the same value if the key object gets
garbage collected in between.  This can happen, for example
with symbols:  (hashv 'foo n) (gc) (hashv 'foo n) may produce two
different values, since 'foo will be garbage collected.
[hash.c:213]

(hash key size)
Determine a hash value for KEY that is suitable for lookups in
a hashtable of size SIZE, where equal? is used as the equality
predicate.  The function returns an integer in the range 0 to
SIZE - 1.
[hash.c:236]

(hashq-get-handle table obj)
This procedure is similar to its @code{-ref} cousin, but returns a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hashq-ref table key} returns
only a @code{value}, @code{hashq-get-handle table key} returns the pair
@code{(key . value)}.
[hashtab.c:176]

(hashq-create-handle! table key init)
This function looks up @var{key} in @var{table} and returns its handle.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
[hashtab.c:188]

(hashq-ref table obj dflt)
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Uses `eq?' for equality testing.
[hashtab.c:201]

(hashq-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there. Uses `eq?' for equality testing.
[hashtab.c:215]

(hashq-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Uses `eq?' for equality tests.
[hashtab.c:227]

(hashv-get-handle table obj)
This procedure is similar to its @code{-ref} cousin, but returns a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hashv-ref table key} returns
only a @code{value}, @code{hashv-get-handle table key} returns the pair
@code{(key . value)}.
[hashtab.c:244]

(hashv-create-handle! table key init)
This function looks up @var{key} in @var{table} and returns its handle.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
[hashtab.c:256]

(hashv-ref table obj dflt)
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Uses `eqv?' for equality testing.
[hashtab.c:269]

(hashv-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there. Uses `eqv?' for equality testing.
[hashtab.c:283]

(hashv-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Uses `eqv?' for equality tests.
[hashtab.c:294]

(hash-get-handle table obj)
This procedure is similar to its @code{-ref} cousin, but returns a
@dfn{handle} from the hash table rather than the value associated with
@var{key}.  By convention, a handle in a hash table is the pair which
associates a key with a value.  Where @code{hash-ref table key} returns
only a @code{value}, @code{hash-get-handle table key} returns the pair
@code{(key . value)}.
[hashtab.c:310]

(hash-create-handle! table key init)
This function looks up @var{key} in @var{table} and returns its handle.
If @var{key} is not already present, a new handle is created which
associates @var{key} with @var{init}.
[hashtab.c:322]

(hash-ref table obj dflt)
Look up @var{key} in the hash table @var{table}, and return the
value (if any) associated with it.  If @var{key} is not found,
return @var{default} (or @code{#f} if no @var{default} argument is
supplied).  Uses `equal?' for equality testing.
[hashtab.c:335]

(hash-set! table obj val)
Find the entry in @var{table} associated with @var{key}, and store
@var{value} there. Uses `equal?' for equality testing.
[hashtab.c:349]

(hash-remove! table obj)
Remove @var{key} (and any value associated with it) from @var{table}.
Uses `equal?' for equality tests.
[hashtab.c:361]

(hashx-get-handle hash assoc table obj)
This behaves the same way as the corresponding @code{-get-handle}
function, but uses @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.
[hashtab.c:430]

(hashx-create-handle! hashassoctableobjinit)
This behaves the same way as the corresponding @code{-create-handle}
function, but uses @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.
[hashtab.c:448]

(hashx-ref hashassoctableobjdflt)
This behaves the same way as the corresponding @code{ref}
function, but uses @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.

By way of illustration, @code{hashq-ref table key} is equivalent
to @code{hashx-ref hashq assq table key}.
[hashtab.c:469]

(hashx-set! hash assoc table obj val)
This behaves the same way as the corresponding @code{set!}
function, but uses @var{hasher} as a
hash function and @var{assoc} to compare keys.  @code{hasher} must
be a function that takes two arguments, a key to be hashed and a
table size.  @code{assoc} must be an associator function, like
@code{assoc}, @code{assq} or @code{assv}.

By way of illustration, @code{hashq-set! table key} is equivalent
to @code{hashx-set! hashq assq table key}.
[hashtab.c:493]

(hash-fold proc init table)
An iterator over hash-table elements.
Accumulates and returns a result by applying PROC successively.
The arguments to PROC are \"(key value prior-result)\" where key
and value are successive pairs from the hash table TABLE, and
prior-result is either INIT (for the first application of PROC)
or the return value of the previous application of PROC.
For example, @code{(hash-fold acons () tab)} will convert a hash
table into an a-list of key-value pairs.
[hashtab.c:530]

(make-hook-with-name name n_args)
[hooks.c:215]

(make-hook n_args)
[hooks.c:229]

(hook? x)
[hooks.c:239]

(hook-empty? hook)
[hooks.c:249]

(add-hook! hook proc append_p)
[hooks.c:260]

(remove-hook! hook proc)
[hooks.c:286]

(reset-hook! hook)
[hooks.c:299]

(run-hook hook args)
[hooks.c:311]

(hook->list hook)
[hooks.c:338]

(%read-delimited! delims buf gobble port start end)
Read characters from @var{port} into @var{buf} until one of the
characters in the @var{delims} string is encountered.  If @var{gobble?}
is true, store the delimiter character in @var{buf} as well; otherwise,
discard it.  If @var{port} is not specified, use the value of
@code{(current-input-port)}.  If @var{start} or @var{end} are specified,
store data only into the substring of @var{buf} bounded by @var{start}
and @var{end} (which default to the beginning and end of the buffer,
respectively).

Return a pair consisting of the delimiter that terminated the string and
the number of characters read.  If reading stopped at the end of file,
the delimiter returned is the @var{eof-object}; if the buffer was filled
without encountering a delimiter, this value is @var{#f}.
[ioext.c:85]

(%read-line port)
Read a newline-terminated line from @var{port}, allocating storage as
necessary.  The newline terminator (if any) is removed from the string,
and a pair consisting of the line and its delimiter is returned.  The
delimiter may be either a newline or the @var{eof-object}; if
@code{%read-line} is called at the end of file, it returns the pair
@code{(#<eof> . #<eof>)}.
[ioext.c:238]

(write-line obj port)
Display @var{obj} and a newline character to @var{port}.  If @var{port}
is not specified, @code{(current-output-port)} is used.  This function
is equivalent to:

@smalllisp
(display obj [port])
(newline [port])
@end smalllisp
[ioext.c:292]

(ftell object)
Returns an integer representing the current position of @var{fd/port},
measured from the beginning.  Equivalent to:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ioext.c:306]

(fseek object offset whence)
Obsolete.  Almost the same as seek, above, but the return value is
unspecified.
[ioext.c:319]

(redirect-port old new)
This procedure takes two ports and duplicates the underlying file
descriptor from @var{old-port} into @var{new-port}.  The
current file descriptor in @var{new-port} will be closed.
After the redirection the two ports will share a file position
and file status flags.

The return value is unspecified.

Unexpected behaviour can result if both ports are subsequently used
and the original and/or duplicate ports are buffered.

This procedure does not have any side effects on other ports or
revealed counts.
[ioext.c:341]

(dup->fdes fd_or_port fd)
Returns an integer file descriptor.
[ioext.c:378]

(fileno port)
Returns the integer file descriptor underlying @var{port}.
Does not change its revealed count.
[ioext.c:418]

(isatty? port)
Returns @code{#t} if @var{port} is using a serial
non-file device, otherwise @code{#f}.
[ioext.c:434]

(fdopen fdes modes)
Returns a new port based on the file descriptor @var{fdes}.
Modes are given by the string @var{modes}.  The revealed count of the port
is initialized to zero.  The modes string is the same as that accepted
by @ref{File Ports, open-file}.
[ioext.c:456]

(primitive-move->fdes port fd)
Moves the underlying file descriptor for @var{port} to the integer
value @var{fdes} without changing the revealed count of @var{port}.
Any other ports already using this descriptor will be automatically
shifted to new descriptors and their revealed counts reset to zero.
The return value is @code{#f} if the file descriptor already had the
required value or @code{#t} if it was moved.
[ioext.c:481]

(fdes->ports fd)
Returns a list of existing ports which have @var{fdes} as an
underlying file descriptor, without changing their revealed counts.
[ioext.c:514]

(make-keyword-from-dash-symbol symbol)
Return a keyword object from SYMBOL that starts with `-' (a dash).
[keywords.c:71]

(keyword? obj)
Returns #t if the argument OBJ is a keyword, else #f.
[keywords.c:109]

(keyword-dash-symbol keyword)
Return KEYWORD as a dash symbol.
This is the inverse of `make-keyword-from-dash-symbol'.
[keywords.c:120]

(nil-cons x y)
[lang.c:69]

(nil-car x)
[lang.c:83]

(nil-cdr x)
[lang.c:95]

(null x)
[lang.c:109]

(nil-eq x y)
[lang.c:137]

(list objs)
Return a list containing OBJS, the arguments to `list'.
[list.c:84]

(list*)
scm_cons_star
[list.c:94]

(cons* arg rest)
Like `list', but the last arg provides the tail of the constructed list,
returning (cons ARG1 (cons ARG2 (cons ... ARGn))).
Requires at least one argument.  If given one argument, that argument
is returned as result.
This function is called `list*' in some other Schemes and in Common LISP.
[list.c:104]

(null? x)
Return #t iff X is the empty list, else #f.
[list.c:128]

(list? x)
Return #t iff X is a proper list, else #f.
[list.c:138]

(length lst)
Return the number of elements in list LST.
[list.c:179]

(append args)
Returns a list consisting of the elements of the first LIST
followed by the elements of the other LISTs.
  (append '(x) '(y))          =>  (x y)
  (append '(a) '(b c d))      =>  (a b c d)
  (append '(a (b)) '((c)))    =>  (a (b) (c))
The resulting list is always newly allocated, except that it shares
structure with the last LIST argument.  The last argument may
actually be any object; an improper list results if the last
argument is not a proper list.
  (append '(a b) '(c . d))    =>  (a b c . d)
  (append '() 'a)             =>  a
[list.c:207]

(append! args)
A destructive version of @code{append} (@pxref{Pairs and Lists,,,r4rs,
The Revised^4 Report on Scheme}).  The cdr field of each list's final
pair is changed to point to the head of the next list, so no consing is
performed.  Return a pointer to the mutated list.
[list.c:240]

(last-pair lst)
Return a pointer to the last pair in @var{lst}, signalling an error if
@var{lst} is circular.
[list.c:266]

(reverse lst)
Return a new list that contains the elements of LST but in reverse order.
[list.c:295]

(reverse! lst new_tail)
A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r4rs,
The Revised^4 Report on Scheme}).  The cdr of each cell in @var{lst} is
modified to point to the previous list element.  Return a pointer to the
head of the reversed list.

Caveat: because the list is modified in place, the tail of the original
list now becomes its head, and the head of the original list now becomes
the tail.  Therefore, the @var{lst} symbol to which the head of the
original list was bound now points to the tail.  To ensure that the head
of the modified list is not lost, it is wise to save the return value of
@code{reverse!}
[list.c:329]

(list-ref lst k)
Return the Kth element from list LST.
[list.c:355]

(list-set! lst k val)
Set the @var{k}th element of @var{lst} to @var{val}.
[list.c:373]

(list-cdr-ref)
scm_list_tail
[list.c:391]

(list-tail lst k)
Return the \"tail\" of @var{lst} beginning with its @var{k}th element.
The first element of the list is considered to be element 0.

@code{list-cdr-ref} and @code{list-tail} are identical.  It may help to
think of @code{list-cdr-ref} as accessing the @var{k}th cdr of the list,
or returning the results of cdring @var{k} times down @var{lst}.
[list.c:399]

(list-cdr-set! lst k val)
Set the @var{k}th cdr of @var{lst} to @var{val}.
[list.c:415]

(list-head lst k)
Copy the first @var{k} elements from @var{lst} into a new list, and
return it.
[list.c:439]

(list-copy lst)
Return a (newly-created) copy of @var{lst}.
[list.c:463]

(sloppy-memq x lst)
This procedure behaves like @code{memq}, but does no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[list.c:493]

(sloppy-memv x lst)
This procedure behaves like @code{memv}, but does no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[list.c:510]

(sloppy-member x lst)
This procedure behaves like @code{member}, but does no type or error checking.
Its use is recommended only in writing Guile internals,
not for high-level Scheme programs.
[list.c:527]

(memq x lst)
Return the first sublist of LST whose car is `eq?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[list.c:547]

(memv x lst)
Return the first sublist of LST whose car is `eqv?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[list.c:565]

(member x lst)
Return the first sublist of LST whose car is `equal?' to X
where the sublists of LST are the non-empty lists returned
by `(list-tail LST K)' for K less than the length of LST.  If
X does not occur in LST, then `#f' (not the empty list) is
returned.
[list.c:582]

(delq! item lst)
@deffnx primitive delv! item lst
@deffnx primitive delete! item lst
These procedures are destructive versions of @code{delq}, @code{delv}
and @code{delete}: they modify the pointers in the existing @var{lst}
rather than creating a new list.  Caveat evaluator: Like other
destructive list functions, these functions cannot modify the binding of
@var{lst}, and so cannot be used to delete the first element of
@var{lst} destructively.
[list.c:605]

(delv! item lst)
Destructively remove all elements from LST that are `eqv?' to ITEM.
[list.c:628]

(delete! item lst)
Destructively remove all elements from LST that are `equal?' to ITEM.
[list.c:652]

(delq item lst)
Return a newly-created copy of @var{lst} with elements `eq?' to @var{item} removed.
This procedure mirrors @code{memq}:
@code{delq} compares elements of @var{lst} against @var{item} with
@code{eq?}.
[list.c:681]

(delv item lst)
Return a newly-created copy of @var{lst} with elements `eqv?' to @var{item} removed.
This procedure mirrors @code{memv}:
@code{delv} compares elements of @var{lst} against @var{item} with
@code{eqv?}.
[list.c:694]

(delete item lst)
Return a newly-created copy of @var{lst} with elements `equal?' to @var{item} removed.
This procedure mirrors @code{member}:
@code{delete} compares elements of @var{lst} against @var{item} with
@code{equal?}.
[list.c:707]

(delq1! item lst)
Like `delq!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `eq?'.  See also `delv1!' and `delete1!'.
[list.c:719]

(delv1! item lst)
Like `delv!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `eqv?'.  See also `delq1!' and `delete1!'.
[list.c:746]

(delete1! item lst)
Like `delete!', but only deletes the first occurrence of ITEM from LST.
Tests for equality using `equal?'.  See also `delq1!' and `delv1!'.
[list.c:773]

(primitive-load filename)
Load @var{file} and evaluate its contents in the top-level environment.
The load paths are not searched; @var{file} must either be a full
pathname or be a pathname relative to the current directory.  If the
variable @code{%load-hook} is defined, it should be bound to a procedure
that will be called before any code is loaded.  See documentation for
@code{%load-hook} later in this section.
[load.c:109]

(%package-data-dir)
Return the name of the directory where Scheme packages, modules and
libraries are kept.  On most Unix systems, this will be
@samp{/usr/local/share/guile}.
[load.c:144]

(%library-dir)
Return the directory where the Guile Scheme library files are installed.
E.g., may return \"/usr/share/guile/1.3.5\".
[load.c:156]

(%site-dir)
Return the directory where the Guile site files are installed.
E.g., may return \"/usr/share/guile/site\".
[load.c:168]

(parse-path path tail)
[load.c:217]

(search-path path filename extensions)
[load.c:262]

(%search-load-path filename)
Search @var{%load-path} for @var{file}, which must be readable by the
current user.  If @var{file} is found in the list of paths to search or
is an absolute pathname, return its full pathname.  Otherwise, return
@code{#f}.  Filenames may have any of the optional extensions in the
@code{%load-extensions} list; @code{%search-load-path} will try each
extension automatically.
[load.c:410]

(primitive-load-path filename)
Search @var{%load-path} for @var{file} and load it into the top-level
environment.  If @var{file} is a relative pathname and is not found in
the list of search paths, an error is signalled.
[load.c:431]

(read-and-eval! port)
Read a form from @var{port} (standard input by default), and evaluate it
(memoizing it in the process) in the top-level environment.  If no data
is left to be read from @var{port}, an @code{end-of-file} error is
signalled.
[load.c:466]

(procedure->syntax code)
Returns a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, returns the result
of applying @var{code} to the expression and the environment.
[macros.c:60]

(procedure->macro code)
Returns a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, evaluates the result
of applying @var{code} to the expression and the environment.
The value returned from @var{code} which has been passed to
@code{procedure->memoizing-macro} replaces the form passed to
@var{code}.  For example:

@example
(define trace
  (procedure->macro
   (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))

(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
@end example
[macros.c:82]

(procedure->memoizing-macro code)
Returns a @dfn{macro} which, when a symbol defined to this value
appears as the first symbol in an expression, evaluates the result
of applying @var{proc} to the expression and the environment.
The value returned from @var{proc} which has been passed to
@code{procedure->memoizing-macro} replaces the form passed to
@var{proc}.  For example:

@example
(define trace
  (procedure->macro
   (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))

(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
@end example
[macros.c:104]

(macro? obj)
Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a
syntax transformer.
[macros.c:116]

(macro-type m)
Return one of the symbols @code{syntax}, @code{macro} or @code{macro!},
depending on whether @var{obj} is a syntax tranformer, a regular macro,
or a memoizing macro, respectively.  If @var{obj} is not a macro,
@code{#f} is returned.
[macros.c:133]

(macro-name m)
[macros.c:151]

(macro-transformer m)
[macros.c:162]

(standard-eval-closure module)
[modules.c:245]

(inet-aton address)
Converts a string containing an Internet host address in the traditional
dotted decimal notation into an integer.

@smalllisp
(inet-aton \"127.0.0.1\") @result{} 2130706433

@end smalllisp
[net_db.c:94]

(inet-ntoa inetid)
Converts an integer Internet host address into a string with the
traditional dotted decimal representation.

@smalllisp
(inet-ntoa 2130706433) @result{} \"127.0.0.1\""
@end smalllisp
[net_db.c:115]

(inet-netof address)
Returns the network number part of the given integer Internet address.

@smalllisp
(inet-netof 2130706433) @result{} 127
@end smalllisp
[net_db.c:134]

(inet-lnaof address)
Returns the local-address-with-network part of the given Internet
address.

@smalllisp
(inet-lnaof 2130706433) @result{} 1
@end smalllisp
[net_db.c:151]

(inet-makeaddr net lna)
Makes an Internet host address by combining the network number @var{net}
with the local-address-within-network number @var{lna}.

@smalllisp
(inet-makeaddr 127 1) @result{} 2130706433
@end smalllisp
[net_db.c:168]

(gethost name)
@deffnx procedure gethostbyname hostname
@deffnx procedure gethostbyaddr address
Look up a host by name or address, returning a host object.  The
@code{gethost} procedure will accept either a string name or an integer
address; if given no arguments, it behaves like @code{gethostent} (see
below).  If a name or address is supplied but the address can not be
found, an error will be thrown to one of the keys:
@code{host-not-found}, @code{try-again}, @code{no-recovery} or
@code{no-data}, corresponding to the equivalent @code{h_error} values.
Unusual conditions may result in errors thrown to the
@code{system-error} or @code{misc_error} keys.
[net_db.c:253]

(getnet name)
@deffnx procedure getnetbyname net-name
@deffnx procedure getnetbyaddr net-number
Look up a network by name or net number in the network database.  The
@var{net-name} argument must be a string, and the @var{net-number}
argument must be an integer.  @code{getnet} will accept either type of
argument, behaving like @code{getnetent} (see below) if no arguments are
given.
[net_db.c:334]

(getproto name)
@deffnx procedure getprotobyname name
@deffnx procedure getprotobynumber number
Look up a network protocol by name or by number.  @code{getprotobyname}
takes a string argument, and @code{getprotobynumber} takes an integer
argument.  @code{getproto} will accept either type, behaving like
@code{getprotoent} (see below) if no arguments are supplied.
[net_db.c:386]

(getserv name proto)
@deffnx procedure getservbyname name protocol
@deffnx procedure getservbyport port protocol
Look up a network service by name or by service number, and return a
network service object.  The @var{protocol} argument specifies the name
of the desired protocol; if the protocol found in the network service
database does not match this name, a system error is signalled.

The @code{getserv} procedure will take either a service name or number
as its first argument; if given no arguments, it behaves like
@code{getservent} (see below).
[net_db.c:455]

(sethost arg)
If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.
Otherwise it is equivalent to @code{sethostent stayopen}.
[net_db.c:496]

(setnet arg)
If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.
Otherwise it is equivalent to @code{setnetent stayopen}.
[net_db.c:512]

(setproto arg)
If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.
Otherwise it is equivalent to @code{setprotoent stayopen}.
[net_db.c:528]

(setserv arg)
If @var{stayopen} is omitted, this is equivalent to @code{endservent}.
Otherwise it is equivalent to @code{setservent stayopen}.
[net_db.c:544]

(exact? x)
Return #t if X is an exact number, #f otherwise.
[numbers.c:103]

(odd? n)
Return #t if N is an odd number, #f otherwise.
[numbers.c:119]

(even? n)
Return #t if N is an even number, #f otherwise.
[numbers.c:135]

(logand n1 n2)
Returns the integer which is the bit-wise AND of the two integer
arguments.

Example:
@lisp
(number->string (logand #b1100 #b1010) 2)
   @result{} \"1000"
[numbers.c:717]

(logior n1 n2)
Returns the integer which is the bit-wise OR of the two integer
arguments.

Example:
@lisp
(number->string (logior #b1100 #b1010) 2)
   @result{} \"1110"
@end lisp
[numbers.c:804]

(logxor n1 n2)
Returns the integer which is the bit-wise XOR of the two integer
arguments.

Example:
@lisp
(number->string (logxor #b1100 #b1010) 2)
   @result{} \"110"
@end lisp
[numbers.c:890]

(logtest n1 n2)
@example
(logtest j k) @equiv{} (not (zero? (logand j k)))

(logtest #b0100 #b1011) @result{} #f
(logtest #b0100 #b0111) @result{} #t
@end example
[numbers.c:959]

(logbit? index j)
@example
(logbit? index j) @equiv{} (logtest (integer-expt 2 index) j)

(logbit? 0 #b1101) @result{} #t
(logbit? 1 #b1101) @result{} #f
(logbit? 2 #b1101) @result{} #t
(logbit? 3 #b1101) @result{} #t
(logbit? 4 #b1101) @result{} #f
@end example
[numbers.c:1016]

(lognot n)
Returns the integer which is the 2s-complement of the integer argument.

Example:
@lisp
(number->string (lognot #b10000000) 2)
   @result{} \"-10000001"
(number->string (lognot #b0) 2)
   @result{} \"-1"
@end lisp
[numbers.c:1065]

(integer-expt n k)
Returns @var{n} raised to the non-negative integer exponent @var{k}.

Example:
@lisp
(integer-expt 2 5)
   @result{} 32
(integer-expt -3 3)
   @result{} -27
@end lisp
[numbers.c:1081]

(ash n cnt)
The function ash performs an arithmetic shift left by CNT bits
(or shift right, if CNT is negative).  'Arithmetic' means, that
the function does not guarantee to keep the bit structure of N,
but rather guarantees that the result will always be rounded
towards minus infinity.  Therefore, the results of ash and a
corresponding bitwise shift will differ if N is negative.

Formally, the function returns an integer equivalent to
@code{(inexact->exact (floor (* N (expt 2 CNT))))}.@refill

Example:
@lisp
(number->string (ash #b1 3) 2)
   @result{} \"1000\""
(number->string (ash #b1010 -1) 2)"
   @result{} \"101\""
@end lisp
[numbers.c:1128]

(bit-extract n start end)
Returns the integer composed of the @var{start} (inclusive) through
@var{end} (exclusive) bits of @var{n}.  The @var{start}th bit becomes
the 0-th bit in the result.@refill

Example:
@lisp
(number->string (bit-extract #b1101101010 0 4) 2)
   @result{} \"1010"
(number->string (bit-extract #b1101101010 4 9) 2)
   @result{} \"10110"
@end lisp
[numbers.c:1181]

(logcount n)
Returns the number of bits in integer @var{n}.  If integer is positive,
the 1-bits in its binary representation are counted.  If negative, the
0-bits in its two's-complement binary representation are counted.  If 0,
0 is returned.

Example:
@lisp
(logcount #b10101010)
   @result{} 4
(logcount 0)
   @result{} 0
(logcount -2)
   @result{} 1
@end lisp
[numbers.c:1222]

(integer-length n)
Returns the number of bits neccessary to represent @var{n}.

Example:
@lisp
(integer-length #b10101010)
   @result{} 8
(integer-length 0)
   @result{} 0
(integer-length #b1111)
   @result{} 4
@end lisp
[numbers.c:1273]

(number->string n radix)
Return a string holding the external representation of the
number N in the given RADIX.  If N is inexact, a radix of 10
will be used.
[numbers.c:2220]

(string->number string radix)
Returns a number of the maximally precise representation
expressed by the given STRING. RADIX must be an exact integer,
either 2, 8, 10, or 16. If supplied, RADIX is a default radix
that may be overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets the revealed count for a port to a given value.
The return value is unspecified.
[ports.c:536]

(port-mode port)
Returns the port modes associated with the open port @var{port}.  These
will not necessarily be identical to the modes used when the port was
opened, since modes such as \"append\" which are used only during
port creation are not retained.
[ports.c:579]

(close-port port)
Close the specified port object.  Returns @code{#t} if it successfully
closes a port or @code{#f} if it was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:616]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:644]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:659]

(close-all-ports-except ports)
Close all open file ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec call to close file descriptors
which are not needed in the new process.
[ports.c:674]

(input-port? x)
Returns @code{#t} if @var{x} is an input port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:712]

(output-port? x)
Returns @code{#t} if @var{x} is an output port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:725]

(port-closed? port)
Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.
[ports.c:738]

(eof-object? x)
Returns @code{#t} if @var{x} is an end-of-file object; otherwise
returns @code{#f}.
[ports.c:749]

(force-output port)
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[ports.c:763]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[ports.c:781]

(read-char port)
Returns the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[ports.c:799]

(peek-char port)
Returns the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[ports.c:1032]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[ports.c:1053]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[ports.c:1076]

(seek object offset whence)
Sets the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ports.c:1112]

(truncate-file object length)
Truncates the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port.
position.

The return value is unspecified.
[ports.c:1153]

(port-line port)
Return the current line number for PORT.
[ports.c:1207]

(set-port-line! port line)
Set the current line number for PORT to LINE.
[ports.c:1218]

(port-column port)
@deffnx primitive port-line [input-port]
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[ports.c:1239]

(set-port-column! port column)
@deffnx primitive set-port-column! [input-port] column
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[ports.c:1252]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings \"standard input\", \"standard output\" and \"standard error\""
when called on the current input, output and error ports respectively.
[ports.c:1267]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[ports.c:1281]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[ports.c:1384]

(pipe)
Returns a newly created pipe: a pair of ports which are linked
together on the local machine.  The CAR is the input port and
the CDR is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[posix.c:185]

(getgroups)
Returns a vector of integers representing the current supplimentary group IDs.
[posix.c:205]

(getpw user)
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[posix.c:244]

(setpw arg)
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[posix.c:298]

(getgr name)
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[posix.c:317]

(setgr arg)
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[posix.c:358]

(kill pid sig)
Sends a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[posix.c:394]

(waitpid pid options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped.  Normally it will
suspend the calling process until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[posix.c:442]

(status:exit-val status)
Returns the exit status value, as would be
set if a process , upda overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets the revealed count for a port to a given value.
The return value is unspecified.
[ports.c:536]

(port-mode port)
Returns the port modes associated with the open port @var{port}.  These
will not necessarily be identical to the modes used when the port was
opened, since modes such as \"append\" which are used only during
port creation are not retained.
[ports.c:579]

(close-port port)
Close the specified port object.  Returns @code{#t} if it successfully
closes a port or @code{#f} if it was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:616]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:644]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:659]

(close-all-ports-except ports)
Close all open file ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec call to close file descriptors
which are not needed in the new process.
[ports.c:674]

(input-port? x)
Returns @code{#t} if @var{x} is an input port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:712]

(output-port? x)
Returns @code{#t} if @var{x} is an output port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:725]

(port-closed? port)
Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.
[ports.c:738]

(eof-object? x)
Returns @code{#t} if @var{x} is an end-of-file object; otherwise
returns @code{#f}.
[ports.c:749]

(force-output port)
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[ports.c:763]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[ports.c:781]

(read-char port)
Returns the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[ports.c:799]

(peek-char port)
Returns the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[ports.c:1032]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[ports.c:1053]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[ports.c:1076]

(seek object offset whence)
Sets the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ports.c:1112]

(truncate-file object length)
Truncates the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port.
position.

The return value is unspecified.
[ports.c:1153]

(port-line port)
Return the current line number for PORT.
[ports.c:1207]

(set-port-line! port line)
Set the current line number for PORT to LINE.
[ports.c:1218]

(port-column port)
@deffnx primitive port-line [input-port]
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[ports.c:1239]

(set-port-column! port column)
@deffnx primitive set-port-column! [input-port] column
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[ports.c:1252]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings \"standard input\", \"standard output\" and \"standard error\""
when called on the current input, output and error ports respectively.
[ports.c:1267]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[ports.c:1281]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[ports.c:1384]

(pipe)
Returns a newly created pipe: a pair of ports which are linked
together on the local machine.  The CAR is the input port and
the CDR is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[posix.c:185]

(getgroups)
Returns a vector of integers representing the current supplimentary group IDs.
[posix.c:205]

(getpw user)
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[posix.c:244]

(setpw arg)
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[posix.c:298]

(getgr name)
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[posix.c:317]

(setgr arg)
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[posix.c:358]

(kill pid sig)
Sends a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[posix.c:394]

(waitpid pid options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped.  Normally it will
suspend the calling process until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[posix.c:442]

(status:exit-val status)
Returns the exit status value, as would be
set if a process , upda overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets the revealed count for a port to a given value.
The return value is unspecified.
[ports.c:536]

(port-mode port)
Returns the port modes associated with the open port @var{port}.  These
will not necessarily be identical to the modes used when the port was
opened, since modes such as \"append\" which are used only during
port creation are not retained.
[ports.c:579]

(close-port port)
Close the specified port object.  Returns @code{#t} if it successfully
closes a port or @code{#f} if it was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:616]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:644]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:659]

(close-all-ports-except ports)
Close all open file ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec call to close file descriptors
which are not needed in the new process.
[ports.c:674]

(input-port? x)
Returns @code{#t} if @var{x} is an input port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:712]

(output-port? x)
Returns @code{#t} if @var{x} is an output port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:725]

(port-closed? port)
Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.
[ports.c:738]

(eof-object? x)
Returns @code{#t} if @var{x} is an end-of-file object; otherwise
returns @code{#f}.
[ports.c:749]

(force-output port)
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[ports.c:763]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[ports.c:781]

(read-char port)
Returns the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[ports.c:799]

(peek-char port)
Returns the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[ports.c:1032]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[ports.c:1053]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[ports.c:1076]

(seek object offset whence)
Sets the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ports.c:1112]

(truncate-file object length)
Truncates the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port.
position.

The return value is unspecified.
[ports.c:1153]

(port-line port)
Return the current line number for PORT.
[ports.c:1207]

(set-port-line! port line)
Set the current line number for PORT to LINE.
[ports.c:1218]

(port-column port)
@deffnx primitive port-line [input-port]
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[ports.c:1239]

(set-port-column! port column)
@deffnx primitive set-port-column! [input-port] column
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[ports.c:1252]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings \"standard input\", \"standard output\" and \"standard error\""
when called on the current input, output and error ports respectively.
[ports.c:1267]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[ports.c:1281]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[ports.c:1384]

(pipe)
Returns a newly created pipe: a pair of ports which are linked
together on the local machine.  The CAR is the input port and
the CDR is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[posix.c:185]

(getgroups)
Returns a vector of integers representing the current supplimentary group IDs.
[posix.c:205]

(getpw user)
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[posix.c:244]

(setpw arg)
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[posix.c:298]

(getgr name)
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[posix.c:317]

(setgr arg)
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[posix.c:358]

(kill pid sig)
Sends a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[posix.c:394]

(waitpid pid options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped.  Normally it will
suspend the calling process until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[posix.c:442]

(status:exit-val status)
Returns the exit status value, as would be
set if a process , upda overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets the revealed count for a port to a given value.
The return value is unspecified.
[ports.c:536]

(port-mode port)
Returns the port modes associated with the open port @var{port}.  These
will not necessarily be identical to the modes used when the port was
opened, since modes such as \"append\" which are used only during
port creation are not retained.
[ports.c:579]

(close-port port)
Close the specified port object.  Returns @code{#t} if it successfully
closes a port or @code{#f} if it was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:616]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:644]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:659]

(close-all-ports-except ports)
Close all open file ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec call to close file descriptors
which are not needed in the new process.
[ports.c:674]

(input-port? x)
Returns @code{#t} if @var{x} is an input port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:712]

(output-port? x)
Returns @code{#t} if @var{x} is an output port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:725]

(port-closed? port)
Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.
[ports.c:738]

(eof-object? x)
Returns @code{#t} if @var{x} is an end-of-file object; otherwise
returns @code{#f}.
[ports.c:749]

(force-output port)
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[ports.c:763]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[ports.c:781]

(read-char port)
Returns the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[ports.c:799]

(peek-char port)
Returns the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[ports.c:1032]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[ports.c:1053]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[ports.c:1076]

(seek object offset whence)
Sets the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ports.c:1112]

(truncate-file object length)
Truncates the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port.
position.

The return value is unspecified.
[ports.c:1153]

(port-line port)
Return the current line number for PORT.
[ports.c:1207]

(set-port-line! port line)
Set the current line number for PORT to LINE.
[ports.c:1218]

(port-column port)
@deffnx primitive port-line [input-port]
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[ports.c:1239]

(set-port-column! port column)
@deffnx primitive set-port-column! [input-port] column
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[ports.c:1252]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings \"standard input\", \"standard output\" and \"standard error\""
when called on the current input, output and error ports respectively.
[ports.c:1267]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[ports.c:1281]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[ports.c:1384]

(pipe)
Returns a newly created pipe: a pair of ports which are linked
together on the local machine.  The CAR is the input port and
the CDR is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[posix.c:185]

(getgroups)
Returns a vector of integers representing the current supplimentary group IDs.
[posix.c:205]

(getpw user)
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[posix.c:244]

(setpw arg)
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[posix.c:298]

(getgr name)
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[posix.c:317]

(setgr arg)
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[posix.c:358]

(kill pid sig)
Sends a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[posix.c:394]

(waitpid pid options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped.  Normally it will
suspend the calling process until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[posix.c:442]

(status:exit-val status)
Returns the exit status value, as would be
set if a process , upda overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets the revealed count for a port to a given value.
The return value is unspecified.
[ports.c:536]

(port-mode port)
Returns the port modes associated with the open port @var{port}.  These
will not necessarily be identical to the modes used when the port was
opened, since modes such as \"append\" which are used only during
port creation are not retained.
[ports.c:579]

(close-port port)
Close the specified port object.  Returns @code{#t} if it successfully
closes a port or @code{#f} if it was already
closed.  An exception may be raised if an error occurs, for example
when flushing buffered output.
See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:616]

(close-input-port port)
Close the specified input port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:644]

(close-output-port port)
Close the specified output port object.  The routine has no effect if
the file has already been closed.  An exception may be raised if an
error occurs.  The value returned is unspecified.

See also @ref{Ports and File Descriptors, close}, for a procedure
which can close file descriptors.
[ports.c:659]

(close-all-ports-except ports)
Close all open file ports used by the interpreter
except for those supplied as arguments.  This procedure
is intended to be used before an exec call to close file descriptors
which are not needed in the new process.
[ports.c:674]

(input-port? x)
Returns @code{#t} if @var{x} is an input port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:712]

(output-port? x)
Returns @code{#t} if @var{x} is an output port, otherwise returns
@code{#f}.  Any object satisfying this predicate also satisfies
@code{port?}.
[ports.c:725]

(port-closed? port)
Returns @code{#t} if @var{port} is closed or @code{#f} if it is open.
[ports.c:738]

(eof-object? x)
Returns @code{#t} if @var{x} is an end-of-file object; otherwise
returns @code{#f}.
[ports.c:749]

(force-output port)
Flush the specified output port, or the current output port if @var{port}
is omitted.  The current output buffer contents are passed to the
underlying port implementation (e.g., in the case of fports, the
data will be written to the file and the output buffer will be cleared.)
It has no effect on an unbuffered port.

The return value is unspecified.
[ports.c:763]

(flush-all-ports)
Equivalent to calling @code{force-output} on
all open output ports.  The return value is unspecified.
[ports.c:781]

(read-char port)
Returns the next character available from @var{port}, updating
@var{port} to point to the following character.  If no more
characters are available, an end-of-file object is returned.
[ports.c:799]

(peek-char port)
Returns the next character available from @var{port},
@emph{without} updating @var{port} to point to the following
character.  If no more characters are available, an end-of-file object
is returned.@footnote{The value returned by a call to @code{peek-char}
is the same as the value that would have been returned by a call to
@code{read-char} on the same port.  The only difference is that the very
next call to @code{read-char} or @code{peek-char} on that
@var{port} will return the value returned by the preceding call to
@code{peek-char}.  In particular, a call to @code{peek-char} on an
interactive port will hang waiting for input whenever a call to
@code{read-char} would have hung.}
[ports.c:1032]

(unread-char cobj port)
Place @var{char} in @var{port} so that it will be read by the
next read operation.  If called multiple times, the unread characters
will be read again in last-in first-out order.  If @var{port} is
not supplied, the current input port is used.
[ports.c:1053]

(unread-string str port)
Place the string @var{str} in @var{port} so that its characters will be
read in subsequent read operations.  If called multiple times, the
unread characters will be read again in last-in first-out order.  If
@var{port} is not supplied, the current-input-port is used.
[ports.c:1076]

(seek object offset whence)
Sets the current position of @var{fd/port} to the integer @var{offset},
which is interpreted according to the value of @var{whence}.

One of the following variables should be supplied
for @var{whence}:
@defvar SEEK_SET
Seek from the beginning of the file.
@end defvar
@defvar SEEK_CUR
Seek from the current position.
@end defvar
@defvar SEEK_END
Seek from the end of the file.
@end defvar

If @var{fd/port} is a file descriptor, the underlying system call is
@code{lseek}.  @var{port} may be a string port.

The value returned is the new position in the file.  This means that
the current position of a port can be obtained using:
@smalllisp
(seek port 0 SEEK_CUR)
@end smalllisp
[ports.c:1112]

(truncate-file object length)
Truncates the object referred to by @var{obj} to at most @var{size} bytes.
@var{obj} can be a string containing a file name or an integer file
descriptor or a port.  @var{size} may be omitted if @var{obj} is not
a file name, in which case the truncation occurs at the current port.
position.

The return value is unspecified.
[ports.c:1153]

(port-line port)
Return the current line number for PORT.
[ports.c:1207]

(set-port-line! port line)
Set the current line number for PORT to LINE.
[ports.c:1218]

(port-column port)
@deffnx primitive port-line [input-port]
Return the current column number or line number of @var{input-port},
using the current input port if none is specified.  If the number is
unknown, the result is #f.  Otherwise, the result is a 0-origin integer
- i.e. the first character of the first line is line 0, column 0.
(However, when you display a file position, for example in an error
message, we recommand you add 1 to get 1-origin integers.  This is
because lines and column numbers traditionally start with 1, and that is
what non-programmers will find most natural.)
[ports.c:1239]

(set-port-column! port column)
@deffnx primitive set-port-column! [input-port] column
Set the current column or line number of @var{input-port}, using the
current input port if none is specified.
[ports.c:1252]

(port-filename port)
Return the filename associated with @var{port}.  This function returns
the strings \"standard input\", \"standard output\" and \"standard error\""
when called on the current input, output and error ports respectively.
[ports.c:1267]

(set-port-filename! port filename)
Change the filename associated with @var{port}, using the current input
port if none is specified.  Note that this does not change the port's
source of data, but only the value that is returned by
@code{port-filename} and reported in diagnostic output.
[ports.c:1281]

(%make-void-port mode)
Create and return a new void port.  A void port acts like
/dev/null.  The @var{mode} argument
specifies the input/output modes for this port: see the
documentation for @code{open-file} in @ref{File Ports}.
[ports.c:1384]

(pipe)
Returns a newly created pipe: a pair of ports which are linked
together on the local machine.  The CAR is the input port and
the CDR is the output port.  Data written (and flushed) to the
output port can be read from the input port.
Pipes are commonly used for communication with a newly
forked child process.  The need to flush the output port
can be avoided by making it unbuffered using @code{setvbuf}.

Writes occur atomically provided the size of the data in
bytes is not greater than the value of @code{PIPE_BUF}
Note that the output port is likely to block if too much data
(typically equal to @code{PIPE_BUF}) has been written but not
yet read from the input port
[posix.c:185]

(getgroups)
Returns a vector of integers representing the current supplimentary group IDs.
[posix.c:205]

(getpw user)
Look up an entry in the user database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getpwuid, getpwnam
or getpwent respectively.
[posix.c:244]

(setpw arg)
If called with a true argument, initialize or reset the password data
stream.  Otherwise, close the stream.  The @code{setpwent} and
@code{endpwent} procedures are implemented on top of this.
[posix.c:298]

(getgr name)
Look up an entry in the group database.  @var{obj} can be an integer,
a string, or omitted, giving the behaviour of getgrgid, getgrnam
or getgrent respectively.
[posix.c:317]

(setgr arg)
If called with a true argument, initialize or reset the group data
stream.  Otherwise, close the stream.  The @code{setgrent} and
@code{endgrent} procedures are implemented on top of this.
[posix.c:358]

(kill pid sig)
Sends a signal to the specified process or group of processes.

@var{pid} specifies the processes to which the signal is sent:

@table @r
@item @var{pid} greater than 0
The process whose identifier is @var{pid}.
@item @var{pid} equal to 0
All processes in the current process group.
@item @var{pid} less than -1
The process group whose identifier is -@var{pid}
@item @var{pid} equal to -1
If the process is privileged, all processes except for some special
system processes.  Otherwise, all processes with the current effective
user ID.
@end table

@var{sig} should be specified using a variable corresponding to
the Unix symbolic name, e.g.,

@defvar SIGHUP
Hang-up signal.
@end defvar

@defvar SIGINT
Interrupt signal.
@end defvar
[posix.c:394]

(waitpid pid options)
This procedure collects status information from a child process which
has terminated or (optionally) stopped.  Normally it will
suspend the calling process until this can be done.  If more than one
child process is eligible then one will be chosen by the operating system.

The value of @var{pid} determines the behaviour:

@table @r
@item @var{pid} greater than 0
Request status information from the specified child process.
@item @var{pid} equal to -1 or WAIT_ANY
Request status information for any child process.
@item @var{pid} equal to 0 or WAIT_MYPGRP
Request status information for any child process in the current process
group.
@item @var{pid} less than -1
Request status information for any child process whose process group ID
is -@var{PID}.
@end table

The @var{options} argument, if supplied, should be the bitwise OR of the
values of zero or more of the following variables:

@defvar WNOHANG
Return immediately even if there are no child processes to be collected.
@end defvar

@defvar WUNTRACED
Report status information for stopped processes as well as terminated
processes.
@end defvar

The return value is a pair containing:

@enumerate
@item
The process ID of the child process, or 0 if @code{WNOHANG} was
specified and no process was collected.
@item
The integer status value.
@end enumerate
[posix.c:442]

(status:exit-val status)
Returns the exit status value, as would be
set if a process , upda overridden by an explicit radix prefix in STRING
(e.g. \"#o177\"). If RADIX is not supplied, then the default
radix is 10. If string is not a syntactically valid notation
for a number, then `string->number' returns #f.  (r5rs)
[numbers.c:2804]

(number?)
scm_number_p
[numbers.c:2871]

(complex? x)
Return #t if X is a complex number, #f else.  Note that the
sets of real, rational and integer values form subsets of the
set of complex numbers, i. e. the predicate will also be
fulfilled if X is a real, rational or integer number.
[numbers.c:2878]

(real?)
scm_real_p
[numbers.c:2886]

(rational? x)
Return #t if X is a rational number, #f else.  Note that the
set of integer values forms a subset of the set of rational
numbers, i. e. the predicate will also be fulfilled if X is an
integer number.
[numbers.c:2893]

(integer? x)
Return #t if X is an integer number, #f else.
[numbers.c:2913]

(inexact? x)
Return #t if X is an inexact number, #f else.
[numbers.c:2937]

(> x y)
Return #t if the list of parameters is monotonically
increasing.
[numbers.c:3059]

(<= x y)
Return #t if the list of parameters is monotonically
non-decreasing.
[numbers.c:3070]

(>= x y)
Return #t if the list of parameters is monotonically
non-increasing.
[numbers.c:3081]

($expt z1 z2)
[numbers.c:3912]

($atan2 z1 z2)
[numbers.c:3924]

(make-rectangular real imaginary)
Return a complex number constructed of the given REAL and
IMAGINARY parts.
[numbers.c:3937]

(make-polar z1 z2)
Return the complex number Z1 * e^(i * Z2).
[numbers.c:3950]

(inexact->exact z)
Returns an exact number that is numerically closest to Z.
[numbers.c:4063]

(entity? obj)
[objects.c:360]

(operator? obj)
[objects.c:369]

(set-object-procedure! obj proc)
[objects.c:380]

(make-class-object metaclass layout)
[objects.c:438]

(make-subclass-object class layout)
[objects.c:452]

(object-properties obj)
@deffnx primitive procedure-properties obj
Return @var{obj}'s property list.
[objprop.c:63]

(set-object-properties! obj plist)
@deffnx primitive set-procedure-properties! obj alist
Set @var{obj}'s property list to @var{alist}.
[objprop.c:74]

(object-property obj key)
@deffnx primitive procedure-property obj key
Return the property of @var{obj} with name @var{key}.
[objprop.c:86]

(set-object-property! obj key val)
@deffnx primitive set-procedure-property! obj key value
In @var{obj}'s property list, set the property named @var{key} to
@var{value}.
[objprop.c:99]

(cons x y)
Returns a newly allocated pair whose car is @var{x} and whose cdr is
@var{y}.  The pair is guaranteed to be different (in the sense of
@code{eqv?}) from every previously existing object.
[pairs.c:62]

(pair? x)
Returns @code{#t} if @var{x} is a pair; otherwise returns @code{#f}.
[pairs.c:94]

(set-car! pair value)
Stores @var{value} in the car field of @var{pair}.  The value returned
by @code{set-car!} is unspecified.
[pairs.c:105]

(set-cdr! pair value)
Stores @var{value} in the cdr field of @var{pair}.  The value returned
by @code{set-cdr!} is unspecified.
[pairs.c:118]

(char-ready? port)
Returns @code{#t} if a character is ready on input @var{port} and
returns @code{#f} otherwise.  If @code{char-ready?} returns @code{#t}
then the next @code{read-char} operation on @var{port} is
guaranteed not to hang.  If @var{port} is a file port at end of
file then @code{char-ready?} returns @code{#t}.
@footnote{@code{char-ready?} exists to make it possible for a
program to accept characters from interactive ports without getting
stuck waiting for input.  Any input editors associated with such ports
must make sure that characters whose existence has been asserted by
@code{char-ready?} cannot be rubbed out.  If @code{char-ready?} were to
return @code{#f} at end of file, a port at end of file would be
indistinguishable from an interactive port that has no ready
characters.}
[ports.c:241]

(drain-input port)
Drains @var{PORT}'s read buffers (including any pushed-back characters)
and returns the contents as a single string.
[ports.c:276]

(current-input-port)
Returns the current input port.  This is the default port used by many
input procedures.  Initially, @code{current-input-port} returns the
value of @code{???}.
[ports.c:313]

(current-output-port)
Returns the current output port.  This is the default port used by many
output procedures.  Initially, @code{current-output-port} returns the
value of @code{???}.
[ports.c:324]

(current-error-port)
Return the port to which errors and warnings should be sent (the
@dfn{standard error} in Unix and C terminology).
[ports.c:334]

(current-load-port)
Return the current-load-port.
The load port is used internally by `primitive-load'.
[ports.c:344]

(set-current-input-port port)
@deffnx primitive set-current-output-port port
@deffnx primitive set-current-error-port port
Change the ports returned by @code{current-input-port},
@code{current-output-port} and @code{current-error-port}, respectively,
so that they use the supplied @var{port} for input or output.
[ports.c:357]

(set-current-output-port port)
Set the current default output port to PORT.
[ports.c:370]

(set-current-error-port port)
Set the current default error port to PORT.
[ports.c:384]

(port-revealed port)
Returns the revealed count for @var{port}.
[ports.c:523]

(set-port-revealed! port rcount)
Sets t