This is sizzle-ref.info, produced by makeinfo version 4.0 from
sizzle-ref.texi.

INFO-DIR-SECTION Sizzle Scheme Interpreter
START-INFO-DIR-ENTRY
* sizzle-ref: (sizzle-ref).     Sizzle reference manual.
END-INFO-DIR-ENTRY

   This file documents the Sizzle Scheme interpreter.

   Copyright (C) 1999, 2000 Martin Grabmueller

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.


File: sizzle-ref.info,  Node: Input and output,  Next: Regular expression functions,  Prev: Debugging Support,  Up: Builtin Procedures

Input and output
================

   The procedures in this section all deal with input and output of data
from and to various types of ports.  Unless otherwise noted, all the
procedures are always available in the interpreter.

 - Primitive procedure: call-with-input-file string proc
     Opens the file named STRING for input and calls PROC with the
     newly created input port as a single argument.

 - Primitive procedure: call-with-output-file string proc
     Opens the file named STRING for output and calls PROC with the
     newly created output port as a single argument.

 - Primitive procedure: input-port? obj
     Returns `#t' if OBJ is an input port, `#f' otherwise.

 - Primitive procedure: output-port? obj
     Returns `#t' if OBJ is an output port, `#f' otherwise.

 - Primitive procedure: current-input-port
     Returns the current default input port.

 - Primitive procedure: current-output-port
     Returns the current default output port.

 - Primitive procedure: current-error-port
     Returns the current default error output port.

 - Primitive procedure: set-current-input-port port
     Set PORT to be the value which subsequent calls to
     `current-input-port' will return.

 - Primitive procedure: set-current-output-port port
     Set PORT to be the value which subsequent calls to
     `current-output-port' will return.

 - Primitive procedure: set-current-error-port port
     Set PORT to be the value which subsequent calls to
     `current-error-port' will return.

 - Primitive procedure: with-input-from-file string thunk
     Opens the file named STRING for input and makes it the current
     default input port for the time PROC is called.

 - Primitive procedure: with-output-to-file string thunk
     Opens the file named STRING for output and makes it the current
     default output port for the time PROC is called.

 - Primitive procedure: with-error-to-file string thunk
     Opens the file named STRING for output and makes it the current
     default error port for the time PROC is called.

 - Primitive procedure: open-input-file filename
     Returns an input port connected to the file named FILENAME. An
     error is signalled if the file cannot be opened.

 - Primitive procedure: open-output-file filename
     Returns an ouput port connected to the file named FILENAME. An
     error is signalled if the file cannot be opened. If a file with
     the same name already exists, it will be overwritten.

 - Primitive procedure: close-port port
     Close the port PORT.

 - Primitive procedure: close-input-port port
     Close the input port PORT.  This is synonymous to `close-port',
     but is required by R5RS.

 - Primitive procedure: close-output-port port
     Close the output port PORT.  This is synonymous to `close-port',
     but is required by R5RS.

 - Primitive procedure: force-output port
     Force all buffered output to PORT to be actually written to the
     underlying file.  If PORT is a string port, nothing happens.  The
     return value is unspecified.

 - Primitive procedure: read
 - Primitive procedure: read port
     Read a scheme object from PORT.  PORT is omitted, the current
     input port is used.

 - Primitive procedure: read-char
 - Primitive procedure: read-char port
     Reads a character from PORT and returns it.  PORT is omitted, the
     current input port is used. Returns the end-of-file object on end
     of file.

 - Primitive procedure: unread-char char
 - Primitive procedure: unread-char char port
     Put the character CHAR back on the port PORT, so that it can bea
     read again with `read-char'.  PORT defaults to the value returned
     by `current-input-port', if not given.

 - Primitive procedure: peek-char
 - Primitive procedure: peek-char port
     Reads a character from PORT and return its without removing it
     from the port. A subsequent call to `read-char' on the same port
     will return the character again.  PORT is omitted, the current
     input port is used. Returns the end-of-file object on end of file.

 - Primitive procedure: char-ready?
 - Primitive procedure: char-ready? port
     Tests whether a character is available to be read from PORT and
     returns `#t' if it is, `#f' otherwise.  If PORT is not specified,
     the current input port is used.

 - Library procedure: read-line [port [handle-delim]]
     `read-line' reads a newline-terminated string from PORT.  The
     return value depends on the value of HANDLE-DELIM, which may be
     one of the symbols `trim', `concat', `peek' and `split'.  If it is
     `trim' (the default), the trailing newline is removed and the
     string is returned.  If `concat', the string is returned with the
     trailing newline intact.  If `peek', the newline is left in the
     input port buffer and the string is returned.  If `split', the
     newline is split from the string and `read-line' returns a pair
     consisting of the truncated string and the newline.

     This procedure is not supported when the option `-n,
     --no-system-init-file' is passed to the interpreter, or if the
     system startup file is not found.

 - Primitive procedure: %read-delimited! delims buf gobble? [port start
          end]
     Read characters from PORT into BUF until one of the characters in
     the DELIMS string is encountered.  If GOBBLE?  is true, store the
     delimiter character in BUF as well; otherwise, discard it.  If
     PORT is not specified, use the value returned by
     `current-input-port'.  If START or END are specified, store data
     only into the substring of BUF bounded by START and 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 EOF-OBJECT; if the
     buffer was filled without encountering a delimiter, this value is
     #F.

 - Primitive procedure: write-line obj [port]
     Display OBJ and a newline character to PORT.  If PORT is not
     specified, `(current-output-port)' is used.  This function is
     equivalent to:
          (display obj [port])
          (newline [port])

 - Primitive procedure: seek port offset whence
     Change the position of the file pointer for PORT. OFFSET is used
     to calculate the new file offset, depending on WHENCE.  Three
     variable may be used for values to give as WHENCE.
    `SEEK_SET'
          OFFSET is used as the new file offset.

    `SEEK_CUR'
          OFFSET is added to the current offset to yield the new file
          offset.

    `SEEK_END'
          OFFSET is subtracted from the file length to yield the new
          file offset.  PORT may also be a string port, which means
     that the read/write pointer for the string port will be modified.

     The return value is the new offset of the file pointer.

 - Primitive procedure: ftell port
     Return the current offset of the file pointer of PORT, which may
     be a file or string port.

 - Primitive procedure: eof-object? obj
     Returns `#t' if OBJ is the end-of-file object, `#f' otherwise.

 - Primitive procedure: port-closed? port
     Returns `#t' if PORT is a closed port, `#f' otherwise.

 - Primitive procedure: display obj
 - Primitive procedure: display obj port
     Print the textual representation of OBJ to PORT.  OBJ is not
     quoted when printing. `display''s return value is unspecified. If
     PORT is omitted, the current output port is used.

 - Primitive procedure: write obj
 - Primitive procedure: write obj port
     Print the textual representation of OBJ to PORT.  OBJ is
     quotedwhen printing. `write''s return value is unspecified. If
     PORT is omitted, the current output port is used.

 - Primitive procedure: write-char char
 - Primitive procedure: write-char char port
     Write CHAR to PORT. The actual character code of CHAR is written,
     not its read syntax. `write-char''s return value is unspecified.
     If PORT is omitted, the current output port is used.

 - Primitive procedure: newline
 - Primitive procedure: newline port
     Simply prints a newline character to PORT, thus ending the current
     output line.  The same can be achieved by printing a newline
     character using the function `display'.  `newline''s return value
     is unspecified. If PORT is omitted, the current output port is
     used.

 - Primitive procedure: call-with-input-string string proc
     Create an input string port which will return the contents of
     STRING and call PROC, passing the newly created string port as the
     argument.

 - Primitive procedure: call-with-output-string proc
     Call PROC with a string port as the argument and return all data
     which was written to the string port while PROC was executing as a
     string.

 - Primitive procedure: with-input-from-string string thunk
     Call THUNK with the current input port connected to a string port
     which delivers the contents of STRING.

 - Primitive procedure: with-output-to-string thunk
     Call THUNK and return a string consisting of all data which was
     written to the current output port during execution of THUNK.

 - Primitive procedure: with-error-to-string thunk
     Call THUNK and return a string consisting of all data which was
     written to the current error port during execution of THUNK.

 - Primitive procedure: open-input-string string
     Takes STRING and returns an input port that delivers characters
     from the string.  The port can be closed by `close-input-port',
     though its storage will be reclaimed by the garbage collector if it
     becomes inaccessible.

 - Primitive procedure: open-output-string
     Returns an output port that will accumulate characters for
     retrieval by `get-output-string'.  The port can be closed by
     `close-output-port', though its storage will be reclaimed by the
     garbage collector if it becomes inaccessible.

 - Primitive procedure: get-output-string output-port
     Given an output port created with `open-output-string', returns a
     string consisting of the characters that have been output to the
     port so far.

 - Primitive procedure: with-input-from-port port thunk
     Call THUNK, but while THUNK is evaluating, redirect all input from
     the input port PORT.

 - Primitive procedure: with-output-to-port port thunk
     Call THUNK and redirect all output sent to the current output port
     to PORT while THUNK is evaluating.

 - Primitive procedure: with-error-to-port port thunk
     Call THUNK and redirect all output sent to the current error port
     to PORT while THUNK is evaluating.

 - Primitive procedure: port-line
 - Primitive procedure: port-line port
     Return the current line number of the port PORT.  If PORT is not
     specified, the current input port is used.

 - Primitive procedure: set-port-line! port n
     Set the current line number of the port PORT to the value of N,
     which must be an integer value.  The return value is not specified.

 - Primitive procedure: port-column
 - Primitive procedure: port-column port
     Return the current line column number of the port PORT.  If PORT
     is not specified, the current input port is used.

 - Primitive procedure: set-port-column! port n
     Set the current column number of the port PORT to the value of N,
     which must be an integer value.  The return value is not specified.

 - Primitive procedure: port-filename
 - Primitive procedure: port-filename port
     Return the file name of the port PORT.  If PORT is not specified,
     the current input port is used.

 - Primitive procedure: set-port-filename! port s
     Set the file name of the port PORT to the value of S, which must
     be an string value.  The return value is not specified.

 - Primitive procedure: isatty? [port]
     Return `#t', if PORT is a tty, `#f' otherwise.  PORT defaults to
     the current input port.

 - Primitive procedure: object->string obj
     Return a string with the characters `display' would produce when
     printing OBJ.


File: sizzle-ref.info,  Node: Regular expression functions,  Next: System interface functions,  Prev: Input and output,  Up: Builtin Procedures

Regular expression functions
============================

   Sizzle supports Posix regular expressions.  This section documents
all functions provided to match text using regular expressions.

   Note that Posix regular expressions only support matching of strings
which do not include null bytes.

   Regular expression operations are not available if the Sizzle library
was configured with the `--disable-regexp' option or if no usable
regular expression matching library was found on configuration time.

 - Primitive procedure: regexp? obj
     Returns `#t' if OBJ is a compiled regular expression object, `#f'
     otherwise.

 - Primitive procedure: make-regexp string flags ...
     Create a compiled regular expression object which represents the
     string STRING.  The following additional arguments can be passed to
     control regular expression compilation:
    `regexp/icase'
          The matching is performed case-insensitively.

    `regexp/extended'
          Support extended Posix regular expressions (this is the
          default).

    `regexp/basic'
          Do not support extended Posix regular expressions.

    `regexp/newline'
          Treat a newline in the matched string as beginning/end of the
          string as far as the beginning-of-line and end-of-line
          operators are concerned.

 - Primitive procedure: regexp-exec rx string [start [flags]]
     Match the regular expression RX against STRING.  If START is
     given, start matching at that position.  Flags may be a mask of
     the following constants:
    `regexp/notbol'
          The match-beginning-of-line operator always fails to match.

    `regexp/noteol'
          The end-beginning-of-line operator always fails to match.


File: sizzle-ref.info,  Node: System interface functions,  Next: Network Procedures,  Prev: Regular expression functions,  Up: Builtin Procedures

System interface functions
==========================

   The Posix standard and many traditional Unix versions define a lot of
functions which are useful for systems programming.  Some of the most
useful functions have been included into Sizzle, so it can be used for
basic system programming tasks as well as all other uses.

   Not all functionality documented in this section is available on all
platforms.  `fork', for example cannot be implemented efficiently under
Windoze.  Primitives, which do not function properly on the system
Sizzle was compiled on, will throw a `not-available' exception when
called.

   Except when otherwise noted, procedures in this section are not
available when Sizzle was configured with the `--disable-posix' option.
You also need to perform a `(use-modules (core posix))' call to make
these procedures available.

 - Primitive procedure: command-line
     Returns a list containing the command line arguments passed to the
     interpreter.  Note that if you invoke a Sizzle script with the `-s
     SCRIPT' command line option, only the script name (as the first
     element in the command line) and the arguments after `SCRIPT' are
     contained in the command line list.

     This procedure is always available.

 - Primitive procedure: system [command]
     Execute the command COMMAND using the command line shell and
     return the exit code of the given command.  If no COMMAND is
     given, return #t if a command processor is available and #f
     otherwise.  This function may raise a `system-error' exception if
     an error occurs.  The return value is the exit code of the child
     process.

 - Primitive procedure: getenv string
     Returns the value of the environment variable called STRING if
     defined, and `#f' otherwise.

     This procedure is always available.

 - Primitive procedure: putenv string
     Insert the string STRING into the process environment.  STRING
     must be of the form name=value.  The return value is not specified.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getcwd
     Returns a string which denotes the current working directory.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: chdir string
     Change the current working directory to STRING.  A `system-error'
     exception will be raised if the directory STRING cannot be changed
     to.  The return value is not specified.

 - Primitive procedure: getpid
     Returns the process identifier (pid) of the running Sizzle process.

 - Primitive procedure: getppid
     Returns the parent process identifier of the running Sizzle
     process.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getuid
     Returns the user identifier (uid) of the user running the current
     Sizzle process.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: setuid uid
     Set the user identifier of the current Sizzle process to UID.
     Only the superuser can do that.  This function may raise a
     `system-error' exception if an error occurs.  The return value is
     not specified.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: geteuid
     Returns the effective user identifier of the running Sizzle
     process.  A `system-error' exception may be raised if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: seteuid euid
     Set the effective user identifier of the current Sizzle process to
     EUID.  This function may raise a `system-error' exception if an
     error occurs.  The return value is not specified.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getgid
     Returns the group identifier of the running Sizzle process.  A
     `system-error' exception may be raised if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: setgid gid
     Set the group identifier of the running Sizzle process to GID.  A
     `system-error' exception may be raised if an error occurs.  The
     return value is not specified.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getegid
     Returns the effective group identifier of the running Sizzle
     process.  A `system-error' exception may be raised if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: setegid egid
     Set the effective group identifier of the running Sizzle process to
     EGID.  A `system-error' exception may be raised if an error
     occurs. The return value is not specified.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getpgid pid
     Returns the process group identifier of the process specified by
     PID.  If PID is zero, the process identifier of the current
     process is used.  This function may raise a `system-error'
     exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getpgrp
     This is equivalent to (getpgid 0).

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getpwnam name
     Returns a vector containing the broken out fields of a line from
     `/etc/passwd' for the entry that matches the user name NAME. This
     function may raise a `system-error' exception if an error occurs.
     The returned vector contains the fields:
    `username'
          Login name

    `password'
          Crypted password or `x' if using shadow passwords

    `uid'
          User identifier

    `gid'
          group identifier

    `gecos'
          Full name, maybe additional information

    `dir'
          Login directory

    `shell'
          Login shell

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: getpwuid uid
     Returns a vector containing the broken out fields of a line from
     `/etc/passwd' for the entry that matches the user identifier UID.
     This function may raise a `system-error' exception if an error
     occurs.  The returned vector has the same format as for `getpwnam'.

     This procedure is only available if supported by the underlying C
     library.

 - Library procedure: pw:name vec
 - Library procedure: pw:passwd vec
 - Library procedure: pw:uid vec
 - Library procedure: pw:gid vec
 - Library procedure: pw:gecos vec
 - Library procedure: pw:dir vec
 - Library procedure: pw:shell vec
     Accessor procedures for the fields of the vector returned by
     `getpwnam' and `getpwuid'.

 - Primitive procedure: getgroups
     Returns a vector containing all groups the current user belongs to.
     This function may raise a `system-error' exception if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: stat filename
     Returns information about the specified file.  You do not need any
     access rights to the file to get this information but you need
     search rights to all directories named in the path leading to the
     file.  This function may raise a `system-error' exception if an
     error occurs.  The returned vector has the following fields:
    `dev'
          Device the file is located on.

    `ino'
          Inode number of the file.

    `mode'
          The file mode and permissions.

    `nlink'
          Number of hard links to the file.

    `uid'
          User identifier of the file owner.

    `gid'
          Group identifier of the file owner

    `rdev'
          Device type (if inode device)

    `size'
          Total size in bytes

    `atime'
          Time of last access

    `mtime'
          Time of last modification

    `ctime'
          Time of last change

    `blksize'
          Block size for the filesystem the file is on

    `blocks'
          Number of blocks the file allocates

    `type'
          The type of the file as a symbol, which may be any of
          `regular', `directory', `symlink', `block-special',
          `char-special', `fifo', `socket' or `unknown'.

    `perms'
          Permissions of the file.  This is the file mode without the
          file type bits.  The file mode is a bitset which can be
     tested by logically combining it with one or more of the following
     constants:
    `S_ISUID'
          Set user identifier

    `S_ISGID'
          Set group identifier

    `S_IRWXU'
          User (file owner) has read, write and execute permission

    `S_IRUSR'
          User has read permission

    `S_IWUSR'
          User has write permission

    `S_IXUSR'
          User has execute permission

    `S_IRWXG'
          Group has read, write and execute permission

    `S_IRGRP'
          Group has read permission

    `S_IWGRP'
          Group has write permission

    `S_IXGRP'
          Group has execute permission

    `S_IRWXO'
          Others have read, write and execute permission

    `S_IROTH'
          Others have read permission

    `S_IWOTH'
          Others have write permission

    `S_IXOTH'
          Others have execute permission

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: lstat filename
     Like `stat', but does not follow symbolic links.

     This procedure is only available if supported by the underlying C
     library.

 - Library procedure: stat:dev vec
 - Library procedure: stat:ino vec
 - Library procedure: stat:mode vec
 - Library procedure: stat:nlink vec
 - Library procedure: stat:uid vec
 - Library procedure: stat:gid vec
 - Library procedure: stat:rdev vec
 - Library procedure: stat:size vec
 - Library procedure: stat:atime vec
 - Library procedure: stat:mtime vec
 - Library procedure: stat:ctime vec
 - Library procedure: stat:blksize vec
 - Library procedure: stat:blocks vec
 - Library procedure: stat:type vec
 - Library procedure: stat:perms vec
     These are accessor functions for extracting fields from the vectors
     returned by `stat' and `lstat'.

 - Primitive procedure: access? filename mode
     Checks whether the process would be allowed to read, write or test
     for existence of the file (or other file system object) whose name
     is pathname.  If pathname is a symbolic link permissions of the
     file referred to by this symbolic link are tested.  Returns `#t' if
     access is permitted, `#f' otherwise.  This function may raise a
     `system-error' exception if an error occurs.  MODE is a mask of
     one or more of the following constants:
    `R_OK'
          Test for read permission

    `W_OK'
          Test for write permission

    `X_OK'
          Test for execute permission

    `F_OK'
          Test for file existence `access?' is only successful if all
     permissions are granted.

 - Primitive procedure: sys:pipe
     Creates a pair of file descriptors, pointing to a pipe inode. The
     car of the returned pair is a file descriptor for reading, the cdr
     is a file descriptor for writing.  This function may raise a
     `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: open-fdes filename flags [mode]
     Attempts to open the file called FILENAME and returns a file
     descriptor.  FLAGS is a mask of one or more of the following:
    `O_RDONLY'
          Open the file read only.

    `O_WRONLY'
          Open the file write only.

    `O_RDWR'
          Open the file for reading and writing.

    `O_CREAT'
          If the file does not exist it will be created.

    `O_EXCL'
          When used with `O_CREAT', if the file already exists it is an
          error and the open will fail.

    `O_NOCTTY'
          If pathname refers to a terminal device - see tty(4) - it
          will not become the process's controlling terminal even if
          the process does not have one.

    `O_TRUNC'
          If the file already exists it will be truncated.

    `O_APPEND'
          The file is opened in append mode.  Initially, and before
          each write, the file pointer is positioned at the end of the
          file, as if with lseek.

    `O_NONBLOCK'
          Open the file in non-blocking mode, which means that
          operations on the file do not wait for completion.

    `O_NDELAY'
          The same as `O_NONBLOCK'.

    `O_SYNC'
          Writes to the file will be immediately written to disk.  If
     `O_CREAT' is given and the file will be created, the additional
     argument MODE must be given, which denotes the file permission the
     new file will have.  MODE is a mask of the permission constants
     listed in the description of `stat'.

     This function may raise a `system-error' exception if an error
     occurs.

 - Primitive procedure: sys:creat mode
     This is equivalent to `open' with flags equal to `(logior O_CREAT
     O_WRONLY O_TRUNC)'.

 - Primitive procedure: close fd
     Closes a file descriptor, if FD is an integer, so that it no
     longer refers to any file and may be reused, or simply closes FD
     of it is a port.  This function may raise a `system-error'
     exception if an error occurs.

 - Primitive procedure: sys:write fd u8vec count
     Write COUNT bytes from the homogenous unsigned 8-bit vector U8VEC
     to the file referenced by the file descriptor FD.  Returns the
     number of bytes actually written.  This function may raise a
     `system-error' exception if an error occurs.

     This procedure is only available if homogenous vectors were enable
     on configuration time.

 - Primitive procedure: sys:read fd count
     Read COUNT bytes from the file referenced by the file descriptor
     FD and returns a homogenous unsigned 8-bit vector containing those
     bytes.  This function may raise a `system-error' exception if an
     error occurs.

     This procedure is only available if homogenous vectors were enable
     on configuration time.

 - Primitive procedure: sys:read! fd u8vec count
     Read COUNT bytes from the file referenced by the file descriptor
     FD and stores them into the homogenous unsigned 8-bit vector
     U8VEC.  The return value is not specified.  This function may
     raise a `system-error' exception if an error occurs.

     This procedure is only available if homogenous vectors were enable
     on configuration time.

 - Primitive procedure: unlink filename
     Deletes a name from the filesystem. If that name was the last link
     to a file and no processes have the file open the file is deleted
     and the space it was using is made available for reuse.  The
     return value is not specified.  This function may raise a
     `system-error' exception if an error occurs.

 - Primitive procedure: link oldpath newpath
     Creates a new link (also known as a hard link) to an existing
     file.  If NEWPATH exists it will not be overwritten.  The return
     value is not specified.  This function may raise a `system-error'
     exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: symlink oldpath newpath
     Creates a new symbolic link to an existing file.  If NEWPATH
     exists it will not be overwritten.  The return value is not
     specified.  This function may raise a `system-error' exception if
     an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: rename oldpath newpath
     Renames a file, moving it between directories if required.
     OLDPATH and NEWPATH must refer to the same file system.  The
     return value is not specified.  This function may raise a
     `system-error' exception if an error occurs.

 - Primitive procedure: readlink filename
     Returns the name of the file the link FILENAME is referring to.
     This function may raise a `system-error' exception if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: chmod path mode
     The mode of the file given by PATH is changed to MODE.  MODE is a
     mask made from the `S_I...' constants listed in the description of
     `stat'.  This function may raise a `system-error' exception if an
     error occurs.

 - Primitive procedure: chown path uid gid
     Set the user identifier and group identifier of the file PATH to
     UID and GID.  If any of UID or GID is equal to -1, that component
     of PATH's ownership is not changed.  This function may raise a
     `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: primitive-exit [status]
     Terminate the current process without performing any cleanup.  The
     exit status is STATUS, which defaults to 0 if not specified.  This
     procedure has no return value, because it never returns.

 - Primitive procedure: fork
     Creates a child process that differs from the parent process only
     in its process identifier and parent process identifier, and in
     the fact that resource utilizations are set to 0.  File locks and
     pending signals are not inherited.  This function may raise a
     `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: kill pid sig
     Sends any signal to any process group or process.  If PID is
     positive, then signal SIG is sent to PID.

     If PID equals 0, then SIG is sent to every process in the process
     group of the current process.  If PID equals -1, then SIG is sent
     to every process except for the first one, from higher numbers in
     the process table to lower.  If PID is less than -1, then SIG is
     sent to every process in the process group -PID.  If SIG is 0,
     then no signal is sent, but error checking is still performed.

     This function may raise a `system-error' exception if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: wait
     Waits for any child process to terminate and returns a pair whose
     car is the process id of the child and whose cdr is the exit code.
     This function may raise a `system-error' exception if an error
     occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: waitpid pid [options]
     Waits until child process PID has terminated.  For usage of the
     OPTIONS argument, refer to the `waitpid' man page.  This function
     may raise a `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: sleep n
     Suspend the running process for N seconds, or until a signal wakes
     up the process.  This function may raise a `system-error' exception
     if an error occurs.

 - Primitive procedure: execl filename args
     Execute the file FILENAME, passing the list ARGS as command line
     options.  This function may raise a `system-error' exception if an
     error occurs.

 - Primitive procedure: execlp filename args
     Like `execl', but search the path for FILENAME.

 - Primitive procedure: execle filename args env
     Like `execl', but pass the environment list ENV together with the
     command line arguments ARGS to the process.

 - Primitive procedure: nice inc
     Change the current process priority by amount INC.  You must be
     the system administrator to pass a negative INC.  This function
     may raise a `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: sync
     Force all dirty block from the cache of the operating system to be
     written to the disks.  This function may raise a `system-error'
     exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: uname
     Return a vector containing information about the system. This
     function may raise a `system-error' exception if an error occurs.
     The returned vector contains the following fields:
    `sysname'
          The name of the operating system.

    `nodename'
          The name of the host.

    `release'
          The operating system release.

    `version'
          The operating system version.

    `machine'
          The machine architecture.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: utime filename [timelist]
     If TIMELIST is omitted, set the access and modification time for
     the file FILENAME to the current time.  Otherwise, TIMELIST must
     be a list of two integer values, which will be used to set the
     access and modification time of FILENAME.  This function may raise
     a `system-error' exception if an error occurs.

 - Primitive procedure: tmpnam
     The `tmpnam' procedure generates a unique temporary filename in the
     standard directory for temporary files (normally `/tmp').

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: tmpfile
     The `tmpfile' procedure generates a unique temporary filename in
     the standard directory for temporary files (normally `/tmp') .  The
     temporary file is then opened in binary read/write (w+b) mode.
     The file will be automatically deleted when it is closed or the
     program terminates.  The return value is a port open for input and
     output.  This function may raise a `system-error' exception if an
     error occurs.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: umask [mask]
     `umask' sets the umask to `(logand mask #o777)'.  The umask is
     used by open(2) to set initial file permissions on a newly-created
     file.  Specifically, permissions in the umask are turned off from
     the mode argument to open(2) (so, for example, the common umask
     default value of 022 results in new files being created with
     permissions 0666 & ~022 = 0644 = rw-r-r- in the usual case where
     the mode is specified as 0666).  If MASK is not given, the current
     umask value is returned, without changing the umask for the
     process.

 - Primitive procedure: strftime format vec
     Format the time-representing vector VEC according to the format
     specifier FORMAT to a string and return that string.  For details
     of the format specified, have a look at `man strftime'.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: strptime format string
     Parse the string STRING according to the format specifier FORMAT.
     Check out `man strptime' for the format specification.  Returns a
     pair consisting of a time vector and the number of characters of
     STRING which have been used up when parsing.  This procedure is
     essentialy the counterpart of `strftime'.

     This procedure is only available if supported by the underlying C
     library.

 - Primitive procedure: gmtime x
     Split up the time object X, which represents the current time in
     standard Unix convention in seconds since January 1, 1970.
     Returns a vector with the split up fields of the time.  The times
     in the vector is in Coordinated Universal Time. The result vector
     contains the following fields:
    seconds

    minutes

    hours

    day of month

    month

    year

    day of the week

    day in the year

    daylight saving time

    time zone offset

    time zone name or `#f' if not specified

 - Primitive procedure: localtime x
     Returns X converted to local time in a vector of the format
     defined in the description of `gmtime'.

     Bug: Right now time zone offset and time zone names are not
     correctly set by `localtime'.

 - Library procedure: tm:sec timevec
 - Library procedure: tm:min timevec
 - Library procedure: tm:hour timevec
 - Library procedure: tm:mday timevec
 - Library procedure: tm:month timevec
 - Library procedure: tm:year timevec
 - Library procedure: tm:wday timevec
 - Library procedure: tm:yday timevec
 - Library procedure: tm:isdst timevec
 - Library procedure: tm:zoff timevec
 - Library procedure: tm:zname timevec
     These procedure return the fields their names stand for from the
     time vector TIMEVEC, which must have the format documented in the
     decription for `gmtime'.

 - Primitive procedure: current-time
     Return the current time in an integer, represented in the number of
     seconds elapsed since 00:00:00 on January 1, 1970, Coordinated
     Universal Time (UTC).  The value returned by this procedure can be
     used in calls to `gmtime' or `localtime', which split up the time
     value into its various parts.

 - Primitive procedure: directory-files dirname
     Return a list containing all files in the directory DIRNAME.  This
     procedure may throw a `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: fcntl fdesc cmd [arg]
     `fcnt' performs one of various operations on the file descriptor
     FD.  The following commands are possible:
    `F_DUPFD'
          Makes arg be a copy of fd, closing FDESC first if necessary.

    `F_GETFD'
          Read the close-on-exec flag.  If the low-order bit is 0, the
          file will remain open across exec, otherwise it will be
          closed.

    `F_SETFD'
          Set the close-on-exec flag to the value specified by arg
          (only the least significant bit is used).

    `F_GETFL'
          Read the descriptor's flags (all flags (as set by open(2)) are
          returned).

    `F_SETFL'
          Set the descriptor's flags to the value specified by arg.
          Only `O_APPEND' and `O_NONBLOCK' may be set.  The flags are
          shared between copies (made with dup etc.) of the same file
          descriptor.

    `F_GETLK, F_SETLK, F_SETLKW'
          Manage discretionary file locks.  This command is not properly
          implemented in Sizzle right now.

    `F_GETLK'
          This command is not properly implemented in Sizzle right now.

    `F_SETLK'
          This command is not properly implemented in Sizzle right now.

    `F_SETLKW'
          This command is not properly implemented in Sizzle right now.

    `F_GETOWN'
          Get the process ID or process group currently receiving SIGIO
          and SIGURG signals for events on file descriptor fd.  Process
          groups are returned as negative values.

    `F_SETOWN'
          Set the process ID or process group that will receive `SIGIO'
          and `SIGURG' signals for events on file descriptor FD.
          Process groups are specified using negative values.

     This procedure is only available if supported by the underlying C
     library and (limited) under Windows.

 - Primitive procedure: fsync fdesc
     FDESC must be either a valid file descripor or a file port.  All
     pending output is written if FDESC is a file port.  The data
     buffered for the underlying file descriptor is then forced to be
     written to disk using the system call `fsync'.

     This procedure is only available if the `fsync()' system call is
     available and under Windows.

 - Primitive procedure: copy-file oldfile newfile
     Copy the file specified by OLDFILE to NEWFILE.  The return value
     is unspecified.

 - Primitive procedure: directory-stream? obj
     Return `#t' if OBJ is a directory stream, `#f' otherwise.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: opendir str
     Open the directory called STR and return a directory stream for
     that directory, which can be used in calls to `readdir',
     `closedir' and `rewinddir'.  This procedure may raise a
     `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: closedir stream
     Close the directory stream STREAM.  The return value is not
     specified.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: readdir stream
     Return the next filename from the directory stream STREAM, or the
     end-of-file object if all files have been read.  This procedure may
     raise a `system-error' exception if an error occurs.

     This procedure is only available if supported by the underlying C
     library and under Windows.

 - Primitive procedure: rewinddir stream
     Rewind the directory stream to the beginning, so that on the next
     call to `readdir', the first file from the stream will be read.
     The return value is not specified.

     This procedure is only available if supported by the underlying C
     library and under Windows.

