% Copyright 2005-2018 Cisco Systems, Inc. % % Licensed under the Apache License, Version 2.0 (the "License"); % you may not use this file except in compliance with the License. % You may obtain a copy of the License at % % http://www.apache.org/licenses/LICENSE-2.0 % % Unless required by applicable law or agreed to in writing, software % distributed under the License is distributed on an "AS IS" BASIS, % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % See the License for the specific language governing permissions and % limitations under the License. \chapter{Input/Output Operations\label{CHPTIO}} This chapter describes {\ChezScheme}'s generic port facility, operations on ports, and various {\ChezScheme} extensions to the standard set of input/output operations. See Chapter~\ref{TSPL:CHPTIO} of {\TSPLFOUR} or the Revised$^6$ Report on Scheme for a description of standard input/output operations. Definitions of a few sample generic ports are given in Section~\ref{SECTPORTEXAMPLES}. {\ChezScheme} closes file ports automatically after they become inaccessible to the program or when the Scheme program exits, but it is best to close ports explicitly whenever possible. \section{Generic Ports} {\ChezScheme}'s ``\index{generic port}generic port'' facility allows the programmer to add new types of textual ports with arbitrary input/output semantics. It may be used, for example, to define any of the built-in Common Lisp~\cite{Steele:common} stream types, i.e., \index{synonym streams}synonym streams, \index{broadcast streams}broadcast streams, \index{concatenated streams}concatenated streams, \index{two-way streams}two-way streams, \index{echo streams}echo streams, and \index{string streams}string streams. It may also be used to define more exotic ports, such as ports that represent windows on a bit-mapped display or ports that represent processes connected to the current process via pipes or sockets. Each port has an associated \emph{port handler}. A port handler is a procedure that accepts messages in an object-oriented style. Each message corresponds to one of the low-level Scheme operations on ports, such as \scheme{read-char} and \scheme{close-input-port} (but not \scheme{read}, which is defined in terms of the lower-level operations). Most of these operations simply call the handler immediately with the corresponding message. Standard messages adhere to the following conventions: the message name is the first argument to the handler. It is always a symbol, and it is always the name of a primitive Scheme operation on ports. The additional arguments are the same as the arguments to the primitive procedure and occur in the same order. (The port argument to some of the primitive procedures is optional; in the case of the messages passed to a handler, the port argument is always supplied.) The following messages are defined for built-in ports: \schemedisplay block-read \var{port} \var{string} \var{count} block-write \var{port} \var{string} \var{count} char-ready? \var{port} clear-input-port \var{port} clear-output-port \var{port} close-port \var{port} file-position \var{port} file-position \var{port} \var{position} file-length \var{port} flush-output-port \var{port} peek-char \var{port} port-name \var{port} read-char \var{port} unread-char \var{char} \var{port} write-char \var{char} \var{port} \endschemedisplay \noindent Additional messages may be accepted by user-defined ports. {\ChezScheme} input and output is normally buffered for efficiency. To support buffering, each input port contains an input buffer and each output port contains an output buffer. Bidirectional ports, ports that are both input ports and output ports, contain both input and output buffers. Input is not buffered if the input buffer is the empty string, and output is not buffered if the output buffer is the empty string. In the case of unbuffered input and output, calls to \scheme{read-char}, \scheme{write-char}, and similar messages cause the handler to be invoked immediately with the corresponding message. For buffered input and output, calls to these procedures cause the buffer to be updated, and the handler is not called under normal circumstances until the buffer becomes empty (for input) or full (for output). Handlers for buffered ports must \var{not} count on the buffer being empty or full when \scheme{read-char}, \scheme{write-char}, and similar messages are received, however, due to the possibility that (a) the handler is invoked through some other mechanism, or (b) the call to the handler is interrupted. In the presence of keyboard, timer, and other interrupts, it is possible for a call to a port handler to be interrupted or for the handler itself to be interrupted. If the port is accessible outside of the interrupted code, there is a possibility that the interrupt handler will cause input or output to be performed on the port. This is one reason, as stated above, that port handlers must not count on the input buffer being empty or output buffer being full when a \scheme{read-char}, \scheme{write-char}, or similar message is received. In addition, port handlers may need to manipulate the buffers only with interrupts disabled (using \scheme{with-interrupts-disabled}). Generic ports are created via one of the port construction procedures \scheme{make-input-port}, \scheme{make-output-port}, and \scheme{make-input/output-port} defined later in this chapter. Ports have seven accessible fields: \begin{description} \item[\var{handler},] accessed with \scheme{port-handler}; \item[\var{output-buffer},] accessed with \scheme{port-output-buffer}, \item[\var{output-size},] accessed with \scheme{port-output-size}, \item[\var{output-index},] accessed with \scheme{port-output-index}, \item[\var{input-buffer},] accessed with \scheme{port-input-buffer}, \item[\var{input-size},] accessed with \scheme{port-input-size}, and \item[\var{input-index},] accessed with \scheme{port-input-index}. \end{description} \noindent The output-size and output-index fields are valid only for output ports, and the input-size and input-index fields are valid only for input ports. The output and input size and index fields may be updated as well using the corresponding ``\scheme{set-\var{field}!}'' procedure. A port's output size determines how much of the port's output buffer is actually available for writing by \scheme{write-char}. The output size is often the same as the string length of the port's output buffer, but it can be set to less (but no less than zero) at the discretion of the programmer. The output index determines to which position in the port's buffer the next character will be written. The output index should be between $0$ and the output size, inclusive. If no output has occurred since the buffer was last flushed, the output index should be $0$. If the index is less than the size, \scheme{write-char} stores its character argument into the specified character position within the buffer and increments the index. If the index is equal to the size, \scheme{write-char} leaves the fields of the port unchanged and invokes the handler. A port's input size determines how much of the port's input buffer is actually available for reading by \scheme{read-char}. A port's input size and input index are constrained in the same manner as output size and index, i.e., the input size must be between $0$ and the string length of the input buffer (inclusive), and the input index must be between $0$ and the input size (inclusive). Often, the input size is less than the length of the input buffer because there are fewer characters available to read than would fit in the buffer. The input index determines from which position in the input buffer the next character will be read. If the index is less than the size, \scheme{read-char} extracts the character in this position, increments the index, and returns the character. If the index is equal to the size, \scheme{read-char} leaves the fields of the port unchanged and invokes the handler. The operation of \scheme{peek-char} is similar to that of \scheme{read-char}, except that it does not increment the input index. \scheme{unread-char} decrements the input index if it is greater than $0$, otherwise it invokes the handler. \scheme{char-ready?} returns \scheme{#t} if the input index is less than the input size, otherwise it invokes the handler. Although the fields shown and discussed above are logically present in a port, actual implementation details may differ. The current {\ChezScheme} implementation uses a different representation that allows \scheme{read-char}, \scheme{write-char}, and similar operations to be open-coded with minimal overhead. The access and assignment operators perform the conversion between the actual representation and the one shown above. Port handlers receiving a message must return a value appropriate for the corresponding operation. For example, a handler receiving a \scheme{read-char} message must return a character or eof object (if it returns). For operations that return unspecified values, such as \scheme{close-port}, the handler is not required to return any particular value. \section{File Options\label{SECTFILEOPTIONS}} The Revised$^6$ Report requires that the universe of a file-options enumeration set must include \scheme{no-create}, \scheme{no-fail}, and \scheme{no-truncate}, whose meanings are described within the description of the \scheme{file-options} syntax in Section~\ref{TSPL:SECTOPENINGFILES} of {\TSPLFOUR}. {\ChezScheme} defines a number of additional file options: \begin{description} \item[\var{compressed}:] An output file should be compressed when written; and a compressed input file should be decompressed when read. The compression format for output is determined by the \index{\scheme{compress-format}}\scheme{compress-format} parameter, while the compression format on input is inferred. The compression level, which is relevant only for output, is determined by the \index{\scheme{compress-level}}\scheme{compress-level} parameter. \item[\var{replace}:] For output files only, replace (remove and recreate) the existing file if it exists. \item[\var{exclusive}:] For output files only, lock the file for exclusive access. On some systems the lock is advisory, i.e., it inhibits access by other processes only if they also attempt to open exclusively. \item[\var{append}:] For output files only, position the output port at the end of the file before each write so that output to the port is always appended to the file. \item[\var{perm-set-user-id}:] For newly created output files under Unix-based systems only, set user-id bit. \item[\var{perm-set-group-id}:] For newly created output files under Unix-based systems only, set group-id bit. \item[\var{perm-sticky}:] For newly created output files under Unix-based systems only, set sticky bit. \item[\var{perm-no-user-read}:] For newly created output files under Unix-based systems only, do not set user read bit. (User read bit is set by default, unless masked by the process umask.) \item[\var{perm-no-user-write}:] For newly created output files under Unix-based systems only, do not set user write bit. (User write bit is set by default, unless masked by the process umask.) \item[\var{perm-user-execute}:] For newly created output files under Unix-based systems only, set user execute bit unless masked by process umask. (User execute bit is not set by default.) \item[\var{perm-no-group-read}:] For newly created output files under Unix-based systems only, do not set group read bit. (Group read bit is set by default, unless masked by the process umask.) \item[\var{perm-no-group-write}:] For newly created output files under Unix-based systems only, do not set group write bit. (Group write bit is set by default, unless masked by the process umask.) \item[\var{perm-group-execute}:] For newly created output files under Unix-based systems only, set group execute bit unless masked by process umask. (Group execute bit is not set by default.) \item[\var{perm-no-other-read}:] For newly created output files under Unix-based systems only, do not set other read bit. (Other read bit is set by default, unless masked by the process umask.) \item[\var{perm-no-other-write}:] For newly created output files under Unix-based systems only, do not set other write bit. (Other write bit is set by default, unless masked by the process umask.) \item[\var{perm-other-execute}:] For newly created output files under Unix-based systems only, set other execute bit unless masked by process umask. (Other execute bit is not set by default.) \end{description} \section{Transcoders\label{SECTTRANSCODERS}} The language of the Revised$^6$ Report provides three built-in codecs: a latin-1 codec, a utf-8 codec, and a utf-16 codec. {\ChezScheme} provides three additional codecs: a utf-16le codec, utf-16be codec, and an ``iconv'' codec for non-Unicode character sets. It also provides an alternative to the standard utf-16 codec that defaults to little-endian format rather than the default big-endian format. This section describes these codecs, plus a \scheme{current-transcoder} parameter that allows the programmer to determine the transcoder used for a textual port whenever the transcoder is implicit, as for \scheme{open-input-file} or \scheme{load}, along with the predicate \scheme{transcoder?}, which should be standard but is not. %---------------------------------------------------------------------------- \entryheader \formdef{utf-16-codec}{\categoryprocedure}{(utf-16-codec)} \formdef{utf-16-codec}{\categoryprocedure}{(utf-16-codec \var{endianness})} \formdef{utf-16le-codec}{\categoryprocedure}{(utf-16le-codec)} \formdef{utf-16be-codec}{\categoryprocedure}{(utf-16be-codec)} \returns a codec \listlibraries \endentryheader \var{endianness} must be the symbol \scheme{big} or the symbol \scheme{little}. The codec returned by \scheme{utf-16-codec} can be used to create and process data written UTF-16 format. When called without the \var{endianness} argument or with \var{endianness} \scheme{big}, \scheme{utf-16-codec} returns a codec for standard UTF-16 data, i.e., one that defaults to big-endian format if no byte-order mark (BOM) is found. When output is transcoded with a transcoder based on this codec, a BOM is emitted just before the first character written, and each character is written as a UTF-16 character in big-endian format. For input, a BOM is looked for at the start of the input and, if present, controls the byte order of the remaining UTF-16 characters. If no BOM is present, big-endian order is assumed. For input-output ports, the BOM is not emitted if the file is read before written, and a BOM is not looked for if the file is written before read. For textual ports created via \scheme{transcoded-port}, a BOM written or read via the transcoder appears at the beginning of the underlying data stream or file only if the binary port passed to \scheme{transcoded-port} is positioned at the start of the data stream or file. When the transcoder can determine this is the case, it sets a flag that causes \scheme{set-port-position!} to position the port beyond the BOM if an attempt is made to reposition the port to the start of the data stream or file, so that the BOM is preserved. When called with \var{endianness} \scheme{little}, \scheme{utf-16-codec} returns a codec that defaults to the little-endian format both for reading and for writing. For output-only streams or input/output streams that are written before read, the result is standard UTF-16, with a BOM that specifies little-endian format followed by characters in little-endian byte order. For input-only streams or input/output streams that are read before written, this codec allows programs to read from input streams that either begin with a BOM or are encoded in UTF-16LE format. This is particularly useful for handling files that might have been produced by older Windows applications that claim to produce UTF-16 files but actually produce UTF-16LE files. The Revised$^6$ Report version of \scheme{utf-16-codec} lacks the optional \var{endianness} argument. The codecs returned by \scheme{utf-16le-codec} and \scheme{utf-16be-codec} are used to read and write data in the UTF-16LE and UTF-16BE formats, i.e., UTF-16 with little-endian or big-endian byte order and no BOM. For output, these codecs are useful for controlling whether and where the BOM is emitted, since no BOM is emitted implicitly and a BOM can be emitted explicitly as an ordinary character. For input, these codecs are useful for processing files known to be in little-endian or big-endian format with no BOM. %---------------------------------------------------------------------------- \entryheader \formdef{iconv-codec}{\categoryprocedure}{(iconv-codec \var{code-page})} \returns a codec \listlibraries \endentryheader \var{code-page} must be a string and should identify a codec accepted by the \scheme{iconv} library installed on the target machine. The codec returned by this procedure can be used to convert from the non-Unicode single- and multiple-byte character sets supported by \scheme{iconv}. When used in the input direction, the codec converts byte sequences into Scheme strings, and when used in the output direction, it converts Scheme strings to byte sequences. The set of supported code pages depends on the version of \scheme{iconv} available; consult the \scheme{iconv} documentation or use the shell command \scheme{iconv --list} to obtain a list of supported code pages. While the Windows operating system does not supply an \scheme{iconv} library, it is possible to use \scheme{iconv-codec} on Windows systems by supplying an \scheme{iconv} dynamic-link library (named \scheme{iconv.dll}, \scheme{libiconv.dll}, or \scheme{libiconv-2.dll}) that provides Posix-conformant \scheme{iconv_open}, \scheme{iconv}, and \scheme{iconv_close} entry points either under those names or under the alternative names \scheme{libiconv_open}, \scheme{libiconv}, and \scheme{libiconv_close}. The dll must be located in a standard location for dlls or in the current directory of the process the first time \scheme{iconv-codec} is called. %---------------------------------------------------------------------------- \entryheader \formdef{current-transcoder}{\categorythreadparameter}{current-transcoder} \listlibraries \endentryheader The transcoder value of the \scheme{current-transcoder} parameter is used whenever a textual file is opened with an implicit transcoder, e.g., by \scheme{open-input-file} and other convenience I/O procedures, \scheme{compile-file} \scheme{include}, \scheme{load}, and \scheme{pretty-file}. Its initial value is the value of the \scheme{native-transcoder} procedure. %---------------------------------------------------------------------------- \entryheader \formdef{transcoder?}{\categoryprocedure}{(transcoder? \var{obj})} \returns \scheme{#t} if \var{obj} is a transcoder, \scheme{#f} otherwise \listlibraries \endentryheader \section{Port Operations\label{SECTPORTOPERATIONS}} The procedures used to create, access, and alter ports directly are described in this section. Also described are several nonstandard operations on ports. Unless otherwise specified, procedures requiring either input ports or output ports as arguments accept input/output ports as well, i.e., an input/output port is both an input port and an output port. %---------------------------------------------------------------------------- \entryheader \formdef{make-input-port}{\categoryprocedure}{(make-input-port \var{handler} \var{input-buffer})} \formdef{make-output-port}{\categoryprocedure}{(make-output-port \var{handler} \var{output-buffer})} \formdef{make-input/output-port}{\categoryprocedure}{(make-input/output-port \var{handler} \var{input-buffer} \var{output-buffer})} \returns a new textual port \listlibraries \endentryheader \noindent \var{handler} must be a procedure, and \var{input-buffer} and \var{output-buffer} must be strings. Each procedure creates a \index{generic port}generic port. The handler associated with the port is \var{handler}, the input buffer is \var{input-buffer}, and the output buffer is \var{output-buffer}. For \scheme{make-input-port}, the output buffer is undefined, and for \scheme{make-output-port}, the input buffer is undefined. The input size of an input or input/output port is initialized to the string length of the input buffer, and the input index is set to $0$. The output size and index of an output or input/output port are initialized similarly. The length of an input or output buffer may be zero, in which case buffering is effectively disabled. %---------------------------------------------------------------------------- \entryheader \formdef{port-handler}{\categoryprocedure}{(port-handler \var{port})} \returns a procedure \listlibraries \endentryheader \noindent For generic ports, \scheme{port-handler} returns the handler passed to one of the generic port creation procedures described above. For ports created by \scheme{open-input-file} and similar procedures, \scheme{port-handler} returns an internal handler that may be invoked in the same manner as any other handler. %---------------------------------------------------------------------------- \entryheader \formdef{port-input-buffer}{\categoryprocedure}{(port-input-buffer \var{input-port})} \formdef{port-input-size}{\categoryprocedure}{(port-input-size \var{input-port})} \formdef{port-input-index}{\categoryprocedure}{(port-input-index \var{input-port})} \formdef{textual-port-input-buffer}{\categoryprocedure}{(textual-port-input-buffer \var{textual-input-port})} \formdef{textual-port-input-size}{\categoryprocedure}{(textual-port-input-size \var{textual-input-port})} \formdef{textual-port-input-index}{\categoryprocedure}{(textual-port-input-index \var{textual-input-port})} \formdef{binary-port-input-buffer}{\categoryprocedure}{(binary-port-input-buffer \var{binary-input-port})} \formdef{binary-port-input-size}{\categoryprocedure}{(binary-port-input-size \var{binary-input-port})} \formdef{binary-port-input-index}{\categoryprocedure}{(binary-port-input-index \var{binary-input-port})} \returns see below \listlibraries \endentryheader \noindent These procedures return the input buffer, size, or index of the input port. The variants specialized to textual or binary ports are slightly more efficient than their generic counterparts. %---------------------------------------------------------------------------- \entryheader \formdef{set-port-input-index!}{\categoryprocedure}{(set-port-input-index! \var{input-port} \var{n})} \formdef{set-port-input-size!}{\categoryprocedure}{(set-port-input-size! \var{input-port} \var{n})} \formdef{set-port-input-buffer!}{\categoryprocedure}{(set-port-input-buffer! \var{input-port} \var{x})} \formdef{set-textual-port-input-index!}{\categoryprocedure}{(set-textual-port-input-index! \var{textual-input-port} \var{n})} \formdef{set-textual-port-input-size!}{\categoryprocedure}{(set-textual-port-input-size! \var{textual-input-port} \var{n})} \formdef{set-textual-port-input-buffer!}{\categoryprocedure}{(set-textual-port-input-buffer! \var{textual-input-port} \var{string})} \formdef{set-binary-port-input-index!}{\categoryprocedure}{(set-binary-port-input-index! \var{binary-input-port} \var{n})} \formdef{set-binary-port-input-size!}{\categoryprocedure}{(set-binary-port-input-size! \var{binary-input-port} \var{n})} \formdef{set-binary-port-input-buffer!}{\categoryprocedure}{(set-binary-port-input-buffer! \var{binary-input-port} \var{bytevector})} \returns unspecified \listlibraries \endentryheader \noindent The procedure \scheme{set-port-input-index!} sets the input index field of \var{input-port} to $n$, which must be a nonnegative integer less than or equal to the port's input size. The procedure \scheme{set-port-input-size!} sets the input size field of \var{input-port} to $n$, which must be a nonnegative integer less than or equal to the string length of the port's input buffer. It also sets the input index to $0$. The procedure \scheme{set-port-input-buffer!} sets the input buffer field of \var{input-port} to $x$, which must be a string for textual ports and a bytevector for binary ports. It also sets the input size to the length of the string or bytevector and the input index to $0$. The variants specialized to textual or binary ports are slightly more efficient than their generic counterparts. %---------------------------------------------------------------------------- \entryheader \formdef{port-input-count}{\categoryprocedure}{(port-input-count \var{input-port})} \formdef{textual-port-input-count}{\categoryprocedure}{(textual-port-input-count \var{textual-input-port})} \formdef{binary-port-input-count}{\categoryprocedure}{(binary-port-input-count \var{binary-input-port})} \returns see below \listlibraries \endentryheader These procedures return an exact integer representing the number of characters or bytes left to be read from the port's input buffer, i.e., the difference between the buffer size and index. The variants specialized to textual or binary ports are slightly more efficient than their generic counterpart. %---------------------------------------------------------------------------- \entryheader \formdef{port-input-empty?}{\categoryprocedure}{(port-input-empty? \var{input-port})} \returns \scheme{#t} if the port's input buffer contains no more data, otherwise \scheme{#f} \listlibraries \endentryheader This procedure determines whether the port's input count is zero without computing or returning the actual count. %---------------------------------------------------------------------------- \entryheader \formdef{port-output-buffer}{\categoryprocedure}{(port-output-buffer \var{output-port})} \formdef{port-output-size}{\categoryprocedure}{(port-output-size \var{output-port})} \formdef{port-output-index}{\categoryprocedure}{(port-output-index \var{output-port})} \formdef{textual-port-output-buffer}{\categoryprocedure}{(textual-port-output-buffer \var{output-port})} \formdef{textual-port-output-size}{\categoryprocedure}{(textual-port-output-size \var{output-port})} \formdef{textual-port-output-index}{\categoryprocedure}{(textual-port-output-index \var{output-port})} \formdef{binary-port-output-buffer}{\categoryprocedure}{(binary-port-output-buffer \var{output-port})} \formdef{binary-port-output-size}{\categoryprocedure}{(binary-port-output-size \var{output-port})} \formdef{binary-port-output-index}{\categoryprocedure}{(binary-port-output-index \var{output-port})} \returns see below \listlibraries \endentryheader \noindent These procedures return the output buffer, size, or index of the output port. The variants specialized to textual or binary ports are slightly more efficient than their generic counterparts. %---------------------------------------------------------------------------- \entryheader \formdef{set-port-output-index!}{\categoryprocedure}{(set-port-output-index! \var{output-port} \var{n})} \formdef{set-port-output-size!}{\categoryprocedure}{(set-port-output-size! \var{output-port} \var{n})} \formdef{set-port-output-buffer!}{\categoryprocedure}{(set-port-output-buffer! \var{output-port} \var{x})} \formdef{set-textual-port-output-index!}{\categoryprocedure}{(set-textual-port-output-index! \var{textual-output-port} \var{n})} \formdef{set-textual-port-output-size!}{\categoryprocedure}{(set-textual-port-output-size! \var{textual-output-port} \var{n})} \formdef{set-textual-port-output-buffer!}{\categoryprocedure}{(set-textual-port-output-buffer! \var{textual-output-port} \var{string})} \formdef{set-binary-port-output-index!}{\categoryprocedure}{(set-binary-port-output-index! \var{output-port} \var{n})} \formdef{set-binary-port-output-size!}{\categoryprocedure}{(set-binary-port-output-size! \var{output-port} \var{n})} \formdef{set-binary-port-output-buffer!}{\categoryprocedure}{(set-binary-port-output-buffer! \var{binary-output-port} \var{bytevector})} \returns unspecified \listlibraries \endentryheader \noindent The procedure \scheme{set-port-output-index!} sets the output index field of the output port to $n$, which must be a nonnegative integer less than or equal to the port's output size. The procedure \scheme{set-port-output-size!} sets the output size field of the output port to $n$, which must be a nonnegative integer less than or equal to the string length of the port's output buffer. It also sets the output index to $0$. The procedure \scheme{set-port-output-buffer!} sets the output buffer field of \var{output-port} to $x$, which must be a string for textual ports and a bytevector for binary ports. It also sets the output size to the length of the string or bytevector and the output index to $0$. The variants specialized to textual or binary ports are slightly more efficient than their generic counterparts. %---------------------------------------------------------------------------- \entryheader \formdef{port-output-count}{\categoryprocedure}{(port-output-count \var{output-port})} \formdef{textual-port-output-count}{\categoryprocedure}{(textual-port-output-count \var{textual-output-port})} \formdef{binary-port-output-count}{\categoryprocedure}{(binary-port-output-count \var{binary-output-port})} \returns see below \listlibraries \endentryheader These procedures return an exact integer representing the amount of space in characters or bytes available to be written in the port's output buffer, i.e., the difference between the buffer size and index. The variants specialized to textual or binary ports are slightly more efficient than their generic counterpart. %---------------------------------------------------------------------------- \entryheader \formdef{port-output-full?}{\categoryprocedure}{(port-output-full? \var{output-port})} \returns \scheme{#t} if the port's input buffer has no more room, otherwise \scheme{#f} \listlibraries \endentryheader This procedure determines whether the port's output count is zero without computing or returning the actual count. %---------------------------------------------------------------------------- \entryheader \formdef{mark-port-closed!}{\categoryprocedure}{(mark-port-closed! \var{port})} \returns unspecified \listlibraries \endentryheader \noindent This procedure directly marks the port closed so that no further input or output operations are allowed on it. It is typically used by handlers upon receipt of a \scheme{close-port} message. %---------------------------------------------------------------------------- \entryheader \formdef{port-closed?}{\categoryprocedure}{(port-closed? \var{port})} \returns \scheme{#t} if \var{port} is closed, \scheme{#f} otherwise \listlibraries \endentryheader \schemedisplay (let ([p (open-output-string)]) (port-closed? p)) ;=> #f (let ([p (open-output-string)]) (close-port p) (port-closed? p)) ;=> #t \endschemedisplay %---------------------------------------------------------------------------- \entryheader\label{desc:set-port-bol} \formdef{set-port-bol!}{\categoryprocedure}{(set-port-bol! \var{output-port} \var{obj})} \returns unspecified \listlibraries \endentryheader \noindent When \var{obj} is \scheme{#f}, the port's beginning-of-line (BOL) flag is cleared; otherwise, the port's BOL flag is set. The BOL flag is consulted by \scheme{fresh-line} (page~\pageref{desc:fresh-line}) to determine if it needs to emit a newline. This flag is maintained automatically for file output ports, string output ports, and transcript ports. The flag is set for newly created file and string output ports, except for file output ports created with the \scheme{append} option, for which the flag is reset. The BOL flag is clear for newly created generic ports and never set automatically, but may be set explicitly using \scheme{set-port-bol!}. The port is always flushed immediately before the flag is consulted, so it need not be maintained on a per-character basis for buffered ports. %---------------------------------------------------------------------------- \entryheader \formdef{port-bol?}{\categoryprocedure}{(port-bol? \var{port})} \returns \scheme{#t} if \var{port}'s BOL flag is set, \scheme{#f} otherwise \listlibraries \endentryheader %---------------------------------------------------------------------------- \entryheader \formdef{set-port-eof!}{\categoryprocedure}{(set-port-eof! \var{input-port} \var{obj})} \returns unspecified \listlibraries \endentryheader \noindent When \var{obj} is not \scheme{#f}, \scheme{set-port-eof!} marks \var{input-port} so that, once its buffer is empty, the port is treated as if it were at eof even if more data is available in the underlying byte or character stream. Once this artificial eof has been read, the eof mark is cleared, making any additional data in the stream available beyond the eof. This feature can be used by a generic port to simulate a stream consisting of multiple input files. When \var{obj} is \scheme{#f}, the eof mark is cleared. The following example assumes /dev/zero provides an infinite stream of zero bytes. \schemedisplay (define p (parameterize ([file-buffer-size 3]) (open-file-input-port "/dev/zero"))) (set-port-eof! p #t) (get-u8 p) ;=> #!eof (get-u8 p) ;=> 0 (set-port-eof! p #t) (get-u8 p) ;=> 0 (get-u8 p) ;=> 0 (get-u8 p) ;=> #!eof (get-u8 p) ;=> 0 \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{port-name}{\categoryprocedure}{(port-name \var{port})} \returns the name associated with \var{port} \listlibraries \endentryheader \noindent The name may be any object but is usually a string or \scheme{#f} (denoting no name). For file ports, the name is typically a string naming the file. \schemedisplay (let ([p (open-input-file "myfile.ss")]) (port-name p)) ;=> "myfile.ss" (let ([p (open-output-string)]) (port-name p)) ;=> "string" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{set-port-name!}{\categoryprocedure}{(set-port-name! \var{port} \var{obj})} \returns unspecified \listlibraries \endentryheader \noindent This procedure sets \var{port}'s name to \var{obj}, which should be a string or \scheme{#f} (denoting no name). %---------------------------------------------------------------------------- \entryheader \formdef{port-length}{\categoryprocedure}{(port-length \var{port})} \formdef{file-length}{\categoryprocedure}{(file-length \var{port})} \returns the length of the file or other object to which \var{port} refers \formdef{port-has-port-length?}{\categoryprocedure}{(port-has-port-length? \var{port})} \returns \scheme{#t} if the port supports \scheme{port-length}, \scheme{#f} otherwise \listlibraries \endentryheader \noindent A port may allow the length of the underlying stream of characters or bytes to be determined. If so, the procedure \scheme{port-has-port-length?} returns \scheme{#t} and \scheme{port-length} returns the current length. For binary ports, the length is always an exact nonnegative integer byte count. For textual ports, the representation of a length is unspecified; it may not be an exact nonnegative integer and, even if it is, it may not represent either a byte or character count. The length may be used at some later time to reset the length if the port supports \scheme{set-port-length!}. If \scheme{port-length} is called on a port that does not support it, an exception with condition type \scheme{&assertion} is raised. File lengths beyond $2^{32}$ might not be reported property for compressed files on 32-bit versions of the system. \scheme{file-length} is identical to \scheme{port-length}. %---------------------------------------------------------------------------- \entryheader \formdef{set-port-length!}{\categoryprocedure}{(set-port-length! \var{port} \var{len})} \returns unspecified \formdef{port-has-set-port-length!?}{\categoryprocedure}{(port-has-set-port-length!? \var{port})} \returns \scheme{#t} if the port supports \scheme{set-port-length!}, \scheme{#f} otherwise \listlibraries \endentryheader \noindent A port may allow the length of the underlying stream of characters or bytes to be set, i.e., extended or truncated. If so, the procedure \scheme{port-has-set-port-length!?} returns \scheme{#t} and \scheme{set-port-length!} changes the length. For binary ports, the length \var{len} must be an exact nonnegative integer byte count. For textual ports, the representation of a length is unspecified, as described in the entry for \scheme{port-length} above, but \var{len} must be an appropriate length for the textual port, which is usually guaranteed to be the case only if it was obtained from a call to \scheme{port-length} on the same port. If \scheme{set-port-length!} is called on a port that does not support it, an exception with condition type \scheme{&assertion} is raised. It is not possible to set the length of a port opened with compression to an arbitrary position, and the result of an attempt to set the length of a compressed file beyond $2^{32}$ on 32-bit versions of the system is undefined. %---------------------------------------------------------------------------- \entryheader \formdef{port-nonblocking?}{\categoryprocedure}{(port-nonblocking? \var{port})} \returns \scheme{#t} if the port is in nonblocking mode, \scheme{#f} otherwise \formdef{port-has-port-nonblocking??}{\categoryprocedure}{(port-has-port-nonblocking?? \var{port})} \returns \scheme{#t} if the port supports \scheme{port-nonblocking?}, \scheme{#f} otherwise \listlibraries \endentryheader \noindent A port may allow the nonblocking status of the port to be determined. If so, the procedure \scheme{port-has-port-nonblocking??} returns \scheme{#t} and \scheme{port-nonblocking?} returns a boolean value reflecting whether the port is in nonblocking mode. %---------------------------------------------------------------------------- \entryheader \formdef{set-port-nonblocking!}{\categoryprocedure}{(set-port-nonblocking! \var{port} \var{obj})} \returns unspecified \formdef{port-has-set-port-nonblocking!?}{\categoryprocedure}{(port-has-set-port-nonblocking!? \var{port})} \returns \scheme{#t} if the port supports \scheme{set-port-nonblocking!}, \scheme{#f} otherwise \listlibraries \endentryheader \noindent A port may allow reads or writes to be performed in a ``nonblocking'' fashion. If so, the procedure \scheme{port-has-set-port-nonblocking!?} returns \scheme{#t} and \scheme{set-port-nonblocking!} sets the port to nonblocking mode (if \var{obj} is a true value) or blocking mode (if \var{obj} is \scheme{#f}). If \scheme{set-port-nonblocking!} is called on a port that does not support it, an exception with condition type \scheme{&assertion} is raised. Ports created by the standard Revised$^6$ port opening procedures are initially set in blocking mode by default. The same is true for most of the procedures described in this document. A generic port based on a nonblocking source may be nonblocking initially. A port returned by \scheme{open-fd-input-port}, \scheme{open-fd-output-port}, or \scheme{open-fd-input/output-port} is initially in nonblocking mode if the file-descriptor passed in is in nonblocking mode. Similarly, a port returned by \scheme{standard-input-port}, \scheme{standard-output-port}, or \scheme{standard-error-port} is initially in nonblocking mode if the underlying stdin, stdout, or stderr file descriptor is in nonblocking mode. Although \scheme{get-bytevector-some} and \scheme{get-string-some} normally cannot return an empty bytevector or empty string, they can if the port is in nonblocking mode and no input is available. Also, \scheme{get-bytevector-some!} and \scheme{get-string-some!} may not read any data if the port is in nonblocking mode and no data is available. Similarly, \scheme{put-bytevector-some} and \scheme{put-string-some} may not write any data if the port is in nonblocking mode and no room is available. Nonblocking mode is not supported under Windows. %---------------------------------------------------------------------------- \entryheader \formdef{file-position}{\categoryprocedure}{(file-position \var{port})} \formdef{file-position}{\categoryprocedure}{(file-position \var{port} \var{pos})} \returns see below \listlibraries \endentryheader When the second argument is omitted, this procedure behaves like the R6RS \scheme{port-position} procedure, and when present, like the R6RS \scheme{set-port-position!} procedure. For compressed files opened with the \scheme{compressed} flag, \scheme{file-position} returns the position in the uncompressed stream of data. Changing the position of a compressed input file opened with the \scheme{compressed} flag generally requires rewinding and rereading the file and might thus be slow. The position of a compressed output file opened with the \scheme{compressed} flag can be moved forward only; this is accomplished by writing a (compressed) sequence of zeros. File positions beyond $2^{32}$ might not be reported property for compressed files on 32-bit versions of the system. %---------------------------------------------------------------------------- \entryheader \formdef{clear-input-port}{\categoryprocedure}{(clear-input-port)} \formdef{clear-input-port}{\categoryprocedure}{(clear-input-port \var{input-port})} \returns unspecified \listlibraries \endentryheader \noindent If \var{input-port} is not supplied, it defaults to the current input port. This procedure discards any data in the buffer associated with \var{input-port}. This may be necessary, for example, to clear any type-ahead from the keyboard in preparation for an urgent query. %---------------------------------------------------------------------------- \entryheader \formdef{clear-output-port}{\categoryprocedure}{(clear-output-port)} \formdef{clear-output-port}{\categoryprocedure}{(clear-output-port \var{output-port})} \returns unspecified \listlibraries \endentryheader \noindent If \var{output-port} is not supplied, it defaults to the current output port. This procedure discards any data in the buffer associated with \var{output-port}. This may be necessary, for example, to clear any pending output on an interactive port in preparation for an urgent message. %---------------------------------------------------------------------------- \entryheader \formdef{flush-output-port}{\categoryprocedure}{(flush-output-port)} \formdef{flush-output-port}{\categoryprocedure}{(flush-output-port \var{output-port})} \returns unspecified \listlibraries \endentryheader \noindent If \var{output-port} is not supplied, it defaults to the current output port. This procedure forces any data in the buffer associated with \var{output-port} to be printed immediately. The console output port is automatically flushed after a newline and before input from the console input port; all ports are automatically flushed when they are closed. \scheme{flush-output-port} may be necessary, however, to force a message without a newline to be sent to the console output port or to force output to appear on a file without delay. %---------------------------------------------------------------------------- \entryheader \formdef{port-file-compressed!}{\categoryprocedure}{(port-file-compressed! \var{port})} \returns unspecified \listlibraries \endentryheader \var{port} must be an input or an output port, but not an input/output port. It must be a file port pointing to a regular file, i.e., a file on disk rather than, e.g., a socket. The port can be a binary or textual port. If the port is an output port, subsequent output sent to the port will be compressed. If the port is an input port, subsequent input will be decompressed if and only if the port is currently pointing at compressed data. The compression format for output is determined by the \index{\scheme{compress-format}}\scheme{compress-format} parameter, while the compression format on input is inferred. The compression level, which is relevant only for output, is determined by the \index{\scheme{compress-level}}\scheme{compress-level} parameter. This procedure has no effect if the port is already set for compression. %---------------------------------------------------------------------------- \entryheader \formdef{compress-format}{\categorythreadparameter}{compress-format} \listlibraries \endnoskipentryheader \noindent \scheme{compress-format} determines the compression algorithm and format used for output. Currently, the possible values of the parameter are the symbols \scheme{lz4} (the default) and \scheme{gzip}. The \scheme{lz4} format uses the LZ4 compression library developed by Yann Collet. It is therefore compatible with the \scheme{lz4} program, which means that \scheme{lz4} may be used to uncompress files produced by {\ChezScheme} and visa versa. The \scheme{gzip} format uses the zlib compression library developed by Jean-loup Gailly and Mark Adler. It is therefore compatible with the \scheme{gzip} program, which means that \scheme{gzip} may be used to uncompress files produced by {\ChezScheme} and visa versa. Reading \scheme{lz4}-compressed data tends to be much faster than reading \scheme{gzip}-compressed data, while \scheme{gzip}-compressed data tends to be significantly smaller. %---------------------------------------------------------------------------- \entryheader \formdef{compress-level}{\categorythreadparameter}{compress-level} \listlibraries \endnoskipentryheader \noindent \scheme{compress-level} determines the amount of effort spent on compression and is thus relevant only for output. It can be set to one of the symbols \scheme{minimum}, \scheme{low}, \scheme{medium}, \scheme{high}, or \scheme{maximum}, which are listed in order from shortest to longest expected compression time and least to greatest expected effectiveness. Its default value is \scheme{medium}. \section{String Ports\label{SECTIOSTRINGPORTS}} String ports allow the creation and manipulation of strings via port operations. The procedure \scheme{open-input-string} converts a string into a textual input port, allowing the characters in the string to be read in sequence via input operations such as \scheme{read-char} or \scheme{read}. The procedure \scheme{open-output-string} allows new strings to be built up with output operations such as \scheme{write-char} and \scheme{write}. While string ports could be defined as generic ports, they are instead supported as primitive by the implementation. %---------------------------------------------------------------------------- \entryheader \formdef{open-input-string}{\categoryprocedure}{(open-input-string \var{string})} \returns a new string input port \listlibraries \endentryheader \noindent A \index{string input port}string input port is similar to a file input port, except that characters and objects drawn from the port come from \var{string} rather than from a file. A string port is at ``end of file'' when the port reaches the end of the string. It is not necessary to close a string port, although it is okay to do so. \schemedisplay (let ([p (open-input-string "hi mom!")]) (let ([x (read p)]) (list x (read p)))) ;=> (hi mom!) \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{with-input-from-string}{\categoryprocedure}{(with-input-from-string \var{string} \var{thunk})} \returns the values returned by \var{thunk} \listlibraries \endentryheader \noindent \var{thunk} must be a procedure and should accept zero arguments. \scheme{with-input-from-string} parameterizes the current input port to be the result of opening \var{string} for input during the application of \var{thunk}. \schemedisplay (with-input-from-string "(cons 3 4)" (lambda () (eval (read)))) ;=> (3 . 4) \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{open-output-string}{\categoryprocedure}{(open-output-string)} \returns a new string output port \listlibraries \endentryheader \noindent A \index{string output port}string output port is similar to a file output port, except that characters and objects written to the port are placed in a string (which grows as needed) rather than to a file. The string built by writing to a string output port may be obtained with \scheme{get-output-string}. See the example given for \scheme{get-output-string} below. It is not necessary to close a string port, although it is okay to do so. %---------------------------------------------------------------------------- \entryheader \formdef{get-output-string}{\categoryprocedure}{(get-output-string \var{string-output-port})} \returns the string associated with \var{string-output-port} \listlibraries \endentryheader \noindent \var{string-output-port} must be an port returned by \scheme{open-output-string}. As a side effect, \scheme{get-output-string} resets \var{string-output-port} so that subsequent output to \var{string-output-port} is placed into a fresh string. \schemedisplay (let ([p (open-output-string)]) (write 'hi p) (write-char #\space p) (write 'mom! p) (get-output-string p)) ;=> "hi mom!" \endschemedisplay \noindent An implementation of \scheme{format} (Section~\ref{SECTFORMAT}) might be written using string-output ports to produce string output. %---------------------------------------------------------------------------- \entryheader \formdef{with-output-to-string}{\categoryprocedure}{(with-output-to-string \var{thunk})} \returns a string containing the output \listlibraries \endentryheader \noindent \var{thunk} must be a procedure and should accept zero arguments. \scheme{with-output-to-string} parameterizes the current output port to a new string output port during the application of \var{thunk}. If \var{thunk} returns, the string associated with the new string output port is returned, as with \scheme{get-output-string}. \schemedisplay (with-output-to-string (lambda () (display "Once upon a time ...") (newline))) ;=> "Once upon a time ...\n" \endschemedisplay \section{File Ports\label{SECTIOFILEPORTS}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{file-buffer-size}{\categorythreadparameter}{file-buffer-size} \listlibraries \endnoskipentryheader \noindent \scheme{file-buffer-size} is a parameter that determines the size of each buffer created when the buffer mode is not \scheme{none} for a port created by one of the file open operations, e.g., \scheme{open-input-file} or \scheme{open-file-output-port}. When called with no arguments, the parameter returns the current buffer size. When called with a positive fixnum \var{k}, it sets the current buffer size to \var{k}. %---------------------------------------------------------------------------- \entryheader \formdef{file-port?}{\categoryprocedure}{(file-port? \var{port})} \returns \scheme{#t} if \var{port} is a file port, \scheme{#f} otherwise \listlibraries \endentryheader A file port is any port based directly on an O/S file descriptor, e.g., one created by \scheme{open-file-input-port}, \scheme{open-output-port}, \scheme{open-fd-input-port}, etc., but not a string, bytevector, or custom port. %---------------------------------------------------------------------------- \entryheader \formdef{port-file-descriptor}{\categoryprocedure}{(port-file-descriptor \var{port})} \returns the file descriptor associated with \var{port} \listlibraries \endentryheader \var{port} must be a file port, i.e., a port for which \var{file-port?} returns \scheme{#t}. \section{Custom Ports\label{SECTIOCUSTOMPORTS}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{custom-port-buffer-size}{\categorythreadparameter}{custom-port-buffer-size} \listlibraries \endnoskipentryheader \noindent \scheme{custom-port-buffer-size} is a parameter that determines the sizes of the buffers associated with newly created custom ports. When called with no arguments, the parameter returns the current buffer size. When called with a positive fixnum \var{k}, it sets the current buffer size to \var{k}. \section{Input Operations\label{SECTIOINPUT}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{console-input-port}{\categoryglobalparameter}{console-input-port} \listlibraries \endnoskipentryheader \noindent \scheme{console-input-port} is a parameter that determines the input port used by the waiter and interactive debugger. When called with no arguments, it returns the console input port. When called with one argument, which must be a textual input port, it changes the value of the console input port. The initial value of this parameter is a port tied to the standard input (stdin) stream of the Scheme process. %---------------------------------------------------------------------------- \entryheader \formdef{current-input-port}{\categorythreadparameter}{current-input-port} \listlibraries \endentryheader \noindent \scheme{current-input-port} is a parameter that determines the default port argument for most input procedures, including \scheme{read-char}, \scheme{peek-char}, and \scheme{read}, When called with no arguments, \scheme{current-input-port} returns the current input port. When called with one argument, which must be a textual input port, it changes the value of the current input port. The Revised$^6$ Report version of \scheme{current-input-port} accepts only zero arguments, i.e., it cannot be used to change the current input port. The initial value of this parameter is the same port as the initial value of \scheme{console-input-port}. %---------------------------------------------------------------------------- \entryheader \formdef{open-input-file}{\categoryprocedure}{(open-input-file \var{path})} \formdef{open-input-file}{\categoryprocedure}{(open-input-file \var{path} \var{options})} \returns a new input port \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{open-input-file} opens a textual input port for the file named by \var{path}. An exception is raised with condition type \scheme{&i/o-filename} if the file does not exist or cannot be opened for input. \var{options}, if present, is a symbolic option name or option list. Possible symbolic option names are \scheme{compressed}, \scheme{uncompressed}, \scheme{buffered}, and \scheme{unbuffered}. An option list is a list containing zero or more symbolic option names. The mutually exclusive \scheme{compressed} and \scheme{uncompressed} options determine whether the input file should be decompressed if it is compressed (where the compression format is inferred). (See \scheme{open-output-file}.) The default is \scheme{uncompressed}, so the \scheme{uncompressed} option is useful only as documentation. The mutually exclusive \scheme{buffered} and \scheme{unbuffered} options determine whether input is buffered. When input is buffered, it is read in large blocks and buffered internally for efficiency to reduce the number of operating system requests. When the \scheme{unbuffered} option is specified, input is unbuffered, but not fully, since one character of buffering is required to support \scheme{peek-char} and \scheme{unread-char}. Input is buffered by default, so the \scheme{buffered} option is useful only as documentation. % flushed this: posix lockf works only on file descriptors open for writing %The mutually exclusive \scheme{exclusive} and \scheme{nonexclusive} %options determine whether access to the file is ``exclusive.'' %When the exclusive option is specified, the file is locked until %the port is closed to prevent access by other processes. %On some systems the lock is advisory, i.e., it inhibits access by %other processes only if they also attempt to open exclusively. %Nonexclusive access is the default, so the \scheme{nonexclusive} option %is useful only as documentation. For example, the call \schemedisplay (open-input-file "frob" '(compressed)) \endschemedisplay opens the file frob with decompression enabled. The Revised$^6$ Report version of \scheme{open-input-file} does not support the optional \var{options} argument. %---------------------------------------------------------------------------- \entryheader \formdef{call-with-input-file}{\categoryprocedure}{(call-with-input-file \var{path} \var{procedure})} \formdef{call-with-input-file}{\categoryprocedure}{(call-with-input-file \var{path} \var{procedure} \var{options})} \returns the values returned by \var{procedure} \listlibraries \endentryheader \noindent \var{path} must be a string. \var{procedure} should accept one argument. \scheme{call-with-input-file} creates a new input port for the file named by \var{path}, as if with \scheme{open-input-file}, and passes this port to \var{procedure}. If \var{procedure} returns normally, \scheme{call-with-input-file} closes the input port and returns the values returned by \var{procedure}. \scheme{call-with-input-file} does not automatically close the input port if a continuation created outside of \var{procedure} is invoked, since it is possible that another continuation created inside of \var{procedure} will be invoked at a later time, returning control to \var{procedure}. If \var{procedure} does not return, an implementation is free to close the input port only if it can prove that the input port is no longer accessible. As shown in Section~\ref{TSPL:SECTCONTINUATIONS} of {\TSPLFOUR}, \scheme{dynamic-wind} may be used to ensure that the port is closed if a continuation created outside of \var{procedure} is invoked. See \scheme{open-input-file} above for a description of the optional \var{options} argument. The Revised$^6$ Report version of \scheme{call-with-input-file} does not support the optional \var{input} argument. %---------------------------------------------------------------------------- \entryheader \formdef{with-input-from-file}{\categoryprocedure}{(with-input-from-file \var{path} \var{thunk})} \formdef{with-input-from-file}{\categoryprocedure}{(with-input-from-file \var{path} \var{thunk} \var{options})} \returns the values returned by \var{thunk} \listlibraries \endentryheader \noindent \var{path} must be a string. \var{thunk} must be a procedure and should accept zero arguments. \scheme{with-input-from-file} temporarily changes the current input port to be the result of opening the file named by \var{path}, as if with \scheme{open-input-file}, during the application of \var{thunk}. If \var{thunk} returns, the port is closed and the current input port is restored to its old value. The behavior of \scheme{with-input-from-file} is unspecified if a continuation created outside of \var{thunk} is invoked before \var{thunk} returns. An implementation may close the port and restore the current input port to its old value---but it may not. See \scheme{open-input-file} above for a description of the optional \var{options} argument. The Revised$^6$ Report version of \scheme{with-input-from-file} does not support the optional \var{options} argument. %---------------------------------------------------------------------------- \entryheader \formdef{open-fd-input-port}{\categoryprocedure}{(open-fd-input-port \var{fd})} \formdef{open-fd-input-port}{\categoryprocedure}{(open-fd-input-port \var{fd} \var{b-mode})} \formdef{open-fd-input-port}{\categoryprocedure}{(open-fd-input-port \var{fd} \var{b-mode} \var{?transcoder})} \returns a new input port for the file descriptor \var{fd} \listlibraries \endentryheader \noindent \var{fd} must be a nonnegative exact integer and should be a valid open file descriptor. If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual input port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary input port. See the lead-in to Section~\ref{TSPL:SECTOPENINGFILES} of {\TSPLFOUR} for a description of the constraints on and effects of the other arguments. The file descriptor is closed when the port is closed. %---------------------------------------------------------------------------- \entryheader \formdef{standard-input-port}{\categoryprocedure}{(standard-input-port)} \formdef{standard-input-port}{\categoryprocedure}{(standard-input-port \var{b-mode})} \formdef{standard-input-port}{\categoryprocedure}{(standard-input-port \var{b-mode} \var{?transcoder})} \returns a new input port connected to the process's standard input \listlibraries \endentryheader \noindent If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual input port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary input port. The buffer mode \var{b-mode} defaults to \scheme{block}. The Revised$^6$ Report version of this procedure does not accept the optional \var{b-mode} and \var{?transcoder} arguments, which limits it to an implementation-dependent buffering mode (\scheme{block} in {\ChezScheme}) and binary output. %---------------------------------------------------------------------------- \entryheader \formdef{get-string-some}{\categoryprocedure}{(get-string-some \var{textual-input-port})} \returns a nonempty string or the eof object \listlibraries \endentryheader \noindent If \var{textual-input-port} is at end of file, the eof object is returned. Otherwise, \scheme{get-string-some} reads (as if with \scheme{get-u8}) at least one character and possibly more, and returns a string containing these characters. The port's position is advanced past the characters read. The maximum number of characters read by this operation is implementation-dependent. An exception to the ``at least one character'' guarantee occurs if the port is in nonblocking mode (see \scheme{set-port-nonblocking!}) and no input is ready. In this case, an empty string is returned. %---------------------------------------------------------------------------- \entryheader \formdef{get-string-some!}{\categoryprocedure}{(get-string-some! \var{textual-input-port} \var{string} \var{start} \var{n})} \returns the count of characters read, as an exact nonnegative integer, or the eof object \listlibraries \endentryheader \noindent \var{start} and \var{n} must be exact nonnegative integers, and the sum of \var{start} and \var{n} must not exceed the length of \var{string}. If \var{n} is 0, this procedure returns zero without attempting to read from \var{textual-input-port} and without modifying \var{string}. Otherwise, if \var{textual-input-port} is at end of file, this procedure returns the eof object, except it returns zero when the port is in nonblocking mode (see \scheme{set-port-nonblocking!}) and the port cannot be determined to be at end of file without blocking. In either case, \var{string} is not modified. Otherwise, this procedure reads (as if with \scheme{get-char}) up to \var{n} characters from the port, stores the characters in consecutive locations of \var{string} starting at \var{start}, advances the port's position just past the characters read, and returns the count of characters read. If the port is in nonblocking mode, this procedure reads no more than it can without blocking and thus might read zero characters; otherwise, it reads at least one character but no more than are available when the first character becomes available. %---------------------------------------------------------------------------- \entryheader \formdef{get-bytevector-some!}{\categoryprocedure}{(get-bytevector-some! \var{binary-input-port} \var{bytevector} \var{start} \var{n})} \returns the count of bytes read, as an exact nonnegative integer, or the eof object \listlibraries \endentryheader \noindent \var{start} and \var{n} must be exact nonnegative integers, and the sum of \var{start} and \var{n} must not exceed the length of \var{bytevector}. If \var{n} is 0, this procedure returns zero without attempting to read from \var{binary-input-port} and without modifying \var{bytevector}. Otherwise, if \var{binary-input-port} is at end of file, this procedure returns the eof object, except it returns zero when the port is in nonblocking mode (see \scheme{set-port-nonblocking!}) and the port cannot be determined to be at end of file without blocking. In either case, \var{bytevector} is not modified. Otherwise, this procedure reads (as if with \scheme{get-u8}) up to \var{n} bytes from the port, stores the bytes in consecutive locations of \var{bytevector} starting at \var{start}, advances the port's position just past the bytes read, and returns the count of bytes read. If the port is in nonblocking mode, this procedure reads no more than it can without blocking and thus might read zero bytes; otherwise, it reads at least one byte but no more than are available when the first byte becomes available. %---------------------------------------------------------------------------- \entryheader \formdef{unread-char}{\categoryprocedure}{(unread-char \var{char})} \formdef{unread-char}{\categoryprocedure}{(unread-char \var{char} \var{textual-input-port})} \formdef{unget-char}{\categoryprocedure}{(unget-char \var{textual-input-port} \var{char})} \returns unspecified \listlibraries \endentryheader \noindent For \scheme{unread-char}, if \var{textual-input-port} is not supplied, it defaults to the current input port. These procedures ``unread'' the last character read from \scheme{textual-input-port}. \var{char} may or may not be ignored, depending upon the implementation. In any case, \var{char} should be last character read from the port. A character should not be unread twice on the same port without an intervening call to \scheme{read-char} or \scheme{get-char}. \scheme{unread-char} and \scheme{unget-char} are provided for applications requiring one character of lookahead and may be used in place of, or even in combination with, \scheme{peek-char} or \scheme{lookahead-char}. One character of lookahead is required in the procedure \scheme{read-word}, which is defined below in terms of \scheme{unread-char}. \scheme{read-word} returns the next word from a textual input port as a string, where a word is defined to be a sequence of alphabetic characters. Since it does not know until it reads one character too many that it has read the entire word, \scheme{read-word} uses \scheme{unread-char} to return the character to the input port. \schemedisplay (define read-word (lambda (p) (list->string (let f ([c (read-char p)]) (cond [(eof-object? c) '()] [(char-alphabetic? c) (cons c (f (read-char p)))] [else (unread-char c p) '()]))))) \endschemedisplay \noindent In the alternate version below, \scheme{peek-char} is used instead of \scheme{unread-char}. \schemedisplay (define read-word (lambda (p) (list->string (let f ([c (peek-char p)]) (cond [(eof-object? c) '()] [(char-alphabetic? c) (read-char p) (cons c (f (peek-char p)))] [else '()]))))) \endschemedisplay \noindent The advantage of \scheme{unread-char} in this situation is that only one call to \scheme{unread-char} per word is required, whereas one call to \scheme{peek-char} is required for each character in the word plus the first character beyond. In many cases, \scheme{unread-char} and \scheme{unget-char} do not enjoy this advantage, and \scheme{peek-char} or \scheme{lookahead-char} should be used instead. %---------------------------------------------------------------------------- \entryheader \formdef{unget-u8}{\categoryprocedure}{(unget-u8 \var{binary-input-port} \var{octet})} \returns unspecified \listlibraries \endentryheader \noindent This procedures ``unreads'' the last byte read from \scheme{binary-input-port}. \var{octet} may or may not be ignored, depending upon the implementation. In any case, \var{octet} should be last byte read from the port. A byte should not be unread twice on the same port without an intervening call to \scheme{get-u8}. %---------------------------------------------------------------------------- \entryheader \formdef{input-port-ready?}{\categoryprocedure}{(input-port-ready? \var{input-port})} \returns \scheme{#t} if data is available on \var{input-port}, \scheme{#f} otherwise \listlibraries \endentryheader \scheme{input-port-ready?} allows a program to check to see if input is available on a textual or binary input port without hanging. If input is available or the port is at end of file, \scheme{input-port-ready?} returns \scheme{#t}. If it cannot determine from the port whether input is ready, \scheme{input-port-ready?} raises an exception with condition type \scheme{&i/o-read-error}. Otherwise, it returns \scheme{#f}. %---------------------------------------------------------------------------- \entryheader \formdef{char-ready?}{\categoryprocedure}{(char-ready?)} \formdef{char-ready?}{\categoryprocedure}{(char-ready? \var{textual-input-port})} \returns \scheme{#t} if a character is available on \var{textual-input-port}, \scheme{#f} otherwise \listlibraries \endentryheader \noindent If \var{textual-input-port} is not supplied, it defaults to the current input port. \scheme{char-ready?} is like \scheme{input-port-ready?} except it is restricted to textual input ports. %---------------------------------------------------------------------------- \entryheader \formdef{block-read}{\categoryprocedure}{(block-read \var{textual-input-port} \var{string})} \formdef{block-read}{\categoryprocedure}{(block-read \var{textual-input-port} \var{string} \var{count})} \returns see below \listlibraries \endentryheader \noindent \var{count} must be a nonnegative fixnum less than or equal to the length of \var{string}. If not provided, it defaults to the length of \var{string}. If \var{textual-input-port} is at end-of-file, an eof object is returned. Otherwise, \var{string} is filled with as many characters as are available for reading from \var{textual-input-port} up to \var{count}, and the number of characters placed in the string is returned. If \var{textual-input-port} is buffered and the buffer is nonempty, the buffered input or a portion thereof is returned; otherwise \scheme{block-read} bypasses the buffer entirely. %---------------------------------------------------------------------------- \entryheader \formdef{read-token}{\categoryprocedure}{(read-token)} \formdef{read-token}{\categoryprocedure}{(read-token \var{textual-input-port})} \formdef{read-token}{\categoryprocedure}{(read-token \var{textual-input-port} \var{sfd} \var{bfp})} \returns see below \listlibraries \endentryheader \noindent \var{sfd} must be a source-file descriptor. \var{bfp} must be an exact nonnegative integer and should be the character position of the next character to be read from \var{textual-input-port}. Parsing of a Scheme datum is conceptually performed in two steps. First, the sequence of characters that form the datum are grouped into \scheme{tokens}, such as symbols, numbers, left parentheses, and double quotes. During this first step, whitespace and comments are discarded. Second, these tokens are grouped into data. \scheme{read} performs both of these steps and creates an internal representation of each datum it parses. \scheme{read-token} may be used to perform the first step only, one token at a time. \scheme{read-token} is intended to be used by editors and program formatters that must be able to parse a program or datum without actually reading it. If \var{textual-input-port} is not supplied, it defaults to the current input port. One token is read from the input port and returned as four values: \begin{description} \item[\var{type}:] a symbol describing the type of token read, \item[\var{value}:] the token value, \item[\var{start}:] the position of the first character of the token, relative to the starting position of the input port (or \scheme{#f}, if the position cannot be determined), and \item[\var{end}:] the first position beyond the token, relative to the starting position of the input port (or \scheme{#f}, if the position cannot be determined). \end{description} \noindent The input port is left pointing to the first character position beyond the token. When the token type fully specifies the token, \scheme{read-token} returns \scheme{#f} for the value. The token types are listed below with the corresponding \var{value} in parentheses. \begin{description} \item[\scheme{atomic}] (\var{atom}) an atomic value, i.e., a symbol, boolean, number, character, \scheme{#!eof}, or \scheme{#!bwp} \item[\scheme{box}] (\scheme{#f}) box prefix, i.e., \scheme{#&} \item[\scheme{dot}] (\scheme{#f}) dotted pair separator, i.e., \scheme{.} \item[\scheme{eof}] (\scheme{#!eof}) end of file \item[\scheme{fasl}] (\scheme{#f}) fasl prefix, i.e., \scheme{#@} \item[\scheme{insert}] (\var{n}) graph reference, i.e., \scheme{#\var{n}#} \item[\scheme{lbrack}] (\scheme{#f}) open square bracket \item[\scheme{lparen}] (\scheme{#f}) open parenthesis \item[\scheme{mark}] (\var{n}) graph mark, i.e., \scheme{#\var{n}=} \item[\scheme{quote}] (\scheme{quote}, \scheme{quasiquote}, \scheme{syntax}, \scheme{unquote}, \scheme{unquote-splicing}, or \scheme{datum-comment}) an abbreviation mark, e.g., \scheme{'} or \scheme{,@} or datum-comment prefix \item[\scheme{rbrack}] (\scheme{#f}) close square bracket \item[\scheme{record-brack}] (\scheme{#f}) record open bracket, i.e., \scheme{#[} \item[\scheme{rparen}] (\scheme{#f}) close parenthesis \item[\scheme{vfxnparen}] (\var{n}) fxvector prefix, i.e., \scheme{#\var{n}vfx(} \item[\scheme{vfxparen}] (\scheme{#f}) fxvector prefix, i.e., \scheme{#vfx(} \item[\scheme{vnparen}] (\var{n}) vector prefix, i.e., \scheme{#\var{n}(} \item[\scheme{vparen}] (\scheme{#f}) vector prefix, i.e., \scheme{#(} \item[\scheme{vu8nparen}] (\var{n}) bytevector prefix, i.e., \scheme{#\var{n}vu8(} \item[\scheme{vu8paren}] (\scheme{#f}) bytevector prefix, i.e., \scheme{#vu8(} \end{description} \noindent The set of token types is likely to change in future releases of the system; check the release notes for details on such changes. Specifying \var{sfd} and \var{bfp} improves the quality of error messages, guarantees \var{start} and \var{end} can be determined, and eliminates the overhead of asking for a file position on each call to \scheme{read-token}. In most cases, \var{bfp} should be 0 for the first call to \scheme{read-token} at the start of a file, and it should be the fourth return value (\var{end}) of the preceding call to \scheme{read-token} for each subsequent call. This protocol is necessary to handle files containing multiple-byte characters, since file positions do not necessarily correspond to character positions. \schemedisplay (define s (open-input-string "(a b c)")) (read-token s) ;=> lparen #f 0 1 (define s (open-input-string "abc 123")) (read-token s) ;=> atomic abc 0 3 (define s (open-input-string "")) (read-token s) ;=> eof #!eof 0 0 (define s (open-input-string "#7=#7#")) (read-token s) ;=> mark 7 0 3 (read-token s) ;=> insert 7 3 6 \endschemedisplay The information \scheme{read-token} returns is not always sufficient for reconstituting the exact sequence of characters that make up a token. For example, \scheme{1.0} and \scheme{1e0} both return \var{type} \scheme{atomic} with \var{value} \scheme{1.0}. The exact sequence of characters may be obtained only by repositioning the port and reading a block of characters of the appropriate length, using the relative positions given by \var{start} and \var{end}. \section{Output Operations\label{SECTIOOUTPUT}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{console-output-port}{\categoryglobalparameter}{console-output-port} \listlibraries \endnoskipentryheader \noindent \scheme{console-output-port} is a parameter that determines the output port used by the waiter and interactive debugger. When called with no arguments, it returns the console output port. When called with one argument, which must be a textual output port, it changes the value of the console output port. The initial value of this parameter is a port tied to the standard output (stdout) stream of the Scheme process. %---------------------------------------------------------------------------- \entryheader \formdef{current-output-port}{\categorythreadparameter}{current-output-port} \listlibraries \endentryheader \noindent \scheme{current-output-port} is a parameter that determines the default port argument for most output procedures, including \scheme{write-char}, \scheme{newline}, \scheme{write}, \scheme{display}, and \scheme{pretty-print}. When called with no arguments, \scheme{current-output-port} returns the current output port. When called with one argument, which must be a textual output port, it changes the value of the current output port. The Revised$^6$ Report version of \scheme{current-output-port} accepts only zero arguments, i.e., it cannot be used to change the current output port. The initial value of this parameter is the same port as the initial value of \scheme{console-output-port}. %---------------------------------------------------------------------------- \entryheader \formdef{console-error-port}{\categorythreadparameter}{console-error-port} \listlibraries \endentryheader \scheme{console-error-port} is a parameter that can be used to set or obtain the console error port, which determines the port to which conditions and other messages are printed by the default exception handler. When called with no arguments, \scheme{console-error-port} returns the console error port. When called with one argument, which must be a textual output port, it changes the value of the console error port. If the system determines that the standard output (stdout) and standard error (stderr) streams refer to the same file, socket, pipe, virtual terminal, device, etc., this parameter is initially set to the same value as the parameter \scheme{console-output-port}. Otherwise, this parameter is initially set to a different port tied to the standard error (stderr) stream of the Scheme process. %---------------------------------------------------------------------------- \entryheader \formdef{current-error-port}{\categorythreadparameter}{current-error-port} \listlibraries \endentryheader \scheme{current-error-port} is a parameter that can be used to set or obtain the current error port. When called with no arguments, \scheme{current-error-port} returns the current error port. When called with one argument, which must be a textual output port, it changes the value of the current error port. The Revised$^6$ Report version of \scheme{current-error-port} accepts only zero arguments, i.e., it cannot be used to change the current error port. The initial value of this parameter is the same port as the initial value of \scheme{console-error-port}. %---------------------------------------------------------------------------- \entryheader \formdef{open-output-file}{\categoryprocedure}{(open-output-file \var{path})} \formdef{open-output-file}{\categoryprocedure}{(open-output-file \var{path} \var{options})} \returns a new output port \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{open-output-file} opens a textual output port for the file named by \var{path}. \var{options}, if present, is a symbolic option name or option list. Possible symbolic option names are \scheme{error}, \scheme{truncate}, \scheme{replace}, \scheme{append}, \scheme{compressed}, \scheme{uncompressed}, \scheme{buffered}, \scheme{unbuffered}, \scheme{exclusive}, and \scheme{nonexclusive}. An option list is a list containing zero or more symbolic option names and possibly the two-element option \scheme{mode \var{mode}}. The mutually exclusive \scheme{error}, \scheme{truncate}, \scheme{replace}, and \scheme{append} options are used to direct what happens when the file to be opened already exists. \begin{description} \item[\scheme{error}:] An exception is raised with condition-type \scheme{&i/o-filename}. \item[\scheme{replace}:] The existing file is deleted before the new file is opened. \item[\scheme{truncate}:] The existing file is opened and truncated to zero length. \item[\scheme{append}:] The existing file is opened and the output port is positioned at the end of the file before each write so that output to the port is always appended to the file. \end{description} The default behavior is to raise an exception. The mutually exclusive \scheme{compressed} and \scheme{uncompressed} options determine whether the output file is to be compressed. The compression format and level are determined by the \index{\scheme{compress-format}}\scheme{compress-format} and \index{\scheme{compress-level}}\scheme{compress-level} parameters. Files are uncompressed by default, so the \scheme{uncompressed} option is useful only as documentation. The mutually exclusive \scheme{buffered} and \scheme{unbuffered} options determine whether output is buffered. Unbuffered output is sent immediately to the file, whereas buffered output not written until the port's output buffer is filled or the port is flushed (via \scheme{flush-output-port}) or closed (via \scheme{flush-output-port} or by the storage management system when the port becomes inaccessible). Output is buffered by default for efficiency, so the \scheme{buffered} option is useful only as documentation. The mutually exclusive \scheme{exclusive} and \scheme{nonexclusive} options determine whether access to the file is ``exclusive.'' When the exclusive option is specified, the file is locked until the port is closed to prevent access by other processes. On some systems the lock is advisory, i.e., it inhibits access by other processes only if they also attempt to open exclusively. Nonexclusive access is the default, so the \scheme{nonexclusive} option is useful only as documentation. The \scheme{mode} option determines the permission bits on Unix systems when the file is created by the operation, subject to the process umask. The subsequent element in the options list must be an exact integer specifying the permissions in the manner of the Unix \scheme{open} function. The mode option is ignored under Windows. For example, the call \schemedisplay (open-output-file "frob" '(compressed truncate mode #o644)) \endschemedisplay opens the file frob with compression enabled. If frob already exists it is truncated. On Unix-based systems, if frob does not already exist, the permission bits on the newly created file are set to logical and of \scheme{#o644} and the process's umask. The Revised$^6$ Report version of \scheme{open-output-file} does not support the optional \var{options} argument. %---------------------------------------------------------------------------- \entryheader \formdef{call-with-output-file}{\categoryprocedure}{(call-with-output-file \var{path} \var{procedure})} \formdef{call-with-output-file}{\categoryprocedure}{(call-with-output-file \var{path} \var{procedure} \var{options})} \returns the values returned by \var{procedure} \listlibraries \endentryheader \noindent \var{path} must be a string. \var{procedure} should accept one argument. \scheme{call-with-output-file} creates a new output port for the file named by \var{path}, as if with \scheme{open-output-file}, and passes this port to \var{procedure}. If \var{procedure} returns, \scheme{call-with-output-file} closes the output port and returns the values returned by \var{procedure}. \scheme{call-with-output-file} does not automatically close the output port if a continuation created outside of \var{procedure} is invoked, since it is possible that another continuation created inside of \var{procedure} will be invoked at a later time, returning control to \var{procedure}. If \var{procedure} does not return, an implementation is free to close the output port only if it can prove that the output port is no longer accessible. As shown in Section~\ref{TSPL:SECTCONTINUATIONS} of {\TSPLFOUR}, \scheme{dynamic-wind} may be used to ensure that the port is closed if a continuation created outside of \var{procedure} is invoked. See \scheme{open-output-file} above for a description of the optional \var{options} argument. The Revised$^6$ Report version of \scheme{call-with-output-file} does not support the optional \var{options} argument. %---------------------------------------------------------------------------- \entryheader \formdef{with-output-to-file}{\categoryprocedure}{(with-output-to-file \var{path} \var{thunk})} \formdef{with-output-to-file}{\categoryprocedure}{(with-output-to-file \var{path} \var{thunk} \var{options})} \returns the value returned by \var{thunk} \listlibraries \endentryheader \noindent \var{path} must be a string. \var{thunk} must be a procedure and should accept zero arguments. \scheme{with-output-to-file} temporarily rebinds the current output port to be the result of opening the file named by \var{path}, as if with \scheme{open-output-file}, during the application of \var{thunk}. If \var{thunk} returns, the port is closed and the current output port is restored to its old value. The behavior of \scheme{with-output-to-file} is unspecified if a continuation created outside of \var{thunk} is invoked before \var{thunk} returns. An implementation may close the port and restore the current output port to its old value---but it may not. See \scheme{open-output-file} above for a description of the optional \var{options} argument. The Revised$^6$ Report version of \scheme{with-output-to-file} does not support the optional \var{options} argument. %---------------------------------------------------------------------------- \entryheader \formdef{open-fd-output-port}{\categoryprocedure}{(open-fd-output-port \var{fd})} \formdef{open-fd-output-port}{\categoryprocedure}{(open-fd-output-port \var{fd} \var{b-mode})} \formdef{open-fd-output-port}{\categoryprocedure}{(open-fd-output-port \var{fd} \var{b-mode} \var{?transcoder})} \returns a new output port for the file descriptor \var{fd} \listlibraries \endentryheader \noindent \var{fd} must be a nonnegative exact integer and should be a valid open file descriptor. If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual output port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary output port. See the lead-in to Section~\ref{TSPL:SECTOPENINGFILES} of {\TSPLFOUR} for a description of the constraints on and effects of the other arguments. The file descriptor is closed when the port is closed. %---------------------------------------------------------------------------- \entryheader \formdef{standard-output-port}{\categoryprocedure}{(standard-output-port)} \formdef{standard-output-port}{\categoryprocedure}{(standard-output-port \var{b-mode})} \formdef{standard-output-port}{\categoryprocedure}{(standard-output-port \var{b-mode} \var{?transcoder})} \returns a new output port connected to the process's standard output \listlibraries \endentryheader \noindent If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual output port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary output port. The buffer mode \var{b-mode} defaults to \scheme{line}, which differs from \scheme{block} in {\ChezScheme} only for textual output ports. The Revised$^6$ Report version of this procedure does not accept the optional \var{b-mode} and \var{?transcoder} arguments, which limits it to an implementation-dependent buffering mode (\scheme{line} in {\ChezScheme}) and binary output. %---------------------------------------------------------------------------- \entryheader \formdef{standard-error-port}{\categoryprocedure}{(standard-error-port)} \formdef{standard-error-port}{\categoryprocedure}{(standard-error-port \var{b-mode})} \formdef{standard-error-port}{\categoryprocedure}{(standard-error-port \var{b-mode} \var{?transcoder})} \returns a new output port connected to the process's standard error \listlibraries \endentryheader \noindent If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual output port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary output port. The buffer mode \var{b-mode} defaults to \scheme{none}. See the lead-in to Section~\ref{TSPL:SECTOPENINGFILES} of {\TSPLFOUR} for a description of the constraints on and effects of the other arguments. The Revised$^6$ Report version of this procedure does not accept the optional \var{b-mode} and \var{?transcoder} arguments, which limits it to an implementation-dependent buffering mode (\scheme{none} in {\ChezScheme}) and binary output. %---------------------------------------------------------------------------- \entryheader \formdef{put-bytevector-some}{\categoryprocedure}{(put-bytevector-some \var{binary-output-port} \var{bytevector})} \formdef{put-bytevector-some}{\categoryprocedure}{(put-bytevector-some \var{binary-output-port} \var{bytevector} \var{start})} \formdef{put-bytevector-some}{\categoryprocedure}{(put-bytevector-some \var{binary-output-port} \var{bytevector} \var{start} \var{n})} \returns the number of bytes written \listlibraries \endentryheader \noindent \var{start} and \var{n} must be nonnegative exact integers, and the sum of \var{start} and \var{n} must not exceed the length of \var{bytevector}. If not supplied, \var{start} defaults to zero and \var{n} defaults to the difference between the length of \var{bytevector} and \var{start}. This procedure normally writes the \var{n} bytes of \var{bytevector} starting at \var{start} to the port and advances the its position past the end of the bytes written. If the port is in nonblocking mode (see \scheme{set-port-nonblocking!}), however, the number of bytes written may be less than \var{n}, if the system would have to block to write more bytes. %---------------------------------------------------------------------------- \entryheader \formdef{put-string-some}{\categoryprocedure}{(put-string-some \var{textual-output-port} \var{string})} \formdef{put-string-some}{\categoryprocedure}{(put-string-some \var{textual-output-port} \var{string} \var{start})} \formdef{put-string-some}{\categoryprocedure}{(put-string-some \var{textual-output-port} \var{string} \var{start} \var{n})} \returns the number of characters written \listlibraries \endentryheader \noindent \var{start} and \var{n} must be nonnegative exact integers, and the sum of \var{start} and \var{n} must not exceed the length of \var{string}. If not supplied, \var{start} defaults to zero and \var{n} defaults to the difference between the length of \var{string} and \var{start}. This procedure normally writes the \var{n} characters of \var{string} starting at \var{start} to the port and advances the its position past the end of the characters written. If the port is in nonblocking mode (see \scheme{set-port-nonblocking!}), however, the number of characters written may be less than \var{n}, if the system would have to block to write more characters. %---------------------------------------------------------------------------- \entryheader \formdef{display-string}{\categoryprocedure}{(display-string \var{string})} \formdef{display-string}{\categoryprocedure}{(display-string \var{string} \var{textual-output-port})} \returns unspecified \listlibraries \endentryheader \noindent \scheme{display-string} writes the characters contained within \var{string} to \var{textual-output-port} or to the current-output port if \scheme{textual-output-port} is not specified. The enclosing string quotes are not printed, and special characters within the string are not escaped. \scheme{display-string} is a more efficient alternative to \scheme{display} for displaying strings. %---------------------------------------------------------------------------- \entryheader \formdef{block-write}{\categoryprocedure}{(block-write \var{textual-output-port} \var{string})} \formdef{block-write}{\categoryprocedure}{(block-write \var{textual-output-port} \var{string} \var{count})} \returns unspecified \listlibraries \endentryheader \noindent \var{count} must be a nonnegative fixnum less than or equal to the length of \var{string}. If not provided, it defaults to the length of \var{string}. \scheme{block-write} writes the first \var{count} characters of \var{string} to \var{textual-output-port}. If the port is buffered and the buffer is nonempty, the buffer is flushed before the contents of \var{string} are written. In any case, the contents of \var{string} are written immediately, without passing through the buffer. %---------------------------------------------------------------------------- \entryheader \formdef{truncate-port}{\categoryprocedure}{(truncate-port \var{output-port})} \formdef{truncate-port}{\categoryprocedure}{(truncate-port \var{output-port} \var{pos})} \formdef{truncate-file}{\categoryprocedure}{(truncate-file \var{output-port})} \formdef{truncate-file}{\categoryprocedure}{(truncate-file \var{output-port} \var{pos})} \returns unspecified \listlibraries \endentryheader \noindent \scheme{truncate-port} and \scheme{truncate-file} are identical. \var{pos} must be an exact nonnegative integer. It defaults to 0. These procedures truncate the file or other object associated with \var{output-port} to \var{pos} and repositions the port to that position, i.e., it combines the functionality of \scheme{set-port-length!} and \scheme{set-port-position!} and can be called on a port only if \scheme{port-has-set-port-length!?} and \scheme{port-has-set-port-position!?} are both true of the port. %---------------------------------------------------------------------------- \entryheader\label{desc:fresh-line} \formdef{fresh-line}{\categoryprocedure}{(fresh-line)} \formdef{fresh-line}{\categoryprocedure}{(fresh-line \var{textual-output-port})} \returns unspecified \listlibraries \endentryheader \noindent If \var{textual-output-port} is not supplied, it defaults to the current output port. This procedure behaves like \scheme{newline}, i.e., sends a newline character to \var{textual-output-port}, unless it can determine that the port is already positioned at the start of a line. It does this by flushing the port and consulting the ``beginning-of-line'' (BOL) flag associated with the port. (See page~\pageref{desc:set-port-bol}.) \section{Input/Output Operations\label{SECTIOINPUTOUTPUT}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{open-input-output-file}{\categoryprocedure}{(open-input-output-file \var{path})} \formdef{open-input-output-file}{\categoryprocedure}{(open-input-output-file \var{path} \var{options})} \returns a new input-output port \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{open-input-output-file} opens a textual input-output port for the file named by \var{path}. The port may be used to read from or write to the named file. The file is created if it does not already exist. \var{options}, if present, is a symbolic option name or option list. Possible symbolic option names are \scheme{buffered}, \scheme{unbuffered}, \scheme{exclusive}, and \scheme{nonexclusive}. An option list is a list containing zero or more symbolic option names and possibly the two-element option \scheme{mode \var{mode}}. See the description of \scheme{open-output-file} for an explanation of these options. Input/output files are usually closed using \scheme{close-port} but may also be closed with either \scheme{close-input-port} or \scheme{close-output-port}. %---------------------------------------------------------------------------- \entryheader \formdef{open-fd-input/output-port}{\categoryprocedure}{(open-fd-input/output-port \var{fd})} \formdef{open-fd-input/output-port}{\categoryprocedure}{(open-fd-input/output-port \var{fd} \var{b-mode})} \formdef{open-fd-input/output-port}{\categoryprocedure}{(open-fd-input/output-port \var{fd} \var{b-mode} \var{?transcoder})} \returns a new input/output port for the file descriptor \var{fd} \listlibraries \endentryheader \noindent \var{fd} must be a nonnegative exact integer and should be a valid open file descriptor. If \var{?transcoder} is present and not \scheme{#f}, it must be a transcoder, and this procedure returns a textual input/output port whose transcoder is \var{?transcoder}. Otherwise, this procedure returns a binary input/output port. See the lead-in to Section~\ref{TSPL:SECTOPENINGFILES} of {\TSPLFOUR} for a description of the constraints on and effects of the other arguments. The file descriptor is closed when the port is closed. \section{Non-Unicode Bytevector/String Conversions\label{SECTMBCONVS}} The procedures described in this section convert bytevectors containing single- and multiple-byte sequences in non-Unicode character sets to and from Scheme strings. They are available only under Windows. Under other operating systems, and when an \scheme{iconv} DLL is available under Windows, \scheme{bytevector->string} and \scheme{string->bytevector} can be used with a transcoder based on a codec constructed via \index{\scheme{iconv-codec}}\scheme{iconv-codec} to achieve the same results, with more control over the handling of invalid characters and line endings. %---------------------------------------------------------------------------- \entryheader \formdef{multibyte->string}{\categoryprocedure}{(multibyte->string \var{code-page} \var{bytevector})} \returns a string containing the characters encoded in \var{bytevector} \formdef{string->multibyte}{\categoryprocedure}{(string->multibyte \var{code-page} \var{string})} \returns a bytevector containing the encodings of the characters in \var{string} \listlibraries \endentryheader These procedures are available only under Windows. The procedure \scheme{multibyte->string} is a wrapper for the Windows API \scheme{MultiByteToWideChar} function, and \scheme{string->multibyte} is a wrapper for the Windows API \scheme{WideCharToMultiByte} function. \var{code-page} declares the encoding of the byte sequences in the input or output bytevectors. It must be an exact nonnegative integer identifying a code page or one of the symbols \scheme{cp-acp}, \scheme{cp-maccp}, \scheme{cp-oemcp}, \scheme{cp-symbol}, \scheme{cp-thread-acp}, \scheme{cp-utf7}, or \scheme{cp-utf8}, which have the same meanings as the API function meanings for the like-named constants. \section{Pretty Printing\label{SECTPRETTY}} The pretty printer is a version of the \scheme{write} procedure that produces more human-readable output via introduced whitespace, i.e., line breaks and indentation. The pretty printer is the default printer used by the read-eval-print loop (waiter) to print the output(s) of each evaluated form. The pretty printer may also be invoked explicitly by calling the procedure \scheme{pretty-print}. The pretty printer's operation can be controlled via the \scheme{pretty-format} procedure described later in this section, which allows the programmer to specify how specific forms are to be printed, various pretty-printer controls, also described later in this section, and also by the generic input/output controls described in Section~\ref{SECTMISCIOCONTROL}. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-print}{\categoryprocedure}{(pretty-print \var{obj})} \formdef{pretty-print}{\categoryprocedure}{(pretty-print \var{obj} \var{textual-output-port})} \returns unspecified \listlibraries \endentryheader \noindent If \var{textual-output-port} is not supplied, it defaults to the current output port. \scheme{pretty-print} is similar to \scheme{write} except that it uses any number of spaces and newlines in order to print \var{obj} in a style that is pleasing to look at and which shows the nesting level via indentation. For example, \schemedisplay (pretty-print '(define factorial (lambda (n) (let fact ((i n) (a 1)) (if (= i 0) a (fact (- i 1) (* a i))))))) \endschemedisplay \noindent might produce \schemedisplay (define factorial (lambda (n) (let fact ([i n] [a 1]) (if (= i 0) a (fact (- i 1) (* a i)))))) \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{pretty-file}{\categoryprocedure}{(pretty-file \var{ifn} \var{ofn})} \returns unspecified \listlibraries \endentryheader \noindent \var{ifn} and \var{ofn} must be strings. \scheme{pretty-file} reads each object in turn from the file named by \var{ifn} and pretty prints the object to the file named by \var{ofn}. Comments present in the input are discarded by the reader and so do not appear in the output file. If the file named by \var{ofn} already exists, it is replaced. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-format}{\categoryprocedure}{(pretty-format \var{sym})} \returns see below \formdef{pretty-format}{\categoryprocedure}{(pretty-format \var{sym} \var{fmt})} \returns unspecified \listlibraries \endentryheader \noindent By default, the pretty printer uses a generic algorithm for printing each form. This procedure is used to override this default and guide the pretty-printers treatment of specific forms. The symbol \var{sym} names a syntactic form or procedure. With just one argument, \scheme{pretty-format} returns the current format associated with \var{sym}, or \scheme{#f} if no format is associated with \var{sym}. In the two-argument case, the format \var{fmt} is associated with \var{sym} for future invocations of the pretty printer. \var{fmt} must be in the formatting language described below. \begin{grammar} \ang{fmt}\longis\scheme{(quote \var{symbol})}\\ \orbar\scheme{var}\\ \orbar\scheme{\var{symbol}}\\ \orbar\scheme{(read-macro \var{string} \var{symbol})}\\ \orbar\scheme{(meta)}\\ \orbar\scheme{(bracket . \var{fmt-tail})}\\ \orbar\scheme{(alt \var{fmt} \var{fmt}*)}\\ \orbar\scheme{\var{fmt-tail}}\\ \var{fmt-tail}\longis\scheme{()}\\ \orbar\scheme{(\var{tab} \var{fmt} ...)}\\ \orbar\scheme{(\var{fmt} \var{tab} ...)}\\ \orbar\scheme{(\var{tab} \var{fmt} . \var{fmt-tail})}\\ \orbar\scheme{(\var{fmt} ...)}\\ \orbar\scheme{(\var{fmt} . \var{fmt-tail})}\\ \orbar\scheme{(fill \var{tab} \var{fmt} ...)}\\ \var{tab}\longis\scheme{\var{int}}\\ \orbar\scheme{#f} \end{grammar} Some of the format forms are used for matching when there are multiple alternatives, while others are used for matching and control indentation or printing. A description of each \var{fmt} is given below. \begin{description} \item[\scheme{(quote \var{symbol})}:] This matches only the symbol \var{symbol}. \item[\scheme{var}:] This matches any symbol. \item[\scheme{\var{symbol}}:] This matches any input. \item[\scheme{(read-macro \var{string} \var{symbol})}:] This is used for read macros like \scheme{quote} and \var{syntax}. It matches any input of the form (\var{symbol} \var{subform}). For forms that match, the pretty printer prints \var{string} immediately followed by \var{subform}. \item[\scheme{(meta)}:] This is a special case used for the \scheme{meta} keyword (Section~\ref{SECTSYNTAXMETA}) which is used as a keyword prefix of another form. \item[\scheme{(alt \var{fmt} \var{fmt}*)}:] This compares the input against the specified formats and uses the one that is the closest match. Most often, one of the formats will match exactly, but in other cases, as when input is malformed or appears in abstract form in the template of a syntactic abstraction, none of the formats will match exactly. \item[\scheme{(bracket . \var{fmt-tail})}:] This matches any list-structured input and prints the input enclosed in square brackets, i.e., \index{\scheme{[}}\scheme{[} and \index{\scheme{]}}\scheme{]}, rather than parentheses. \item[\scheme{\var{fmt-tail}}:] This matches any list-structured input. \end{description} Indentation of list-structured forms is determined via the \var{fmt-tail} specifier used to the last two cases above. A description of each \var{fmt-tail} is given below. \begin{description} \item[\scheme{()}:] This matches an empty list tail. \item[\scheme{(\var{tab} \var{fmt} ...)}:] This matches the tail of any proper list; if the tail is nonempty and the list does not fit entirely on the current line, a line break is inserted before the first subform of the tail and \var{tab} (see below) determines the amount by which this and all subsequent subforms are indented. \item[\scheme{(\var{fmt} \var{tab} ...)}:] This matches the tail of any proper list; if the tail is nonempty and the list does not fit entirely on the current line, a line break is inserted after the first subform of the tail and \var{tab} (see below) determines the amount by which all subsequent subforms are indented. \item[\scheme{(\var{tab} \var{fmt} . \var{fmt-tail})}:] This matches a nonempty tail if the tail of the tail matches \var{fmt-tail}. If the list does not fit entirely on the current line, a line break is inserted before the first subform of the tail and \var{tab} (see below) determines the amount by which the subform is indented. \item[\scheme{(\var{fmt} ...)}:] This matches the tail of any proper list and specified that no line breaks are to be inserted before or after the current or subsequent subforms. \item[\scheme{(\var{fmt} . \var{fmt-tail})}:] This matches a nonempty tail if the tail of the tail matches \var{fmt-tail} and specifies that no line break is to be inserted before or after the current subform. \item[\scheme{(fill \var{tab} \var{fmt} ...)}:] This matches the tail of any proper list and invokes a fill mode in which the forms are packed with as many as will fit on each line. \end{description} A \var{tab} determines the amount by which a list subform is indented. If \var{tab} is a nonnegative exact integer \var{int}, the subform is indented \var{int} spaces in from the character position just after the opening parenthesis or bracket of the parent form. If \var{tab} is \scheme{#f}, the standard indentation is used. The standard indentation can be determined or changed via the parameter \scheme{pretty-standard-indent}, which is described later in this section. In cases where a format is given that doesn't quite match, the pretty printer tries to use the given format as far as it can. For example, if a format matches a list-structured form with a specific number of subforms, but more or fewer subform are given, the pretty printer will discard or replicate subform formats as necessary. Here is an example showing the formatting of \var{let} might be specified. \schemedisplay (pretty-format 'let '(alt (let ([bracket var x] 0 ...) #f e #f e ...) (let var ([bracket var x] 0 ...) #f e #f e ...))) \endschemedisplay Since \scheme{let} comes in two forms, named and unnamed, two alternatives are specified. In either case, the \scheme{bracket} \var{fmt} is used to enclose the bindings in square brackets, with all bindings after the first appearing just below the first (and just after the enclosing opening parenthesis), if they don't all fit on one line. Each body form is indented by the standard indentation. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-line-length}{\categorythreadparameter}{pretty-line-length} \formdef{pretty-one-line-limit}{\categorythreadparameter}{pretty-one-line-limit} \listlibraries \endentryheader \noindent The value of each of these parameters must be a positive fixnum. The parameters \scheme{pretty-line-length} and \scheme{pretty-one-line-limit} control the output produced by \index{\scheme{pretty-print}}\scheme{pretty-print}. \scheme{pretty-line-length} determines after which character position (starting from the first) on a line the pretty printer attempts to cut off output. This is a soft limit only; if necessary, the pretty-printer will go beyond \scheme{pretty-line-length}. \scheme{pretty-one-line-limit} is similar to \scheme{pretty-line-length}, except that it is relative to the first nonblank position on each line of output. It is also a soft limit. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-initial-indent}{\categorythreadparameter}{pretty-initial-indent} \listlibraries \endentryheader \noindent The value of this parameter must be a nonnegative fixnum. The parameter \scheme{pretty-initial-indent} is used to tell \index{\scheme{pretty-print}}\scheme{pretty-print} where on an output line it has been called. If \scheme{pretty-initial-indent} is zero (the default), \scheme{pretty-print} assumes that the first line of output it produces will start at the beginning of the line. If set to a nonzero value \var{n}, \scheme{pretty-print} assumes that the first line will appear at character position \var{n} and will adjust its printing of subsequent lines. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-standard-indent}{\categorythreadparameter}{pretty-standard-indent} \listlibraries \endentryheader \noindent The value of this parameter must be a nonnegative fixnum. This determines the amount by which \scheme{pretty-print} indents subexpressions of most forms, such as \scheme{let} expressions, from the form's keyword or first subexpression. %---------------------------------------------------------------------------- \entryheader \formdef{pretty-maximum-lines}{\categorythreadparameter}{pretty-maximum-lines} \listlibraries \endentryheader \noindent The parameter \scheme{pretty-maximum-lines} controls how many lines \scheme{pretty-print} prints when it is called. If set to \scheme{#f} (the default), no limit is imposed; if set to a nonnegative fixnum \var{n}, at most \var{n} lines are printed. \section{Formatted Output\label{SECTFORMAT}} %---------------------------------------------------------------------------- \noskipentryheader \formdef{format}{\categoryprocedure}{(format \var{format-string} \var{obj} \dots)} \formdef{format}{\categoryprocedure}{(format #f \var{format-string} \var{obj} \dots)} \formdef{format}{\categoryprocedure}{(format #t \var{format-string} \var{obj} \dots)} \formdef{format}{\categoryprocedure}{(format \var{textual-output-port} \var{format-string} \var{obj} \dots)} \returns see below \listlibraries \endentryheader \noindent \index{formatted output}% When the first argument to format is a string or \scheme{#f} (first and second forms above), \scheme{format} constructs an output string from \var{format-string} and the objects \scheme{\var{obj} \dots}. Characters are copied from \var{format-string} to the output string from left to right, until \var{format-string} is exhausted. The format string may contain one or more \var{format directives}, which are multi-character sequences prefixed by a tilde (~\scheme{~}~). Each directive is replaced by some other text, often involving one or more of the \scheme{\var{obj} \dots} arguments, as determined by the semantics of the directive. When the first argument is \scheme{#t}, output is sent to the current output port instead, as with \scheme{printf}. When the first argument is a port, output is sent to that port, as with \scheme{fprintf}. \scheme{printf} and \scheme{fprintf} are described later in this section. {\ChezScheme}'s implementation of \scheme{format} supports all of the Common Lisp~\cite{Steele:common} format directives except for those specific to the Common Lisp pretty printer. Please consult a Common Lisp reference or the \hyperlink{http://www.lispworks.com/documentation/HyperSpec/Front/index.htm}{Common Lisp Hyperspec}, for complete documentation. A few of the most useful directives are described below. % \begin{itemize} % \item \scheme{~s} % is replaced by the printed representation of the next \var{obj}, which % may be any object, in machine-readable format, as with \scheme{write}. % ``s'' is used for compatibility with \index{Common Lisp}Common Lisp, where it stands for % ``s-expression,'' the Lisp term for object. % % \item \scheme{~a} % is replaced by the printed representation of the next \var{obj}, which % may be any object, in human-readable format, as with \scheme{display}. % ``a'' is used for compatibility with \index{Common Lisp}Common Lisp, where it stands for % ``ascii.'' % % \item \scheme{~c} % is replaced by the next \var{obj}, which must be a character, as with % \scheme{write-char}. % % \item \scheme{~%} % is replaced by a newline character, as with \scheme{newline}. % % \item \scheme{~~} % is replaced by a single tilde. % \end{itemize} % % An exception is raised with condition-type \scheme{&assertion} % if more or fewer \var{objs} are given than required by % a \var{format-string} that requires a fixed number of objects, or if the % format string is malformed in any way. Absent any format directives, \scheme{format} simply displays its string argument. \schemedisplay (format "hi there") ;=> "hi there" \endschemedisplay The \scheme{~s} directive is replaced by the printed representation of the next \var{obj}, which may be any object, in machine-readable format, as with \scheme{write}. \schemedisplay (format "hi ~s" 'mom) ;=> "hi mom" (format "hi ~s" "mom") ;=> "hi \"mom\"" (format "hi ~s~s" 'mom #\!) ;=> "hi mom#\\!" \endschemedisplay The general form of a \scheme{~s} directive is actually \scheme{~\var{mincol},\var{colinc},\var{minpad},\var{padchar}s}, and the \scheme{s} can be preceded by an at sign (~\scheme{@}~) modifier. These additional parameters are used to control padding in the output, with at least \var{minpad} copies of \var{padchar} plus an integer multiple of \var{colinc} copies of \var{padchar} to make the total width, including the written object, \var{mincol} characters wide. The padding is placed on the left if the \var{@} modifier is present, otherwise on the right. \var{mincol} and \var{minpad} default to 0, \var{colinc} defaults to 1, and \var{padchar} defaults to space. If specified, \var{padchar} is prefixed by a single quote mark. \schemedisplay (format "~10s" 'hello) ;=> "hello " (format "~10@s" 'hello) ;=> " hello" (format "~10,,,'*@s" 'hello) ;=> "*****hello" \endschemedisplay The \scheme{~a} directive is similar, but prints the object as with \scheme{display}. \schemedisplay (format "hi ~s~s" "mom" #\!) ;=> "hi \"mom\"#\\!" (format "hi ~a~a" "mom" #\!) ;=> "hi mom!" \endschemedisplay A tilde may be inserted into the output with \scheme{~~}, and a newline may be inserted with \scheme{~%} (or embedded in the string with \scheme{\n}). \schemedisplay (format "~~line one,~%line two.~~") ;=> "~line one,\nline two.~" (format "~~line one,\nline two.~~") ;=> "~line one,\nline two.~" \endschemedisplay Real numbers may be printed in floating-point notation with \scheme{~f}. \schemedisplay (format "~f" 3.14159) ;=> 3.14159 \endschemedisplay Exact numbers may printed as well as inexact numbers in this manner; they are simply converted to inexact first as if with \scheme{exact->inexact}. \schemedisplay (format "~f" 1/3) ;=> "0.3333333333333333" \endschemedisplay The general form is actually \scheme{~\var{w},\var{d},\var{k},\var{overflowchar},\var{padchar}f}. If specified, \var{w} determines the overall width of the output, and \var{d} the number of digits to the right of the decimal point. \var{padchar}, which defaults to space, is the pad character used if padding is needed. Padding is always inserted on the left. The number is scaled by $10^k$ when printed; \var{k} defaults to zero. The entire \var{w}-character field is filled with copies of \var{overflowchar} if \var{overflowchar} is specified and the number cannot be printed in \var{w} characters. \var{k} defaults to 1 If an \scheme{@} modifier is present, a plus sign is printed before the number for nonnegative inputs; otherwise, a sign is printed only if the number is negative. \schemedisplay (format "~,3f" 3.14159) ;=> "3.142" (format "~10f" 3.14159) ;=> " 3.14159" (format "~10,,,'#f" 1e20) ;=> "##########" \endschemedisplay Real numbers may also be printed with \scheme{~e} for scientific notation or with \scheme{~g}, which uses either floating-point or scientific notation based on the size of the input. \schemedisplay (format "~e" 1e23) ;=> "1.0e+23" (format "~g" 1e23) ;=> "1.0e+23" \endschemedisplay A real number may also be printed with \scheme{~$}, which uses monetary notation defaulting to two digits to the right of the decimal point. \schemedisplay (format "$~$" (* 39.95 1.06)) ;=> "$42.35" (format "~$USD" 1/3) ;=> "0.33USD" \endschemedisplay Words can be pluralized automatically using \scheme{p}. \schemedisplay (format "~s bear~:p in ~s den~:p" 10 1) ;=> "10 bears in 1 den" \endschemedisplay Numbers may be printed out in words or roman numerals using variations on \scheme{~r}. \schemedisplay (format "~r" 2599) ;=> "two thousand five hundred ninety-nine" (format "~:r" 99) ;=> "ninety-ninth" (format "~@r" 2599) ;=> "MMDXCIX" \endschemedisplay Case conversions can be performed by bracketing a portion of the format string with the \scheme{~@(} and \scheme{~)} directives. \schemedisplay (format "~@(~r~)" 2599) ;=> "Two thousand five hundred ninety-nine" (format "~@:(~a~)" "Ouch!") ;=> "OUCH!" \endschemedisplay \noindent Some of the directives shown above have more options and parameters, and there are other directives as well, including directives for conditionals, iteration, indirection, and justification. Again, please consult a Common Lisp reference for complete documentation. An implementation of a greatly simplified version of \scheme{format} appears in Section~\ref{TSPL:SECTEXPRINTF} of {\TSPLFOUR}. %---------------------------------------------------------------------------- \entryheader \formdef{printf}{\categoryprocedure}{(printf \var{format-string} \var{obj} \dots)} \formdef{fprintf}{\categoryprocedure}{(fprintf \var{textual-output-port} \var{format-string} \var{obj} \dots)} \returns unspecified \listlibraries \endentryheader \noindent These procedures are simple wrappers for \scheme{format}. \scheme{printf} prints the formatted output to the current output, as with a first-argument of \scheme{#t} to \scheme{format}, and \scheme{fprintf} prints the formatted output to the \var{textual-output-port}, as when the first argument to \scheme{format} is a port. \section{Input/Output Control Operations\label{SECTMISCIOCONTROL}} The I/O control operations described in this section are used to control how the reader reads and printer writes, displays, or pretty-prints characters, symbols, gensyms, numbers, vectors, long or deeply nested lists or vectors, and graph-structured objects. %---------------------------------------------------------------------------- \entryheader\label{desc:char-name} \formdef{char-name}{\categoryprocedure}{(char-name \var{obj})} \returns see below \formdef{char-name}{\categoryprocedure}{(char-name \var{name} \var{char})} \returns unspecified \listlibraries \endentryheader \noindent \scheme{char-name} is used to associate names (symbols) with characters or to retrieve the most recently associated name or character for a given character or name. A name can map to only one character, but more than one name can map to the same character. The name most recently associated with a character determines how that character prints, and each name associated with a character may be used after the \scheme{#\} character prefix to name that character on input. Character associations created by \scheme{char-name} are ignored by the printer unless the parameter \scheme{print-char-name} is set to a true value. The reader recognizes character names established by \scheme{char-name} except after \scheme{#!r6rs}, which is implied within a library or R6RS top-level program. In the one-argument form, \var{obj} must be a symbol or character. If it is a symbol and a character is associated with the symbol, \scheme{char-name} returns that character. If it is a symbol and no character is associated with the symbol, \scheme{char-name} returns \scheme{#f}. Similarly, if \var{obj} is a character, \scheme{char-name} returns the most recently associated symbol for the character or \scheme{#f} if no name is associated with the character. For example, with the default set of character names: \schemedisplay (char-name #\space) ;=> space (char-name 'space) ;=> #\space (char-name 'nochar) ;=> #f (char-name #\a) ;=> #f \endschemedisplay When passed two arguments, \var{name} is added to the set of names associated with \var{char}, and any other association for \var{name} is dropped. \var{char} may be \scheme{#f}, in which case any other association for \var{name} is dropped and no new association is formed. In either case, any other names associated with \var{char} remain associated with \var{char}. The following interactive session demonstrates the use of \scheme{char-name} to establish and remove associations between characters and names, including the association of more than one name with a character. \schemedisplay (print-char-name #t) (char-name 'etx) ;=> #f (char-name 'etx #\x3) (char-name 'etx) ;=> #\etx (char-name #\x3) ;=> etx #\etx ;=> #\etx (eq? #\etx #\x3) ;=> #t #!r6rs #\etx ;=> \var{exception: invalid character name etx} #!chezscheme #\etx ;=> #\etx (char-name 'etx #\space) (char-name #\x3) ;=> #f (char-name 'etx) ;=> #\etx #\space ;=> #\etx (char-name 'etx #f) #\etx ;=> \var{exception: invalid character name etx} #\space ;=> #\space \endschemedisplay (When using the expression editor, it is necessary to type Control-J to force the editor to read the erroneous \scheme{#\etx} input on the two inputs above that result in read errors, since typing Enter causes the expression editor to read the input only if the input is well-formed.) The reader does not recognize hex scalar value escapes in character names, as it does in symbols, so \scheme{#\new\x6c;ine} is not equivalent to \scheme{#\newline}. In general, programmers should avoid the use of character name symbols that cannot be entered without the use of hex scalar value escapes or other symbol-name escape mechanisms, since such character names will not be readable. %---------------------------------------------------------------------------- \entryheader \formdef{print-char-name}{\categorythreadparameter}{print-char-name} \listlibraries \endentryheader \noindent When \scheme{print-char-name} is set to \scheme{#f} (the default), associations created by \scheme{char-name} are ignored by \scheme{write}, \scheme{put-datum}, \scheme{pretty-print}, and the \scheme{format} ``\scheme{~s}'' directive. Otherwise, these procedures use the names established by \scheme{char-name} when printing character objects. \schemedisplay (char-name 'etx #\x3) (format "~s" #\x3) ;=> "#\\x3" (parameterize ([print-char-name #t]) (format "~s" #\x3)) ;=> "#\\etx" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{case-sensitive}{\categorythreadparameter}{case-sensitive} \listlibraries \endentryheader \noindent The \scheme{case-sensitive} parameter determines whether the reader is case-sensitive with respect to symbol and character names. When set to true (the default, as required by the Revised$^6$ Report) the case of alphabetic characters within symbol names is significant. When set to \scheme{#f}, case is insignificant. More precisely, when set to \scheme{#f}, symbol and character names are folded (as if by \scheme{string-foldcase}); otherwise, they are left as they appear in the input. The value of the \scheme{case-sensitive} matters only if neither \scheme{#!fold-case} nor \scheme{#!no-fold-case} has appeared previously in the same input stream. That is, symbol and character name are folded if \scheme{#!fold-case} has been seen. They are not folded if \scheme{#!no-fold-case} has been seen. If neither has been seen, they are folded if and only if \scheme{(case-sensitive)} is \scheme{#f}. \schemedisplay (case-sensitive) ;=> #t (eq? 'abc 'ABC) ;=> #f 'ABC ;=> ABC (case-sensitive #f) 'ABC ;=> abc (eq? 'abc 'ABC) ;=> #t \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-graph}{\categorythreadparameter}{print-graph} \listlibraries \endentryheader \noindent When \scheme{print-graph} is set to a true value, \scheme{write} and \scheme{pretty-print} locate and print objects with shared structure, including cycles, in a notation that may be read subsequently with \scheme{read}. This notation employs the syntax \index{#= (graph mark)@\scheme{#\var{n}=} (graph mark)}``\scheme{#\var{n}=\var{obj}},'' where \var{n} is a nonnegative integer and \var{obj} is the printed representation of an object, to label the first occurrence of \var{obj} in the output. The syntax \index{## (graph reference)@\scheme{#\var{n}#} (graph reference)}``\scheme{#\var{n}#}'' is used to refer to the object labeled by \var{n} thereafter in the output. \scheme{print-graph} is set to \scheme{#f} by default. If graph printing is not enabled, the settings of \scheme{print-length} and \scheme{print-level} are insufficient to force finite output, and \scheme{write} or \scheme{pretty-print} detects a cycle in an object it is given to print, a warning is issued (an exception with condition type \scheme{&warning} is raised) and the object is printed as if \scheme{print-graph} were enabled. Since objects printed through the \scheme{~s} option in the format control strings of \scheme{format}, \scheme{printf}, and \scheme{fprintf} are printed as with \scheme{write}, the printing of such objects is also affected by \scheme{print-graph}. \schemedisplay (parameterize ([print-graph #t]) (let ([x (list 'a 'b)]) (format "~s" (list x x)))) ;=> "(#0=(a b) #0#)" (parameterize ([print-graph #t]) (let ([x (list 'a 'b)]) (set-car! x x) (set-cdr! x x) (format "~s" x))) ;=> "#0=(#0# . #0#)" \endschemedisplay \noindent The graph syntax is understood by the procedure \index{\scheme{read}}\scheme{read}, allowing graph structures to be printed and read consistently. %---------------------------------------------------------------------------- \entryheader \formdef{print-level}{\categorythreadparameter}{print-level} \formdef{print-length}{\categorythreadparameter}{print-length} \listlibraries \endentryheader \noindent These parameters can be used to limit the extent to which nested or multiple-element structures are printed. When called without arguments, \scheme{print-level} returns the current print level and \scheme{print-length} returns the current print length. When called with one argument, which must be a nonnegative fixnum or \scheme{#f}, \scheme{print-level} sets the current print level and \scheme{print-length} sets the current print length to the argument. When \scheme{print-level} is set to a nonnegative integer \var{n}, \scheme{write} and \scheme{pretty-print} traverse only \var{n} levels deep into nested structures. If a structure being printed exceeds \var{n} levels of nesting, the substructure beyond that point is replaced in the output by an \index{\scheme{...}~(ellipses)}\index{ellipses (~\scheme{...}~)}ellipsis (~\scheme{...}~). \scheme{print-level} is set to \scheme{#f} by default, which places no limit on the number of levels printed. When \scheme{print-length} is set to a nonnegative integer \var{n}, the procedures \scheme{write} and \scheme{pretty-print} print only \var{n} elements of a list or vector, replacing the remainder of the list or vector with an \index{\scheme{...}~(ellipses)}\index{ellipses (~\scheme{...}~)}ellipsis (~\scheme{...}~). \scheme{print-length} is set to \scheme{#f} by default, which places no limit on the number of elements printed. Since objects printed through the \scheme{~s} option in the format control strings of \scheme{format}, \scheme{printf}, and \scheme{fprintf} are printed as with \scheme{write}, the printing of such objects is also affected by \scheme{print-level} and \scheme{print-length}. The parameters \scheme{print-level} and \scheme{print-length} are useful for controlling the volume of output in contexts where only a small portion of the output is needed to identify the object being printed. They are also useful in situations where circular structures may be printed (see also \scheme{print-graph}). \schemedisplay (format "~s" '((((a) b) c) d e f g)) ;=> "((((a) b) c) d e f g)" (parameterize ([print-level 2]) (format "~s" '((((a) b) c) d e f g))) ;=> "(((...) c) d e f g)" (parameterize ([print-length 3]) (format "~s" '((((a) b) c) d e f g))) ;=> "((((a) b) c) d e ...)" (parameterize ([print-level 2] [print-length 3]) (format "~s" '((((a) b) c) d e f g))) ;=> "(((...) c) d e ...)" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-radix}{\categorythreadparameter}{print-radix} \listlibraries \endentryheader \noindent The \scheme{print-radix} parameter determines the radix in which numbers are printed by \scheme{write}, \scheme{pretty-print}, and \scheme{display}. Its value should be an integer between 2 and 36, inclusive. Its default value is 10. When the value of \scheme{print-radix} is not 10, \scheme{write} and \scheme{pretty-print} print a radix prefix before the number (\scheme{#b} for radix 2, \scheme{#o} for radix 8, \scheme{#x} for radix 16, and \scheme{#\var{n}r} for any other radix \var{n}). Since objects printed through the \scheme{~s} and \scheme{~a} options in the format control strings of \scheme{format}, \scheme{printf}, and \scheme{fprintf} are printed as with \scheme{write} and \scheme{display}, the printing of such objects is also affected by \scheme{print-radix}. \schemedisplay (format "~s" 11242957) ;=> "11242957" (parameterize ([print-radix 16]) (format "~s" 11242957)) ;=> "#xAB8DCD" (parameterize ([print-radix 16]) (format "~a" 11242957)) ;=> "AB8DCD" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-gensym}{\categorythreadparameter}{print-gensym} \listlibraries \endentryheader \noindent \index{\scheme{gensym}}\index{\scheme{#:} (gensym prefix)}When \scheme{print-gensym} is set to \scheme{#t} (the default) gensyms are printed with an extended symbol syntax that includes both the pretty name and the unique name of the gensym: \index{\scheme{#\schlbrace} (gensym prefix)}\scheme{#\schlbrace\var{pretty-name} \var{unique-name}\schrbrace}. When set to \scheme{pretty}, the pretty name only is shown, with the prefix \index{\scheme{#:} (gensym prefix)}\scheme{#:}. When set to \scheme{pretty/suffix}, the printer prints the gensym's ``pretty'' name along with a suffix based on the gensym's ``unique'' name, separated by a dot (~"."~). If the gensym's unique name is generated automatically during the current session, the suffix is that portion of the unique name that is not common to all gensyms created during the current session. Otherwise, the suffix is the entire unique name. When set to \scheme{#f}, the pretty name only is shown, with no prefix. Since objects printed through the \scheme{~s} option in the format control strings of \scheme{format}, \scheme{printf}, \scheme{errorf}, etc., are printed as with \scheme{write}, the printing of such objects is also affected by \scheme{print-gensym}. When printing an object that may contain more than one occurrence of a gensym and \scheme{print-graph} is set to \scheme{pretty} or \scheme{#f}, it is useful to set \scheme{print-graph} to \scheme{#t} so that multiple occurrences of the same gensym are marked as identical in the output. \schemedisplay (let ([g (gensym)]) (format "~s" g)) ;=> "#{g0 bdids2xl6v49vgwe-a}" (let ([g (gensym)]) (parameterize ([print-gensym 'pretty]) (format "~s" g))) ;=> "#:g1 (let ([g (gensym)]) (parameterize ([print-gensym #f]) (format "~s" g))) ;=> "g2" (let ([g (gensym)]) (parameterize ([print-graph #t] [print-gensym 'pretty]) (format "~s" (list g g)))) ;=> "(#0=#:g3 #0#)" (let ([g1 (gensym "x")] [g2 (gensym "x")] [g3 (gensym "y")]) (parameterize ([print-gensym 'pretty/suffix]) (format "~s ~s ~s" g1 g2 g3))) ;=> "x.1 x.2 y.3" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-brackets}{\categorythreadparameter}{print-brackets} \listlibraries \endentryheader \noindent When \scheme{print-brackets} is set to a true value, the pretty printer (see \index{\scheme{pretty-print}}\scheme{pretty-print}) uses square brackets rather than parentheses around certain subexpressions of common control structures, e.g., around \scheme{let} bindings and \scheme{cond} clauses. \scheme{print-brackets} is set to \scheme{#t} by default. \schemedisplay (let ([p (open-output-string)]) (pretty-print '(let ([x 3]) x) p) ;=> "(let ([x 3]) x) (get-output-string p)) ;== " (parameterize ([print-brackets #f]) (let ([p (open-output-string)]) (pretty-print '(let ([x 3]) x) p) ;=> "(let ((x 3)) x) (get-output-string p))) ;== " \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-extended-identifiers}{\categorythreadparameter}{print-extended-identifiers} \listlibraries \endentryheader Chez Scheme extends the syntax of identifiers as described in Section~\ref{SECTINTROSYNTAX}, except within a set of forms prefixed by \scheme{#!r6rs} (which is implied in a library or top-level program). When this parameter is set to false (the default), identifiers in the extended set are printed with hex scalar value escapes as necessary to conform to the R6RS syntax for identifiers. When this parameter is set to a true value, identifiers in the extended set are printed without the escapes. Identifiers whose names fall outside of both syntaxes are printed with the escapes regardless of the setting of this parameter. For example: \schemedisplay (parameterize ([print-extended-identifiers #f]) (printf "~s\n~s\n" '(1+ --- { } .xyz) (string->symbol "123"))) \endschemedisplay prints \schemedisplay (\x31;+ \x2D;-- \x7B; \x7D; \x2E;xyz) \x31;23 \endschemedisplay while \schemedisplay (parameterize ([print-extended-identifiers #t]) (printf "~s\n~s\n" '(1+ --- { } .xyz) (string->symbol "123"))) \endschemedisplay prints \schemedisplay (1+ --- { } .xyz) \x31;23 \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-vector-length}{\categorythreadparameter}{print-vector-length} \listlibraries \endentryheader \noindent When \scheme{print-vector-length} is set to a true value, \scheme{write}, \scheme{put-datum}, and \scheme{pretty-print} includes the length for all vectors between the ``\scheme{#}'' and open parenthesis, all bytevectors between the ``\scheme{#vu8}'' and open parenthesis, and all fxvectors between the ``\scheme{#vfx}'' and open parenthesis. This parameter is set to \scheme{#f} by default. \index{vector printing}When \scheme{print-vector-length} is set to a true value, \scheme{write}, \scheme{put-datum}, and \scheme{pretty-print} also suppress duplicated trailing elements in the vector to reduce the amount of output. This form is also recognized by the reader. Since objects printed through the \scheme{~s} option in the format control strings of \scheme{format}, \scheme{printf}, and \scheme{fprintf} are printed as with \scheme{write}, the printing of such objects is also affected by the setting of \scheme{print-vector-length}. \schemedisplay (format "~s" (vector 'a 'b 'c 'c 'c)) ;=> "#(a b c c c)" (parameterize ([print-vector-length #t]) (format "~s" (vector 'a 'b 'c 'c 'c))) ;=> "#5(a b c)" (parameterize ([print-vector-length #t]) (format "~s" (bytevector 1 2 3 4 4 4))) ;=> "#6vu8(1 2 3 4)" (parameterize ([print-vector-length #t]) (format "~s" (fxvector 1 2 3 4 4 4))) ;=> "#6vfx(1 2 3 4)" \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{print-precision}{\categorythreadparameter}{print-precision} \listlibraries \endentryheader \noindent When \scheme{print-precision} is set to \scheme{#f} (the default), \scheme{write}, \scheme{put-datum}, \scheme{pretty-print}, and the \scheme{format} ``\scheme{~s}'' directive do not include the vertical-bar ``mantissa-width'' syntax after each floating-point number. When set to a nonnegative exact integer, the mantissa width is included, as per the precision argument to \scheme{number->string}. %---------------------------------------------------------------------------- \entryheader \formdef{print-unicode}{\categorythreadparameter}{print-unicode} \listlibraries \endentryheader \noindent When \scheme{print-unicode} is set to \scheme{#f}, \scheme{write}, \scheme{put-datum}, \scheme{pretty-print}, and the \scheme{format} ``\scheme{~s}'' directive display Unicode characters with encodings $80_{16}$ (128) and above that appear within character objects, symbols, and strings using hexadecimal character escapes. When set to a true value (the default), they are displayed like other printing characters, as if by \scheme{put-char}. \schemedisplay (format "~s" #\x3bb) ;=> "#\\\raw{$\lambda$}" (parameterize ([print-unicode #f]) (format "~s" #\x3bb)) ;=> "#\\x3BB" \endschemedisplay \section{Fasl Output\label{SECTFASL}} \index{fast loading format}% The procedures \scheme{write} and \scheme{pretty-print} print objects in a human readable format. For objects with external datum representations, the output produced by \scheme{write} and \scheme{pretty-print} is also machine-readable with \scheme{read}. Objects with external datum representations include pairs, symbols, vectors, strings, numbers, characters, booleans, and records but not procedures and ports. An alternative \emph{fast loading}, or \emph{fasl}, format may be used for objects with external datum representations. The fasl format is not human readable, but it is machine readable and both more compact and more quickly processed by \scheme{read}. This format is always used for compiled code generated by \scheme{compile-file}, but it may also be used for data that needs to be written and read quickly, such as small databases encoded with Scheme data structures. Objects are printed in fasl format with \scheme{fasl-write}. Because the fasl format is a binary format, fasl output must be written to a binary port. For this reason, it is not possible to include data written in fasl format with textual data in the same file, as was the case in earlier versions of {\ChezScheme}. Similarly, the (textual) reader does not handle objects written in fasl format; the procedure \scheme{fasl-read}, which requires a binary input port, must be used instead. %---------------------------------------------------------------------------- \entryheader \formdef{fasl-write}{\categoryprocedure}{(fasl-write \var{obj} \var{binary-output-port})} \returns unspecified \listlibraries \endentryheader \noindent \scheme{fasl-write} writes the fasl representation of \var{obj} to \var{binary-output-port}. An exception is raised with condition-type \scheme{&assertion} if \var{obj} or any portion of \var{obj} has no external fasl representation, e.g., if \var{obj} is or contains a procedure. The fasl representation of \var{obj} is compressed if the parameter \scheme{fasl-compressed}, described below, is set to \scheme{#t}, its default value. For this reason, \var{binary-output-port} generally should not be opened with the compressed option. A warning is issued (an exception with condition type \scheme{&warning} is raised) on the first attempt to write fasl objects to or read fasl objects from a compressed file. \schemedisplay (define bop (open-file-output-port "tmp.fsl")) (fasl-write '(a b c) bop) (close-port bop) (define bip (open-file-input-port "tmp.fsl")) (fasl-read bip) ;=> (a b c) (fasl-read bip) ;=> #!eof (close-port bip) \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{fasl-read}{\categoryprocedure}{(fasl-read \var{binary-input-port})} \formdef{fasl-read}{\categoryprocedure}{(fasl-read \var{binary-input-port \var{situation}})} \returns unspecified \listlibraries \endentryheader \noindent If present, \var{situation} must be one of the symbols \scheme{load}, \scheme{visit}, or \scheme{revisit}. It defaults to \scheme{load}. \scheme{fasl-read} reads one object from \var{binary-input-port}, which must be positioned at the front of an object written in fasl format. \scheme{fasl-read} returns the eof object if the file is positioned at the end of file. If the situation is \scheme{visit}, \scheme{fasl-read} skips over any revisit (run-time-only) objects, and if the situation is \scheme{revisit}, \scheme{fasl-read} skips over any visit (compile-time-only) objects. It doesn't skip any if the situation is \scheme{load}. Similarly, objects marked as both visit and revisit (e.g., object code corresponding to source code within an \scheme{eval-when} form with situation \scheme{load} or situations \scheme{visit} and \scheme{revisit}) are never skipped. \scheme{fasl-read} automatically decompresses the representation of each fasl object written in compressed format by \scheme{fasl-write}. Thus, \var{binary-input-port} generally should not be opened with the compressed option. A warning is issued (an exception with condition type \scheme{&warning} is raised) on the first attempt to write fasl objects to or read fasl objects from a compressed file. \schemedisplay (define bop (open-file-output-port "tmp.fsl")) (fasl-write '(a b c) bop) (close-port bop) (define bip (open-file-input-port "tmp.fsl")) (fasl-read bip) ;=> (a b c) (fasl-read bip) ;=> #!eof (close-port bip) \endschemedisplay %---------------------------------------------------------------------------- \entryheader \formdef{fasl-compressed}{\categorythreadparameter}{fasl-compressed} \listlibraries \endentryheader \noindent When this parameter is set to its default value, \scheme{#t}, \scheme{fasl-write} compresses the representation of each object as it writes it, often resulting in substantially smaller output but possibly taking more time to write and read. The compression format and level are determined by the \index{\scheme{compress-format}}\scheme{compress-format} and \index{\scheme{compress-level}}\scheme{compress-level} parameters. %---------------------------------------------------------------------------- \entryheader \formdef{fasl-file}{\categoryprocedure}{(fasl-file \var{ifn} \var{ofn})} \returns unspecified \listlibraries \endentryheader \noindent \var{ifn} and \var{ofn} must be strings. \scheme{fasl-file} may be used to convert a file in human-readable format into an equivalent file written in fasl format. \scheme{fasl-file} reads each object in turn from the file named by \var{ifn} and writes the fasl format for the object onto the file named by \var{ofn}. If the file named by \var{ofn} already exists, it is replaced. \section{File System Interface\label{SECTIOFILESYSTEM}} This section describes operations on files, directories, and pathnames. %---------------------------------------------------------------------------- \entryheader \formdef{current-directory}{\categoryglobalparameter}{current-directory} \formdef{cd}{\categoryglobalparameter}{cd} \listlibraries \endentryheader \noindent When invoked without arguments, \scheme{current-directory} returns a string representing the current working directory. Otherwise, the current working directory is changed to the directory specified by the argument, which must be a string representing a valid directory pathname. \scheme{cd} is bound to the same parameter. %---------------------------------------------------------------------------- \entryheader \formdef{directory-list}{\categoryprocedure}{(directory-list \var{path})} \returns a list of file names \listlibraries \endentryheader \var{path} must be a string. The return value is a list of strings representing the names of files found in the directory named by \var{path}. \scheme{directory-list} raises an exception with condition type \scheme{&i/o-filename} if \var{path} does not name a directory or if the process cannot list the directory. %---------------------------------------------------------------------------- \entryheader \formdef{file-exists?}{\categoryprocedure}{(file-exists? \var{path})} \formdef{file-exists?}{\categoryprocedure}{(file-exists? \var{path} \var{follow?})} \returns \scheme{#t} if the file named by \var{path} exists, \scheme{#f} otherwise \listlibraries \endentryheader \var{path} must be a string. If the optional \var{follow?} argument is true (the default), \scheme{file-exists?} follows symbolic links; otherwise it does not. Thus, \scheme{file-exists?} will return \scheme{#f} when handed the pathname of a broken symbolic link unless \var{follow?} is provided and is \scheme{#f}. The Revised$^6$ Report \scheme{file-exists?} does not accept the optional \var{follow?} argument. Whether it follows symbolic links is unspecified. %---------------------------------------------------------------------------- \entryheader \formdef{file-regular?}{\categoryprocedure}{(file-regular? \var{path})} \formdef{file-regular?}{\categoryprocedure}{(file-regular? \var{path} \var{follow?})} \returns \scheme{#t} if the file named by \var{path} is a regular file, \scheme{#f} otherwise \listlibraries \endentryheader \var{path} must be a string. If the optional \var{follow?} argument is true (the default), \scheme{file-regular?} follows symbolic links; otherwise it does not. %---------------------------------------------------------------------------- \entryheader \formdef{file-directory?}{\categoryprocedure}{(file-directory? \var{path})} \formdef{file-directory?}{\categoryprocedure}{(file-directory? \var{path} \var{follow?})} \returns \scheme{#t} if the file named by \var{path} is a directory, \scheme{#f} otherwise \listlibraries \endentryheader \var{path} must be a string. If the optional \var{follow?} argument is true (the default), this procedure follows symbolic links; otherwise it does not. %---------------------------------------------------------------------------- \entryheader \formdef{file-symbolic-link?}{\categoryprocedure}{(file-symbolic-link? \var{path})} \returns \scheme{#t} if the file named by \var{path} is a symbolic link, \scheme{#f} otherwise \listlibraries \endentryheader \var{path} must be a string. \scheme{file-symbolic-link?} never follows symbolic links in making its determination. %---------------------------------------------------------------------------- \entryheader \formdef{file-access-time}{\categoryprocedure}{(file-access-time \var{path/port})} \formdef{file-access-time}{\categoryprocedure}{(file-access-time \var{path/port} \var{follow?})} \returns the access time of the specified file \formdef{file-change-time}{\categoryprocedure}{(file-change-time \var{path/port})} \formdef{file-change-time}{\categoryprocedure}{(file-change-time \var{path/port} \var{follow?})} \returns the change time of the specified file \formdef{file-modification-time}{\categoryprocedure}{(file-modification-time \var{path/port})} \formdef{file-modification-time}{\categoryprocedure}{(file-modification-time \var{path/port} \var{follow?})} \returns the modification time of the specified file \listlibraries \endentryheader \var{path/port} must be a string or port. If \var{path/port} is a string, the time returned is for the file named by the string, and the optional \var{follow?} argument determines whether symbolic links are followed. If \var{follow?} is true (the default), this procedure follows symbolic links; otherwise it does not. If \var{path/port} is a port, it must be a file port, and the time returned is for the associated file. In this case, \var{follow?} is ignored. The returned times are represented as time objects (Section~\ref{SECTSYSTEMTIMESNDATES}). %---------------------------------------------------------------------------- \entryheader \formdef{mkdir}{\categoryprocedure}{(mkdir \var{path})} \formdef{mkdir}{\categoryprocedure}{(mkdir \var{path} \var{mode})} \returns unspecified \listlibraries \endentryheader \noindent \var{path} must be a string. \var{mode} must be a fixnum. \scheme{mkdir} creates a directory with the name given by \var{path}. All \var{path} path components leading up to the last must already exist. If the optional \var{mode} argument is present, it overrides the default permissions for the new directory. Under Windows, the \var{mode} argument is ignored. \scheme{mkdir} raises an exception with condition type \scheme{&i/o-filename} if the directory cannot be created. %---------------------------------------------------------------------------- \entryheader \formdef{delete-file}{\categoryprocedure}{(delete-file \var{path})} \formdef{delete-file}{\categoryprocedure}{(delete-file \var{path} \var{error?})} \returns see below \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{delete-file} removes the file named by \var{path}. If the optional \var{error?} argument is \scheme{#f} (the default), \scheme{delete-file} returns a boolean value: \scheme{#t} if the operation is successful and \scheme{#f} if it is not. Otherwise, \scheme{delete-file} returns an unspecified value if the operation is successful and raises an exception with condition type \scheme{&i/o-filename} if it is not. The Revised$^6$ Report \scheme{delete-file} does not accept the optional \var{error?} argument but behaves as if \var{error?} is true. %---------------------------------------------------------------------------- \entryheader \formdef{delete-directory}{\categoryprocedure}{(delete-directory \var{path})} \formdef{delete-directory}{\categoryprocedure}{(delete-directory \var{path} \var{error?})} \returns see below \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{delete-directory} removes the directory named by \var{path}. If the optional \var{error?} argument is \scheme{#f} (the default), \scheme{delete-directory} returns a boolean value: \scheme{#t} if the operation is successful and \scheme{#f} if it is not. Otherwise, \scheme{delete-directory} returns an unspecified value if the operation is successful and raises an exception with condition type \scheme{&i/o-filename} if it is not. The behavior is unspecified if the directory is not empty, but on most systems the operations will not succeed. %---------------------------------------------------------------------------- \entryheader \formdef{rename-file}{\categoryprocedure}{(rename-file \var{old-pathname} \var{new-pathname})} \returns unspecified \listlibraries \endentryheader \noindent \var{old-pathname} and \var{new-pathname} must be strings. \scheme{rename-file} changes the name of the file named by \var{old-pathname} to \var{new-pathname}. If the file does not exist or cannot be renamed, an exception is raised with condition type \scheme{&i/o-filename}. %---------------------------------------------------------------------------- \entryheader \formdef{chmod}{\categoryprocedure}{(chmod \var{path} \var{mode})} \returns unspecified \listlibraries \endentryheader \noindent \var{path} must be a string. \var{mode} must be a fixnum. \scheme{chmod} sets the permissions on the file named by \var{path} to \var{mode}. Bits 0, 1, and~2 of \var{mode} are the execute, write, and read permission bits for users other than the file's owner who are not in the file's group. Bits 3-5 are the execute, write, and read permission bits for users other than the file's owner but in the file's group. Bits 6-8 are the execute, write, and read permission bits for the file's owner. Bits 7-9 are the Unix sticky, set-group-id, and set-user-id bits. Under Windows, all but the user ``write'' bit are ignored. If the file does not exist or the permissions cannot be changed, an exception is raised with condition type \scheme{&i/o-filename}. %---------------------------------------------------------------------------- \entryheader \formdef{get-mode}{\categoryprocedure}{(get-mode \var{path})} \formdef{get-mode}{\categoryprocedure}{(get-mode \var{path} \var{follow?})} \returns the current permissions mode for \var{path} \listlibraries \endentryheader \noindent \var{path} must be a string. \scheme{get-mode} retrieves the permissions on the file named by \var{path} and returns them as a fixnum in the same form as the \var{mode} argument to \scheme{chmod}. If the optional \var{follow?} argument is true (the default), this procedure follows symbolic links; otherwise it does not. %---------------------------------------------------------------------------- \entryheader \formdef{directory-separator?}{\categoryprocedure}{(directory-separator? \var{char})} \returns \scheme{#t} if \var{char} is a directory separator, \scheme{#f} otherwise \listlibraries \endentryheader The character \scheme{#\/} is a directory separator on all current machine types, and \scheme{#\\} is a directory separator under Windows. %---------------------------------------------------------------------------- \entryheader \formdef{directory-separator}{\categoryprocedure}{(directory-separator)} \returns the preferred directory separator \listlibraries \endentryheader The preferred directory separator is \scheme{#\\} for Windows and \scheme{#\/} for other systems. %---------------------------------------------------------------------------- \entryheader \formdef{path-first}{\categoryprocedure}{(path-first \var{path})} \formdef{path-rest}{\categoryprocedure}{(path-rest \var{path})} \formdef{path-last}{\categoryprocedure}{(path-last \var{path})} \formdef{path-parent}{\categoryprocedure}{(path-parent \var{path})} \formdef{path-extension}{\categoryprocedure}{(path-extension \var{path})} \formdef{path-root}{\categoryprocedure}{(path-root \var{path})} \returns the specified component of \var{path} \formdef{path-absolute?}{\categoryprocedure}{(path-absolute? \var{path})} \returns \scheme{#t} if \var{path} is absolute, otherwise \scheme{#f} \listlibraries \endentryheader \var{path} must be a string. The return value is also a (possibly empty) string. The path first component is the first directory in the path, or the empty string if the path consists only of a single filename. The path rest component is the portion of the path that does not include the path first component or the directory separator (if any) that separates it from the rest of the path. The path last component is the last (filename) portion of \var{path}. The path parent component is the portion of \var{path} that does not include the path last component, if any, or the directory separator that separates it from the rest of the path. If the first component of the path names a root directory (including drives and shares under Windows), home directory (e.g., \scheme{~/abc} or \scheme{~user/abc}), the current directory (\scheme{.}), or the parent directory (\scheme{..}), \scheme{path-first} returns that component. For paths that consist only of such a directory, both \scheme{path-first} and \scheme{path-parent} act as identity procedures, while \scheme{path-rest} and \scheme{path-last} return the empty string. The path extension component is the portion of \var{path} that follows the last dot (period) in the last component of a path name. The path root component is the portion of \var{path} that does not include the extension, if any, or the dot that precedes it. If the first component names a root directory (including drives and shares under Windows) or home directory, \scheme{path-absolute?} returns \scheme{#t}. Otherwise, \scheme{path-absolute?} returns \scheme{#f}. The tables below identify the components for several example paths, with underscores representing empty strings. \begin{tabular}{llllllll} path & abs & first & rest & parent & last & root & ext \\ \scheme{a} & \scheme{#f} & \scheme{_} & \scheme{a} & \scheme{_} & \scheme{a} & \scheme{a} & \scheme{_} \\ \scheme{a/} & \scheme{#f} & \scheme{a} & \scheme{_} & \scheme{a} & \scheme{_} & \scheme{a/} & \scheme{_} \\ \scheme{a/b} & \scheme{#f} & \scheme{a} & \scheme{b} & \scheme{a} & \scheme{b} & \scheme{a/b} & \scheme{_} \\ \scheme{a/b.c} & \scheme{#f} & \scheme{a} & \scheme{b.c} & \scheme{a} & \scheme{b.c} & \scheme{a/b} & \scheme{c} \\ \scheme{/} & \scheme{#t} & \scheme{/} & \scheme{_} & \scheme{/} & \scheme{_} & \scheme{/} & \scheme{_} \\ \scheme{/a/b.c} & \scheme{#t} & \scheme{/} & \scheme{a/b.c} & \scheme{/a} & \scheme{b.c} & \scheme{/a/b} & \scheme{c} \\ \scheme{~/a/b.c} & \scheme{#t} & \scheme{~} & \scheme{a/b.c} & \scheme{~/a} & \scheme{b.c} & \scheme{~/a/b} & \scheme{c} \\ \scheme{~u/a/b.c} & \scheme{#t} & \scheme{~u} & \scheme{a/b.c} & \scheme{~u/a} & \scheme{b.c} & \scheme{~u/a/b} & \scheme{c} \\ \scheme{../..} & \scheme{#f} & \scheme{..} & \scheme{..} & \scheme{..} & \scheme{..} & \scheme{../..} & \scheme{_} \\ \end{tabular} The second table shows the components when Windows drives and shares are involved. \begin{tabular}{llllllll} path & abs & first & rest & parent & last & root & ext \\ \scheme{c:} & \scheme{#f} & \scheme{c:} & \scheme{_} & \scheme{c:} & \scheme{_} & \scheme{c:} & \scheme{_} \\ \scheme{c:/} & \scheme{#t} & \scheme{c:/} & \scheme{_} & \scheme{c:/} & \scheme{_} & \scheme{c:/} & \scheme{_} \\ \scheme{c:a/b} & \scheme{#f} & \scheme{c:} & \scheme{a/b} & \scheme{c:a} & \scheme{b} & \scheme{c:a/b} & \scheme{_} \\ \scheme{//s/a/b.c} & \scheme{#t} & \scheme{//s} & \scheme{a/b.c} & \scheme{//s/a} & \scheme{b.c} & \scheme{//s/a/b} & \scheme{c} \\ \scheme{//s.com} & \scheme{#t} & \scheme{//s.com} & \scheme{_} & \scheme{//s.com} & \scheme{_} & \scheme{//s.com} & \scheme{_} \\ \end{tabular} The following procedure can be used to reproduce the tables above. \schemedisplay (define print-table (lambda path* (define print-row (lambda (abs? path first rest parent last root extension) (printf "~a~11t~a~17t~a~28t~a~39t~a~50t~a~61t~a~73t~a\n" abs? path first rest parent last root extension))) (print-row "path" "abs" "first" "rest" "parent" "last" "root" "ext") (for-each (lambda (path) (define uscore (lambda (s) (if (eqv? s "") "_" s))) (apply print-row path (map (lambda (s) (if (eqv? s "") "_" s)) (list (path-absolute? path) (path-first path) (path-rest path) (path-parent path) (path-last path) (path-root path) (path-extension path))))) path*))) \endschemedisplay For example, the first table can be produced with: \schemedisplay (print-table "a" "a/" "a/b" "a/b.c" "/" "/a/b.c" "~/a/b.c" "~u/a/b.c" "../..") \endschemedisplay while the second can be produced (under Windows) with: \schemedisplay (print-table "c:" "c:/" "c:a/b" "//s/a/b.c" "//s.com") \endschemedisplay \section{Generic Port Examples\label{SECTPORTEXAMPLES}} This section presents the definitions for three types of generic ports: two-way ports, transcript ports, and process ports. \parheader{Two-way ports} \index{two-way ports}The first example defines \scheme{make-two-way-port}, which constructs a textual input/output port from a given pair of textual input and output ports. For example: \schemedisplay (define ip (open-input-string "this is the input")) (define op (open-output-string)) (define p (make-two-way-port ip op)) \endschemedisplay \noindent The port returned by \scheme{make-two-way-port} is both an input and an output port, and it is also a textual port: \schemedisplay (port? p) ;=> #t (input-port? p) ;=> #t (output-port? p) ;=> #t (textual-port? p) ;=> #t \endschemedisplay \noindent Items read from a two-way port come from the constituent input port, and items written to a two-way port go to the constituent output port: \schemedisplay (read p) ;=> this (write 'hello p) (get-output-string op) ;=> hello \endschemedisplay \noindent The definition of \scheme{make-two-way-port} is straightforward. To keep the example simple, no local buffering is performed, although it would be more efficient to do so. \schemedisplay (define make-two-way-port (lambda (ip op) (define handler (lambda (msg . args) (record-case (cons msg args) [block-read (p s n) (block-read ip s n)] [block-write (p s n) (block-write op s n)] [char-ready? (p) (char-ready? ip)] [clear-input-port (p) (clear-input-port ip)] [clear-output-port (p) (clear-output-port op)] [close-port (p) (mark-port-closed! p)] [flush-output-port (p) (flush-output-port op)] [file-position (p . pos) (apply file-position ip pos)] [file-length (p) (file-length ip)] [peek-char (p) (peek-char ip)] [port-name (p) "two-way"] [read-char (p) (read-char ip)] [unread-char (c p) (unread-char c ip)] [write-char (c p) (write-char c op)] [else (assertion-violationf 'two-way-port "operation ~s not handled" msg)]))) (make-input/output-port handler "" ""))) \endschemedisplay \noindent Most of the messages are passed directly to one of the constituent ports. Exceptions are \scheme{close-port}, which is handled directly by marking the port closed, \scheme{port-name}, which is also handled directly. \scheme{file-position} and \scheme{file-length} are rather arbitrarily passed off to the input port. \parheader{Transcript ports} \index{transcript ports}The next example defines \scheme{make-transcript-port}, which constructs a textual input/output port from three ports: a textual input port \var{ip} and two textual output ports, \var{op} and \var{tp}. Input read from a transcript port comes from \var{ip}, and output written to a transcript port goes to \var{op}. In this manner, transcript ports are similar to two-way ports. Unlike two-way ports, input from \var{ip} and output to \var{op} is also written to \var{tp}, so that \var{tp} reflects both input from \var{ip} and output to \var{op}. Transcript ports may be used to define the Scheme procedures \scheme{transcript-on} and \scheme{transcript-off}, or the {\ChezScheme} procedure \scheme{transcript-cafe}. For example, here is a definition of \scheme{transcript-cafe}: \schemedisplay (define transcript-cafe (lambda (pathname) (let ([tp (open-output-file pathname 'replace)]) (let ([p (make-transcript-port (console-input-port) (console-output-port) tp)]) ; set both console and current ports so that ; the waiter and read/write will be in sync (parameterize ([console-input-port p] [console-output-port p] [current-input-port p] [current-output-port p]) (let-values ([vals (new-cafe)]) (close-port p) (close-port tp) (apply values vals))))))) \endschemedisplay The implementation of transcript ports is significantly more complex than the implementation of two-way ports defined above, primarily because it buffers input and output locally. Local buffering is needed to allow the transcript file to reflect accurately the actual input and output performed in the presence of \scheme{unread-char}, \scheme{clear-output-port}, and \scheme{clear-input-port}. Here is the code: % exercise: Try rewriting make-transcript-port without local buffering. % Why does this not work satisfactorily? \schemedisplay (define make-transcript-port (lambda (ip op tp) (define (handler msg . args) (record-case (cons msg args) [block-read (p str cnt) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (if (< i s) (let ([cnt (fxmin cnt (fx- s i))]) (do ([i i (fx+ i 1)] [j 0 (fx+ j 1)]) ((fx= j cnt) (set-port-input-index! p i) cnt) (string-set! str j (string-ref b i)))) (let ([cnt (block-read ip str cnt)]) (unless (eof-object? cnt) (block-write tp str cnt)) cnt))))] [char-ready? (p) (or (< (port-input-index p) (port-input-size p)) (char-ready? ip))] [clear-input-port (p) ; set size to zero rather than index to size ; in order to invalidate unread-char (set-port-input-size! p 0)] [clear-output-port (p) (set-port-output-index! p 0)] [close-port (p) (with-interrupts-disabled (flush-output-port p) (set-port-output-size! p 0) (set-port-input-size! p 0) (mark-port-closed! p))] [file-position (p . pos) (if (null? pos) (most-negative-fixnum) (assertion-violationf 'transcript-port "cannot reposition"))] [flush-output-port (p) (with-interrupts-disabled (let ([b (port-output-buffer p)] [i (port-output-index p)]) (unless (fx= i 0) (block-write op b i) (block-write tp b i) (set-port-output-index! p 0) (set-port-bol! p (char=? (string-ref b (fx- i 1)) #\newline)))) (flush-output-port op) (flush-output-port tp))] [peek-char (p) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (if (fx< i s) (string-ref b i) (begin (flush-output-port p) (let ([s (block-read ip b)]) (if (eof-object? s) s (begin (block-write tp b s) (set-port-input-size! p s) (string-ref b 0))))))))] [port-name (p) "transcript"] [constituent-ports (p) (values ip op tp)] [read-char (p) (with-interrupts-disabled (let ([c (peek-char p)]) (unless (eof-object? c) (set-port-input-index! p (fx+ (port-input-index p) 1))) c))] [unread-char (c p) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (when (fx= i 0) (assertion-violationf 'unread-char "tried to unread too far on ~s" p)) (set-port-input-index! p (fx- i 1)) ; following could be skipped; it's supposed ; to be the same character anyway (string-set! b (fx- i 1) c)))] [write-char (c p) (with-interrupts-disabled (let ([b (port-output-buffer p)] [i (port-output-index p)] [s (port-output-size p)]) (string-set! b i c) ; could check here to be sure that we really ; need to flush; we may end up here even if ; the buffer isn't full (block-write op b (fx+ i 1)) (block-write tp b (fx+ i 1)) (set-port-output-index! p 0) (set-port-bol! p (char=? c #\newline))))] [block-write (p str cnt) (with-interrupts-disabled ; flush buffered data (let ([b (port-output-buffer p)] [i (port-output-index p)]) (unless (fx= i 0) (block-write op b i) (block-write tp b i) (set-port-output-index! p 0) (set-port-bol! p (char=? (string-ref b (fx- i 1)) #\newline)))) ; write new data (unless (fx= cnt 0) (block-write op str cnt) (block-write tp str cnt) (set-port-bol! p (char=? (string-ref str (fx- cnt 1)) #\newline))))] [else (assertion-violationf 'transcript-port "operation ~s not handled" msg)])) (let ([ib (make-string 1024)] [ob (make-string 1024)]) (let ([p (make-input/output-port handler ib ob)]) (set-port-input-size! p 0) (set-port-output-size! p (fx- (string-length ob) 1)) p)))) \endschemedisplay \noindent The chosen length of both the input and output ports is the same; this is not necessary. They could have different lengths, or one could be buffered locally and the other not buffered locally. Local buffering could be disabled effectively by providing zero-length buffers. After we create the port, the input size is set to zero since there is not yet any data to be read. The port output size is set to one less than the length of the buffer. This is done so that \scheme{write-char} always has one character position left over into which to write its character argument. Although this is not necessary, it does simplify the code somewhat while allowing the buffer to be flushed as soon as the last character is available. Block reads and writes are performed on the constituent ports for efficiency and (in the case of writes) to ensure that the operations are performed immediately. The call to \scheme{flush-output-port} in the handling of \scheme{read-char} insures that all output written to \scheme{op} appears before input is read from \scheme{ip}. Since \scheme{block-read} is typically used to support higher-level operations that are performing their own buffering, or for direct input and output in support of I/O-intensive applications, the flush call has been omitted from that part of the handler. Critical sections are used whenever the handler manipulates one of the buffers, to protect against untimely interrupts that could lead to reentry into the handler. The critical sections are unnecessary if no such reentry is possible, i.e., if only one ``thread'' of the computation can have access to the port. \parheader{Process ports} \index{process ports}\index{sockets}The final example demonstrates how to incorporate the socket interface defined in Section~\ref{SECTFOREIGNSOCKETS} into a generic port that allows transparent communication with subprocesses via normal Scheme input/output operations. A process port is created with \scheme{open-process}, which accepts a shell command as a string. \scheme{open-process} sets up a socket, forks a child process, sets up two-way communication via the socket, and invokes the command in a subprocess. The sample session below demonstrates the use of \scheme{open-process}, running and communicating with another Scheme process started with the ``\scheme{-q}'' switch to suppress the greeting and prompts. \schemedisplay > (define p (open-process "exec scheme -q")) > (define s (make-string 1000 #\nul)) > (pretty-print '(+ 3 4) p) > (read p) 7 > (pretty-print '(define (f x) (if (= x 0) 1 (* x (f (- x 1))))) p) > (pretty-print '(f 10) p) > (read p) 3628800 > (pretty-print '(exit) p) > (read p) #!eof > (close-port p) \endschemedisplay \noindent Since process ports, like transcript ports, are two-way, the implementation is somewhat similar. The main difference is that a transcript port reads from and writes to its subordinate ports, whereas a process port reads from and writes to a socket. When a process port is opened, the socket is created and subprocess invoked, and when the port is closed, the socket is closed and the subprocess is terminated. \schemedisplay (define open-process (lambda (command) (define handler (lambda (pid socket) (define (flush-output who p) (let ([i (port-output-index p)]) (when (fx> i 0) (check who (c-write socket (port-output-buffer p) i)) (set-port-output-index! p 0)))) (lambda (msg . args) (record-case (cons msg args) [block-read (p str cnt) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (if (< i s) (let ([cnt (fxmin cnt (fx- s i))]) (do ([i i (fx+ i 1)] [j 0 (fx+ j 1)]) ((fx= j cnt) (set-port-input-index! p i) cnt) (string-set! str j (string-ref b i)))) (begin (flush-output 'block-read p) (let ([n (check 'block-read (c-read socket str cnt))]) (if (fx= n 0) #!eof n))))))] [char-ready? (p) (or (< (port-input-index p) (port-input-size p)) (bytes-ready? socket))] [clear-input-port (p) ; set size to zero rather than index to size ; in order to invalidate unread-char (set-port-input-size! p 0)] [clear-output-port (p) (set-port-output-index! p 0)] [close-port (p) (with-interrupts-disabled (flush-output 'close-port p) (set-port-output-size! p 0) (set-port-input-size! p 0) (mark-port-closed! p) (terminate-process pid))] [file-length (p) 0] [file-position (p . pos) (if (null? pos) (most-negative-fixnum) (assertion-violationf 'process-port "cannot reposition"))] [flush-output-port (p) (with-interrupts-disabled (flush-output 'flush-output-port p))] [peek-char (p) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (if (fx< i s) (string-ref b i) (begin (flush-output 'peek-char p) (let ([s (check 'peek-char (c-read socket b (string-length b)))]) (if (fx= s 0) #!eof (begin (set-port-input-size! p s) (string-ref b 0))))))))] [port-name (p) "process"] [read-char (p) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (if (fx< i s) (begin (set-port-input-index! p (fx+ i 1)) (string-ref b i)) (begin (flush-output 'peek-char p) (let ([s (check 'read-char (c-read socket b (string-length b)))]) (if (fx= s 0) #!eof (begin (set-port-input-size! p s) (set-port-input-index! p 1) (string-ref b 0))))))))] [unread-char (c p) (with-interrupts-disabled (let ([b (port-input-buffer p)] [i (port-input-index p)] [s (port-input-size p)]) (when (fx= i 0) (assertion-violationf 'unread-char "tried to unread too far on ~s" p)) (set-port-input-index! p (fx- i 1)) ; following could be skipped; supposed to be ; same character (string-set! b (fx- i 1) c)))] [write-char (c p) (with-interrupts-disabled (let ([b (port-output-buffer p)] [i (port-output-index p)] [s (port-output-size p)]) (string-set! b i c) (check 'write-char (c-write socket b (fx+ i 1))) (set-port-output-index! p 0)))] [block-write (p str cnt) (with-interrupts-disabled ; flush buffered data (flush-output 'block-write p) ; write new data (check 'block-write (c-write socket str cnt)))] [else (assertion-violationf 'process-port "operation ~s not handled" msg)])))) (let* ([server-socket-name (tmpnam 0)] [server-socket (setup-server-socket server-socket-name)]) (dofork (lambda () ; child (check 'close (close server-socket)) (let ([sock (setup-client-socket server-socket-name)]) (dodup 0 sock) (dodup 1 sock)) (check 'execl (execl4 "/bin/sh" "/bin/sh" "-c" command)) (assertion-violationf 'open-process "subprocess exec failed")) (lambda (pid) ; parent (let ([sock (accept-socket server-socket)]) (check 'close (close server-socket)) (let ([ib (make-string 1024)] [ob (make-string 1024)]) (let ([p (make-input/output-port (handler pid sock) ib ob)]) (set-port-input-size! p 0) (set-port-output-size! p (fx- (string-length ob) 1)) p)))))))) \endschemedisplay