The flexi-streams Reference Manual

3.1.1 flexi-streams/flexi-streams.asd

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

ASDF Systems

flexi-streams.

Packages

flexi-streams-system.

---

3.1.2 flexi-streams/packages.lisp

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Packages

flexi-streams.

---

3.1.3 flexi-streams/mapping.lisp

Dependency

packages.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

octet (type).

Internals

• char* (type).
• char-code-integer (type).
• code-point (type).
• defconstant (macro).
• invert-table (function).
• make-decoding-table (function).
• string* (type).

---

3.1.4 flexi-streams/ascii.lisp

Dependency

mapping.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

+ascii-table+ (constant).

---

3.1.5 flexi-streams/koi8-r.lisp

Dependency

ascii.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

+koi8-r-table+ (constant).

---

3.1.6 flexi-streams/mac.lisp

Dependency

koi8-r.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

+mac-roman-table+ (constant).

---

3.1.7 flexi-streams/iso-8859.lisp

Dependency

mac.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

+iso-8859-tables+ (constant).

---

3.1.8 flexi-streams/enc-cn-tbl.lisp

Dependency

iso-8859.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

• *gbk-to-ucs-special-table* (special variable).
• *gbk-to-ucs-table* (special variable).
• *ucs-to-gbk-special-table* (special variable).
• *ucs-to-gbk-table* (special variable).
• define-multibyte-mapper (macro).
• make-multibyte-mapper (function).

---

3.1.9 flexi-streams/code-pages.lisp

Dependency

enc-cn-tbl.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

+code-page-tables+ (constant).

---

3.1.10 flexi-streams/specials.lisp

Dependency

code-pages.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• *default-eol-style* (special variable).
• *default-little-endian* (special variable).
• *substitution-char* (special variable).

Internals

• *current-unreader* (special variable).
• *fixnum-optimize-settings* (special variable).
• *hyperdoc-base-uri* (special variable).
• *standard-optimize-settings* (special variable).
• +ascii-hash+ (constant).
• +buffer-size+ (constant).
• +code-page-hashes+ (constant).
• +cr+ (constant).
• +iso-8859-hashes+ (constant).
• +koi8-r-hash+ (constant).
• +lf+ (constant).
• +mac-roman-hash+ (constant).
• +name-map+ (special variable).
• +shortcut-map+ (special variable).
• hyperdoc-lookup (function).

---

3.1.11 flexi-streams/util.lisp

Dependency

specials.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

• ascii-name-p (function).
• ash* (macro).
• code-page-name-p (function).
• get-multibyte-mapper (function).
• iso-8859-name-p (function).
• known-code-page-id-p (function).
• koi8-r-name-p (function).
• logand* (macro).
• logior* (macro).
• mac-roman-name-p (function).
• make-octet-buffer (function).
• maybe-rewind (function).
• normalize-external-format-name (function).
• sans (function).
• type-equal (function).
• when-let (macro).
• with-rebinding (macro).
• with-unique-names (macro).

---

3.1.12 flexi-streams/conditions.lisp

Dependency

util.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• external-format-condition (condition).
• external-format-condition-external-format (reader method).
• external-format-encoding-error (condition).
• external-format-error (condition).
• flexi-stream-element-type-error (condition).
• flexi-stream-element-type-error-element-type (reader method).
• flexi-stream-error (condition).
• flexi-stream-out-of-sync-error (condition).
• in-memory-stream-closed-error (condition).
• in-memory-stream-error (condition).
• in-memory-stream-position-spec-error (condition).
• in-memory-stream-position-spec-error-position-spec (reader method).

Internals

• flexi-stream-simple-error (condition).
• in-memory-stream-simple-error (condition).
• signal-encoding-error (function).

---

3.1.13 flexi-streams/external-format.lisp

Dependency

conditions.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• external-format-eol-style (reader method).
• external-format-equal (function).
• external-format-id (reader method).
• external-format-little-endian (reader method).
• external-format-name (reader method).
• initialize-instance (method).
• make-external-format (function).
• make-load-form (method).
• print-object (method).

Internals

• external-format (class).
• external-format-class-name (function).
• external-format-decoding-table (reader method).
• (setf external-format-decoding-table) (writer method).
• external-format-encoding-hash (reader method).
• (setf external-format-encoding-hash) (writer method).
• flexi-8-bit-format (class).
• flexi-ascii-format (class).
• flexi-cr-8-bit-format (class).
• flexi-cr-ascii-format (class).
• flexi-cr-gbk-format (class).
• flexi-cr-latin-1-format (class).
• flexi-cr-mixin (class).
• flexi-cr-utf-16-be-format (class).
• flexi-cr-utf-16-le-format (class).
• flexi-cr-utf-32-be-format (class).
• flexi-cr-utf-32-le-format (class).
• flexi-cr-utf-8-format (class).
• flexi-crlf-8-bit-format (class).
• flexi-crlf-ascii-format (class).
• flexi-crlf-gbk-format (class).
• flexi-crlf-latin-1-format (class).
• flexi-crlf-mixin (class).
• flexi-crlf-utf-16-be-format (class).
• flexi-crlf-utf-16-le-format (class).
• flexi-crlf-utf-32-be-format (class).
• flexi-crlf-utf-32-le-format (class).
• flexi-crlf-utf-8-format (class).
• flexi-gbk-format (class).
• flexi-latin-1-format (class).
• flexi-utf-16-be-format (class).
• flexi-utf-16-format (class).
• flexi-utf-16-le-format (class).
• flexi-utf-32-be-format (class).
• flexi-utf-32-format (class).
• flexi-utf-32-le-format (class).
• flexi-utf-8-format (class).
• make-external-format% (function).
• maybe-convert-external-format (function).
• normalize-external-format (function).

---

3.1.14 flexi-streams/length.lisp

Dependency

external-format.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

• character-length (generic function).
• check-end (generic function).
• compute-number-of-chars (generic function).
• compute-number-of-octets (generic function).
• encoding-factor (generic function).

---

3.1.15 flexi-streams/encode.lisp

Dependency

length.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

• char-to-octets (generic function).
• define-char-encoders (macro).
• define-sequence-writers (macro).
• string-to-octets* (generic function).
• write-sequence* (generic function).

---

3.1.16 flexi-streams/decode.lisp

Dependency

encode.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

• define-char-decoders (macro).
• define-sequence-readers (macro).
• octets-to-char-code (generic function).
• octets-to-string* (generic function).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• read-sequence* (method).
• recover-from-encoding-error (function).

---

3.1.17 flexi-streams/in-memory.lisp

Dependency

decode.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• get-output-stream-sequence (method).
• in-memory-input-stream (class).
• in-memory-output-stream (class).
• in-memory-stream (class).
• list-stream (class).
• make-in-memory-input-stream (method).
• make-in-memory-input-stream (method).
• make-in-memory-output-stream (function).
• output-stream-sequence-length (method).
• peek-byte (generic function).
• stream-element-type (method).
• (setf stream-file-position) (method).
• stream-file-position (method).
• (setf stream-file-position) (method).
• stream-file-position (method).
• stream-listen (method).
• stream-listen (method).
• stream-read-byte (method).
• stream-read-byte (method).
• stream-read-sequence (method).
• stream-read-sequence (method).
• stream-write-byte (method).
• stream-write-sequence (method).
• vector-stream (class).
• with-input-from-sequence (macro).
• with-output-to-sequence (macro).

Internals

• check-if-open (method).
• in-memory-stream-transformer (reader method).
• (setf in-memory-stream-transformer) (writer method).
• list-input-stream (class).
• list-stream-list (reader method).
• (setf list-stream-list) (writer method).
• make-output-vector (function).
• transform-octet (method).
• vector-input-stream (class).
• vector-output-stream (class).
• vector-stream-end (reader method).
• (setf vector-stream-end) (writer method).
• vector-stream-index (reader method).
• (setf vector-stream-index) (writer method).
• vector-stream-vector (reader method).
• (setf vector-stream-vector) (writer method).

---

3.1.18 flexi-streams/stream.lisp

Dependency

in-memory.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• close (method).
• flexi-input-stream (class).
• flexi-io-stream (class).
• flexi-output-stream (class).
• flexi-stream (class).
• flexi-stream-bound (reader method).
• (setf flexi-stream-bound) (writer method).
• flexi-stream-column (reader method).
• (setf flexi-stream-column) (writer method).
• flexi-stream-element-type (reader method).
• (setf flexi-stream-element-type) (writer method).
• (setf flexi-stream-element-type) (method).
• flexi-stream-external-format (reader method).
• (setf flexi-stream-external-format) (writer method).
• (setf flexi-stream-external-format) (method).
• flexi-stream-position (reader method).
• (setf flexi-stream-position) (writer method).
• flexi-stream-stream (reader method).
• initialize-instance (method).
• make-flexi-stream (function).
• open-stream-p (method).
• stream-element-type (method).
• (setf stream-file-position) (method).
• stream-file-position (method).

Internals

• flexi-stream-last-char-code (reader method).
• (setf flexi-stream-last-char-code) (writer method).
• flexi-stream-last-octet (reader method).
• (setf flexi-stream-last-octet) (writer method).
• flexi-stream-octet-stack (reader method).
• (setf flexi-stream-octet-stack) (writer method).

---

3.1.19 flexi-streams/output.lisp

Dependency

stream.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• stream-clear-output (method).
• stream-finish-output (method).
• stream-force-output (method).
• stream-line-column (method).
• stream-write-byte (method).
• stream-write-char (method).
• stream-write-char (method).
• stream-write-sequence (method).
• stream-write-string (method).

Internals

write-byte* (generic function).

---

3.1.20 flexi-streams/input.lisp

Dependency

output.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• peek-byte (method).
• stream-clear-input (method).
• stream-listen (method).
• stream-read-byte (method).
• stream-read-char (method).
• stream-read-char-no-hang (method).
• stream-read-sequence (method).
• stream-unread-char (method).
• unread-byte (method).

Internals

• read-byte* (method).
• unread-char% (function).

---

3.1.21 flexi-streams/io.lisp

Dependency

input.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• stream-clear-input (method).
• stream-clear-output (method).
• stream-read-byte (method).
• stream-read-char (method).
• stream-read-sequence (method).
• stream-unread-char (method).
• stream-write-byte (method).
• stream-write-char (method).
• stream-write-sequence (method).
• unread-byte (method).

Internals

• reset-input-state (method).
• reset-output-state (method).
• write-byte* (method).

---

3.1.22 flexi-streams/strings.lisp

Dependency

io.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

• char-length (function).
• octet-length (function).
• octets-to-string (function).
• string-to-octets (function).

---

5.1.1 Special variables

Special Variable: *default-eol-style* ¶

The end-of-line style used by external formats if none is explicitly given. Depends on the OS the code is compiled on.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *default-little-endian* ¶

Whether external formats are little-endian by default (i.e. unless explicitly specified). Depends on the platform the code is compiled on.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *substitution-char* ¶

If this value is not NIL, it should be a character which is used (as if by a USE-VALUE restart) whenever during reading an error of type FLEXI-STREAM-ENCODING-ERROR would have been signalled otherwise.

Package

flexi-streams.

Source

specials.lisp.

---

5.1.2 Macros

Macro: with-input-from-sequence ((var sequence &key start end transformer) &body body) ¶

Creates an IN-MEMORY input stream from SEQUENCE using the parameters START and END, binds VAR to this stream and then executes the code in BODY. A function TRANSFORMER may optionally be specified to transform the returned octets. The stream is automatically closed on exit from WITH-INPUT-FROM-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is the return value of BODY.

Package

flexi-streams.

Source

in-memory.lisp.

Macro: with-output-to-sequence ((var &key as-list element-type transformer) &body body) ¶

Creates an IN-MEMORY output stream, binds VAR to this stream and then executes the code in BODY. The stream stores data of type ELEMENT-TYPE (a subtype of OCTET) which is (optionally) transformed by the function TRANSFORMER prior to storage. The stream is automatically closed on exit from WITH-OUTPUT-TO-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is a vector (or a list if AS-LIST is true) containing the octets that were sent to the stream within BODY.

Package

flexi-streams.

Source

in-memory.lisp.

---

5.1.3 Ordinary functions

Function: char-length (sequence &key external-format start end) ¶

Kind of the inverse of OCTET-LENGTH. Returns the length of the subsequence (of octets) of SEQUENCE from START to END in characters if decoded using the external format EXTERNAL-FORMAT. Note that this function doesn’t check for the validity of the data in SEQUENCE.

This function is optimized for the case of SEQUENCE being a vector. Don’t use lists if you’re in a hurry.

Package

flexi-streams.

Source

strings.lisp.

Function: external-format-equal (ef1 ef2) ¶

Checks whether two EXTERNAL-FORMAT objects denote the same encoding.

Package

flexi-streams.

Source

external-format.lisp.

Function: make-external-format (name &rest args &key little-endian id eol-style) ¶

Creates and returns an external format object as specified. NAME is a keyword like :LATIN1 or :UTF-8, LITTLE-ENDIAN specifies the ‘endianess’ of the external format and is ignored for 8-bit encodings, EOL-STYLE is one of the keywords :CR, :LF, or :CRLF which denote the end-of-line character (sequence), ID is the ID of a Windows code page (and ignored for other encodings).

Package

flexi-streams.

Source

external-format.lisp.

Function: make-flexi-stream (stream &rest args &key external-format element-type column position bound) ¶

Creates and returns a new flexi stream. STREAM must be an open binary or ‘bivalent’ stream, i.e. it must be capable of reading/writing octets with READ-SEQUENCE and/or WRITE-SEQUENCE. The resulting flexi stream is an input stream if and only if STREAM is an input stream. Likewise, it’s an output stream if and only if STREAM is an output stream. The default for ELEMENT-TYPE is LW:SIMPLE-CHAR on LispWorks and CHARACTER on other Lisps. EXTERNAL-FORMAT must be an EXTERNAL-FORMAT object or a symbol or a list denoting such an object. COLUMN is the initial column of the stream which is either a non-negative integer or NIL. The COLUMN argument must only be used for output streams. POSITION (only used for input streams) should be an integer and it denotes the position the stream is in - it will be increased by one for each octet read. BOUND (only used for input streams) should be NIL or an integer. If BOUND is not NIL and POSITION has gone beyond BOUND, then the stream will behave as if no more input is available.

Package

flexi-streams.

Source

stream.lisp.

Function: make-in-memory-output-stream (&key element-type transformer) ¶

Returns a binary output stream which accepts objects of type ELEMENT-TYPE (a subtype of OCTET) and makes available a sequence that contains the octes that were actually output. The octets stored will each be transformed by the optional TRANSFORMER function.

Package

flexi-streams.

Source

in-memory.lisp.

Function: octet-length (string &key external-format start end) ¶

Returns the length of the substring of STRING from START to END in octets if encoded using the external format EXTERNAL-FORMAT.

In spite of the name, STRING can be any sequence of characters, but the function is optimized for strings.

Package

flexi-streams.

Source

strings.lisp.

Function: octets-to-string (sequence &key external-format start end) ¶

Converts the Lisp sequence SEQUENCE of octets from START to END to a string using the external format designated by EXTERNAL-FORMAT.

This function is optimized for the case of SEQUENCE being a vector. Don’t use lists if you’re in a hurry.

Package

flexi-streams.

Source

strings.lisp.

Function: string-to-octets (string &key external-format start end) ¶

Converts the Lisp string STRING from START to END to an array of octets corresponding to the external format designated by EXTERNAL-FORMAT.

In spite of the name, STRING can be any sequence of characters, but the function is optimized for strings.

Package

flexi-streams.

Source

strings.lisp.

---

5.1.4 Generic functions

Generic Reader: external-format-condition-external-format (condition) ¶

Package

flexi-streams.

Methods

Reader Method: external-format-condition-external-format ((condition external-format-condition)) ¶

Source

conditions.lisp.

Target Slot

external-format.

Generic Reader: external-format-eol-style (object) ¶

Package

flexi-streams.

Methods

Reader Method: external-format-eol-style ((external-format external-format)) ¶

The character(s) to or from which
a #Newline will be translated - one of the keywords :CR, :LF, or :CRLF.

Source

external-format.lisp.

Target Slot

eol-style.

Generic Reader: external-format-id (object) ¶

Package

flexi-streams.

Methods

Reader Method: external-format-id ((external-format external-format)) ¶

If the external format denotes a Windows
code page this ID specifies which one to use. Otherwise the value is ignored (and usually NIL).

Source

external-format.lisp.

Target Slot

id.

Generic Reader: external-format-little-endian (object) ¶

Package

flexi-streams.

Methods

Reader Method: external-format-little-endian ((external-format external-format)) ¶

Whether multi-octet values are
read and written with the least significant octet first. For 8-bit encodings like :ISO-8859-1 this value is ignored.

Source

external-format.lisp.

Target Slot

little-endian.

Generic Reader: external-format-name (object) ¶

Package

flexi-streams.

Methods

Reader Method: external-format-name ((external-format external-format)) ¶

The name of the external format - a keyword.

Source

external-format.lisp.

Target Slot

name.

Generic Reader: flexi-stream-bound (object) ¶

Generic Writer: (setf flexi-stream-bound) (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-bound ((flexi-input-stream flexi-input-stream)) ¶

Writer Method: (setf flexi-stream-bound) ((flexi-input-stream flexi-input-stream)) ¶

When this is not NIL, it must be an integer
and the stream will behave as if no more data is available as soon as POSITION is greater or equal than this value.

Source

stream.lisp.

Target Slot

bound.

Generic Reader: flexi-stream-column (object) ¶

Generic Writer: (setf flexi-stream-column) (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-column ((flexi-output-stream flexi-output-stream)) ¶

Writer Method: (setf flexi-stream-column) ((flexi-output-stream flexi-output-stream)) ¶

The current output column. A non-negative integer or NIL.

Source

stream.lisp.

Target Slot

column.

Generic Reader: flexi-stream-element-type (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-element-type ((flexi-stream flexi-stream)) ¶

The element type of this stream.

Source

stream.lisp.

Target Slot

element-type.

Generic Function: (setf flexi-stream-element-type) (object) ¶

Package

flexi-streams.

Methods

Writer Method: (setf flexi-stream-element-type) :before ((flexi-stream flexi-stream)) ¶

Checks whether the new value makes sense before it is set.

Source

stream.lisp.

Target Slot

element-type.

Method: (setf flexi-stream-element-type) ((flexi-stream flexi-stream)) ¶

The element type of this stream.

Source

stream.lisp.

Generic Reader: flexi-stream-element-type-error-element-type (condition) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-element-type-error-element-type ((condition flexi-stream-element-type-error)) ¶

Source

conditions.lisp.

Target Slot

element-type.

Generic Reader: flexi-stream-external-format (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-external-format ((flexi-stream flexi-stream)) ¶

The encoding currently used
by this stream. Can be changed on the fly.

Source

stream.lisp.

Target Slot

external-format.

Generic Function: (setf flexi-stream-external-format) (object) ¶

Package

flexi-streams.

Methods

Writer Method: (setf flexi-stream-external-format) :around ((flexi-stream flexi-stream)) ¶

Converts the new value to an EXTERNAL-FORMAT object if necessary.

Source

stream.lisp.

Target Slot

external-format.

Method: (setf flexi-stream-external-format) ((flexi-stream flexi-stream)) ¶

The encoding currently used
by this stream. Can be changed on the fly.

Source

stream.lisp.

Generic Reader: flexi-stream-position (object) ¶

Generic Writer: (setf flexi-stream-position) (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-position ((flexi-input-stream flexi-input-stream)) ¶

Writer Method: (setf flexi-stream-position) ((flexi-input-stream flexi-input-stream)) ¶

The position within the stream where each octet read counts as one.

Source

stream.lisp.

Target Slot

position.

Generic Reader: flexi-stream-stream (object) ¶

Package

flexi-streams.

Methods

Reader Method: flexi-stream-stream ((flexi-stream flexi-stream)) ¶

The actual stream that’s used for
input and/or output. It must be capable of reading/writing octets with READ-SEQUENCE and/or WRITE-SEQUENCE.

Source

stream.lisp.

Target Slot

stream.

Generic Function: get-output-stream-sequence (stream &key as-list) ¶

Package

flexi-streams.

Methods

Method: get-output-stream-sequence ((stream in-memory-output-stream) &key as-list) ¶

Returns a vector containing, in order, all the octets that have been output to the IN-MEMORY stream STREAM. This operation clears any octets on STREAM, so the vector contains only those octets which have been output since the last call to GET-OUTPUT-STREAM-SEQUENCE or since the creation of the stream, whichever occurred most recently. If AS-LIST is true the return value is coerced to a list.

Source

in-memory.lisp.

Generic Reader: in-memory-stream-position-spec-error-position-spec (condition) ¶

Package

flexi-streams.

Methods

Reader Method: in-memory-stream-position-spec-error-position-spec ((condition in-memory-stream-position-spec-error)) ¶

Source

conditions.lisp.

Target Slot

position-spec.

Generic Function: make-in-memory-input-stream (vector &key start end transformer) ¶

Package

flexi-streams.

Methods

Method: make-in-memory-input-stream ((list list) &key start end transformer) ¶

Returns a binary input stream which will supply, in order, the octets in the subsequence of LIST bounded by START and END. Each octet returned will be transformed in turn by the optional TRANSFORMER function.

Source

in-memory.lisp.

Method: make-in-memory-input-stream ((vector vector) &key start end transformer) ¶

Returns a binary input stream which will supply, in order, the octets in the subsequence of VECTOR bounded by START and END. Each octet returned will be transformed in turn by the optional TRANSFORMER function.

Source

in-memory.lisp.

Generic Function: output-stream-sequence-length (stream) ¶

Package

flexi-streams.

Methods

Method: output-stream-sequence-length ((stream in-memory-output-stream)) ¶

Returns the current length of the underlying vector of the IN-MEMORY output stream STREAM.

Source

in-memory.lisp.

Generic Function: peek-byte (stream &optional peek-type eof-err-p eof-value) ¶

PEEK-BYTE is like PEEK-CHAR, i.e. it returns a byte from the stream without actually removing it. If PEEK-TYPE is NIL the next byte is returned, if PEEK-TYPE is T, the next byte which is not 0 is returned, if PEEK-TYPE is an byte, the next byte which equals PEEK-TYPE is returned. EOF-ERROR-P and EOF-VALUE are interpreted as usual.

Package

flexi-streams.

Source

in-memory.lisp.

Methods

Method: peek-byte ((flexi-input-stream flexi-input-stream) &optional peek-type eof-error-p eof-value) ¶

Returns an octet from FLEXI-INPUT-STREAM without actually removing it.

Source

input.lisp.

Method: peek-byte ((stream list-input-stream) &optional peek-type eof-error-p eof-value) ¶

Returns a byte from VECTOR-INPUT-STREAM without actually removing it.

Method: peek-byte ((stream vector-input-stream) &optional peek-type eof-error-p eof-value) ¶

Returns a byte from VECTOR-INPUT-STREAM without actually removing it.

Generic Function: unread-byte (byte flexi-input-stream) ¶

Package

flexi-streams.

Methods

Method: unread-byte :before (byte (stream flexi-io-stream)) ¶

Source

io.lisp.

Method: unread-byte (byte (flexi-input-stream flexi-input-stream)) ¶

Similar to UNREAD-CHAR in that it ‘unreads’ the last octet from STREAM. Note that you can only call UNREAD-BYTE after a corresponding READ-BYTE.

Source

input.lisp.

---

5.1.5 Standalone methods

Method: close ((stream flexi-stream) &key abort) ¶

Closes the flexi stream by closing the underlying ‘real’ stream.

Source

stream.lisp.

Method: initialize-instance :after ((flexi-stream flexi-stream) &rest initargs) ¶

Makes sure the EXTERNAL-FORMAT and ELEMENT-TYPE slots contain reasonable values.

Source

stream.lisp.

Method: initialize-instance :after ((external-format flexi-8-bit-format) &rest initargs) ¶

Sets the fixed encoding/decoding tables for this particular external format.

Source

external-format.lisp.

Method: make-load-form ((thing external-format) &optional environment) ¶

Defines a way to reconstruct external formats. Needed for OpenMCL.

Source

external-format.lisp.

Method: open-stream-p ((stream flexi-stream)) ¶

A flexi stream is open if its underlying stream is open.

Source

stream.lisp.

Method: print-object ((object external-format) stream) ¶

How an EXTERNAL-FORMAT object is rendered. Uses NORMALIZE-EXTERNAL-FORMAT.

Source

external-format.lisp.

Method: stream-clear-input :before ((stream flexi-io-stream)) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-clear-input ((flexi-input-stream flexi-input-stream)) ¶

Calls the corresponding method for the underlying input stream and also clears the value of the OCTET-STACK slot.

Package

sb-gray.

Source

input.lisp.

Method: stream-clear-output :before ((stream flexi-io-stream)) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-clear-output ((flexi-output-stream flexi-output-stream)) ¶

Simply calls the corresponding method for the underlying output stream.

Package

sb-gray.

Source

output.lisp.

Method: stream-element-type ((stream in-memory-stream)) ¶

The element type is always OCTET by definition.

Source

in-memory.lisp.

Method: stream-element-type ((stream flexi-stream)) ¶

Returns the element type that was provided by the creator of the stream.

Source

stream.lisp.

Method: (setf stream-file-position) ((stream flexi-stream)) ¶

Dispatch to method for underlying stream.

Package

trivial-gray-streams.

Source

stream.lisp.

Method: stream-file-position ((stream flexi-stream)) ¶

Dispatch to method for underlying stream.

Package

trivial-gray-streams.

Source

stream.lisp.

Method: (setf stream-file-position) ((stream vector-input-stream)) ¶

Sets the index into the underlying vector if POSITION-SPEC is acceptable.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-file-position ((stream vector-input-stream)) ¶

Simply returns the index into the underlying vector.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: (setf stream-file-position) ((stream vector-output-stream)) ¶

Sets the fill pointer underlying vector if POSITION-SPEC is acceptable. Adjusts the vector if necessary.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-file-position ((stream vector-output-stream)) ¶

Simply returns the fill pointer of the underlying vector.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-finish-output ((flexi-output-stream flexi-output-stream)) ¶

Simply calls the corresponding method for the underlying output stream.

Package

sb-gray.

Source

output.lisp.

Method: stream-force-output ((flexi-output-stream flexi-output-stream)) ¶

Simply calls the corresponding method for the underlying output stream.

Package

sb-gray.

Source

output.lisp.

Method: stream-line-column ((flexi-output-stream flexi-output-stream)) ¶

Returns the column stored in the COLUMN slot of the FLEXI-OUTPUT-STREAM object STREAM.

Package

sb-gray.

Source

output.lisp.

Method: stream-listen ((flexi-input-stream flexi-input-stream)) ¶

Calls the corresponding method for the underlying input stream but first checks if (old) input is available in the OCTET-STACK slot.

Package

sb-gray.

Source

input.lisp.

Method: stream-listen ((stream vector-input-stream)) ¶

Checking whether INDEX is beyond END.

Package

sb-gray.

Source

in-memory.lisp.

Method: stream-listen ((stream list-input-stream)) ¶

Checks whether list is not empty.

Package

sb-gray.

Source

in-memory.lisp.

Method: stream-read-byte :before ((stream flexi-io-stream)) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-read-byte ((stream flexi-input-stream)) ¶

Reads one byte (octet) from the underlying stream.

Package

sb-gray.

Source

input.lisp.

Method: stream-read-byte ((stream vector-input-stream)) ¶

Reads one byte and increments INDEX pointer unless we’re beyond END pointer.

Package

sb-gray.

Source

in-memory.lisp.

Method: stream-read-byte ((stream list-input-stream)) ¶

Reads one byte by simply popping it off of the top of the list.

Package

sb-gray.

Source

in-memory.lisp.

Method: stream-read-char :before ((stream flexi-io-stream)) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-read-char ((stream flexi-input-stream)) ¶

Package

sb-gray.

Source

input.lisp.

Method: stream-read-char-no-hang ((stream flexi-input-stream)) ¶

Reads one character if the underlying stream has at least one octet available.

Package

sb-gray.

Source

input.lisp.

Method: stream-read-sequence :before ((stream flexi-io-stream) sequence start end &key) ¶

Package

trivial-gray-streams.

Source

io.lisp.

Method: stream-read-sequence ((flexi-input-stream flexi-input-stream) sequence start end &key) ¶

An optimized version which uses a buffer underneath. The function can deliver characters as well as octets and it decides what to do based on the element type of the sequence (which takes precedence) and the element type of the stream. What you’ll really get might also depend on your Lisp. Some of the implementations are more picky than others - see for example FLEXI-STREAMS-TEST::SEQUENCE-TEST.

Package

trivial-gray-streams.

Source

input.lisp.

Method: stream-read-sequence ((stream vector-input-stream) sequence start end &key) ¶

Traverses both sequences in parallel until the end of one of them is reached.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-read-sequence ((stream list-input-stream) sequence start end &key) ¶

Repeatedly pops elements from the list until it’s empty.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-unread-char :before ((stream flexi-io-stream) char) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-unread-char ((stream flexi-input-stream) char) ¶

Implements UNREAD-CHAR for streams of type FLEXI-INPUT-STREAM. Makes sure CHAR will only be unread if it was the last character read and if it was read with the same encoding that’s currently being used by the stream.

Package

sb-gray.

Source

input.lisp.

Method: stream-write-byte :before ((stream flexi-io-stream) byte) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-write-byte ((flexi-output-stream flexi-output-stream) byte) ¶

Writes a byte (octet) to the underlying stream.

Package

sb-gray.

Source

output.lisp.

Method: stream-write-byte ((stream vector-output-stream) byte) ¶

Writes a byte (octet) by extending the underlying vector.

Package

sb-gray.

Source

in-memory.lisp.

Method: stream-write-char :before ((stream flexi-io-stream) char) ¶

Package

sb-gray.

Source

io.lisp.

Method: stream-write-char :after ((stream flexi-output-stream) char) ¶

Package

sb-gray.

Source

output.lisp.

Method: stream-write-char ((stream flexi-output-stream) char) ¶

Package

sb-gray.

Source

output.lisp.

Method: stream-write-sequence :before ((stream flexi-io-stream) sequence start end &key) ¶

Package

trivial-gray-streams.

Source

io.lisp.

Method: stream-write-sequence ((flexi-output-stream flexi-output-stream) sequence start end &key) ¶

An optimized version which uses a buffer underneath. The function can accepts characters as well as octets and it decides what to do based on the element type of the sequence (if possible) or on the individual elements, i.e. you can mix characters and octets in SEQUENCE if you want. Whether that really works might also depend on your Lisp, some of the implementations are more picky than others.

Package

trivial-gray-streams.

Source

output.lisp.

Method: stream-write-sequence ((stream vector-output-stream) sequence start end &key) ¶

Just calls VECTOR-PUSH-EXTEND repeatedly.

Package

trivial-gray-streams.

Source

in-memory.lisp.

Method: stream-write-string ((stream flexi-output-stream) string &optional start end) ¶

Simply hands over to the optimized method for STREAM-WRITE-SEQUENCE.

Package

sb-gray.

Source

output.lisp.

---

5.1.6 Conditions

Condition: external-format-condition ¶

Superclass for all conditions related to external formats.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

simple-condition.

Direct subclasses

external-format-error.

Direct methods

external-format-condition-external-format.

Direct slots

Slot: external-format ¶

Initform

(quote nil)

Initargs

:external-format

Readers

external-format-condition-external-format.

Writers

This slot is read-only.

Condition: external-format-encoding-error ¶

Errors of this type are signalled if there is an encoding problem.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

external-format-error.

Condition: external-format-error ¶

Superclass for all errors related to external formats.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

• error.
• external-format-condition.

Direct subclasses

external-format-encoding-error.

Condition: flexi-stream-element-type-error ¶

Errors of this type are signalled if the flexi stream has a wrong element type.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

flexi-stream-error.

Direct methods

flexi-stream-element-type-error-element-type.

Direct slots

Slot: element-type ¶

Initargs

:element-type

Readers

flexi-stream-element-type-error-element-type.

Writers

This slot is read-only.

Condition: flexi-stream-error ¶

Superclass for all errors related to flexi streams.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

stream-error.

Direct subclasses

• flexi-stream-element-type-error.
• flexi-stream-out-of-sync-error.
• flexi-stream-simple-error.

Condition: flexi-stream-out-of-sync-error ¶

This can happen if you’re trying to write to an IO
stream which had prior to that ‘looked ahead’ while reading and now can’t ‘rewind’ to the octet where you /should/ be.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

flexi-stream-error.

Condition: in-memory-stream-closed-error ¶

An error that is signalled when someone is trying to read from or write to a closed IN-MEMORY stream.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

in-memory-stream-error.

Condition: in-memory-stream-error ¶

Superclass for all errors related to IN-MEMORY streams.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

stream-error.

Direct subclasses

• in-memory-stream-closed-error.
• in-memory-stream-simple-error.

Condition: in-memory-stream-position-spec-error ¶

Errors of this type are signalled if an erroneous position spec is used in conjunction with FILE-POSITION.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses

in-memory-stream-simple-error.

Direct methods

in-memory-stream-position-spec-error-position-spec.

Direct slots

Slot: position-spec ¶

Initargs

:position-spec

Readers

in-memory-stream-position-spec-error-position-spec.

Writers

This slot is read-only.

---

5.1.7 Classes

Class: flexi-input-stream ¶

A FLEXI-INPUT-STREAM is a FLEXI-STREAM that
can actually be instatiated and used for input. Don’t use MAKE-INSTANCE to create a new FLEXI-INPUT-STREAM but use MAKE-FLEXI-STREAM instead.

Package

flexi-streams.

Source

stream.lisp.

Direct superclasses

• flexi-stream.
• fundamental-binary-input-stream.
• fundamental-character-input-stream.

Direct subclasses

flexi-io-stream.

Direct methods

• (setf flexi-stream-bound).
• flexi-stream-bound.
• (setf flexi-stream-last-char-code).
• flexi-stream-last-char-code.
• (setf flexi-stream-last-octet).
• flexi-stream-last-octet.
• (setf flexi-stream-octet-stack).
• flexi-stream-octet-stack.
• (setf flexi-stream-position).
• flexi-stream-position.
• peek-byte.
• read-byte*.
• stream-clear-input.
• stream-listen.
• stream-read-byte.
• stream-read-char.
• stream-read-char-no-hang.
• stream-read-sequence.
• stream-unread-char.
• unread-byte.

Direct slots

Slot: last-char-code ¶

This slot either holds NIL or the
last character (code) read successfully. This is mainly used for UNREAD-CHAR sanity checks.

Readers

flexi-stream-last-char-code.

Writers

(setf flexi-stream-last-char-code).

Slot: last-octet ¶

This slot either holds NIL or the last
octet read successfully from the stream using a ‘binary’ operation such as READ-BYTE. This is mainly used for UNREAD-BYTE sanity checks.

Readers

flexi-stream-last-octet.

Writers

(setf flexi-stream-last-octet).

Slot: octet-stack ¶

A small buffer which holds octets
that were already read from the underlying stream but not yet used to produce characters. This is mainly used if we have to look ahead for a CR/LF line ending.

Readers

flexi-stream-octet-stack.

Writers

(setf flexi-stream-octet-stack).

Slot: position ¶

The position within the stream where each octet read counts as one.

Package

common-lisp.

Type

integer

Initform

0

Initargs

:position

Readers

flexi-stream-position.

Writers

(setf flexi-stream-position).

Slot: bound ¶

When this is not NIL, it must be an integer
and the stream will behave as if no more data is available as soon as POSITION is greater or equal than this value.

Type

(or null integer)

Initargs

:bound

Readers

flexi-stream-bound.

Writers

(setf flexi-stream-bound).

Class: flexi-io-stream ¶

A FLEXI-IO-STREAM is a FLEXI-STREAM that can
actually be instatiated and used for input and output. Don’t use MAKE-INSTANCE to create a new FLEXI-IO-STREAM but use MAKE-FLEXI-STREAM instead.

Package

flexi-streams.

Source

stream.lisp.

Direct superclasses

• flexi-input-stream.
• flexi-output-stream.

Direct methods

• reset-input-state.
• reset-output-state.
• stream-clear-input.
• stream-clear-output.
• stream-read-byte.
• stream-read-char.
• stream-read-sequence.
• stream-unread-char.
• stream-write-byte.
• stream-write-char.
• stream-write-sequence.
• unread-byte.
• write-byte*.

Class: flexi-output-stream ¶

A FLEXI-OUTPUT-STREAM is a FLEXI-STREAM that
can actually be instatiated and used for output. Don’t use MAKE-INSTANCE to create a new FLEXI-OUTPUT-STREAM but use MAKE-FLEXI-STREAM instead.

Package

flexi-streams.

Source

stream.lisp.

Direct superclasses

• flexi-stream.
• fundamental-binary-output-stream.
• fundamental-character-output-stream.

Direct subclasses

flexi-io-stream.

Direct methods

• (setf flexi-stream-column).
• flexi-stream-column.
• stream-clear-output.
• stream-finish-output.
• stream-force-output.
• stream-line-column.
• stream-write-byte.
• stream-write-char.
• stream-write-char.
• stream-write-sequence.
• stream-write-string.
• write-byte*.

Direct slots

Slot: column ¶

The current output column. A non-negative integer or NIL.

Initform

0

Readers

flexi-stream-column.

Writers

(setf flexi-stream-column).

Class: flexi-stream ¶

A FLEXI-STREAM object is a stream that’s
‘layered’ atop an existing binary/bivalent stream in order to allow for multi-octet external formats. FLEXI-STREAM itself is a mixin and should not be instantiated.

Package

flexi-streams.

Source

stream.lisp.

Direct superclasses

trivial-gray-stream-mixin.

Direct subclasses

• flexi-input-stream.
• flexi-output-stream.

Direct methods

• close.
• (setf flexi-stream-element-type).
• (setf flexi-stream-element-type).
• flexi-stream-element-type.
• (setf flexi-stream-external-format).
• (setf flexi-stream-external-format).
• flexi-stream-external-format.
• flexi-stream-stream.
• initialize-instance.
• open-stream-p.
• stream-element-type.
• (setf stream-file-position).
• stream-file-position.

Direct slots

Slot: stream ¶

The actual stream that’s used for
input and/or output. It must be capable of reading/writing octets with READ-SEQUENCE and/or WRITE-SEQUENCE.

Package

common-lisp.

Initargs

:stream

Readers

flexi-stream-stream.

Writers

This slot is read-only.

Slot: external-format ¶

The encoding currently used
by this stream. Can be changed on the fly.

Initform

(flexi-streams:make-external-format :iso-8859-1)

Initargs

:flexi-stream-external-format

Readers

flexi-stream-external-format.

Writers

(setf flexi-stream-external-format).

Slot: element-type ¶

The element type of this stream.

Initform

(quote flexi-streams::char*)

Initargs

:element-type

Readers

flexi-stream-element-type.

Writers

(setf flexi-stream-element-type).

Class: in-memory-input-stream ¶

An IN-MEMORY-INPUT-STREAM is a binary stream that reads octets from a sequence in RAM.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses

• fundamental-binary-input-stream.
• in-memory-stream.

Direct subclasses

• list-input-stream.
• vector-input-stream.

Class: in-memory-output-stream ¶

An IN-MEMORY-OUTPUT-STREAM is a binary stream that writes octets to a sequence in RAM.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses

• fundamental-binary-output-stream.
• in-memory-stream.

Direct subclasses

vector-output-stream.

Direct methods

• get-output-stream-sequence.
• output-stream-sequence-length.

Class: in-memory-stream ¶

An IN-MEMORY-STREAM is a binary stream that reads octets from or writes octets to a sequence in RAM.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses

trivial-gray-stream-mixin.

Direct subclasses

• in-memory-input-stream.
• in-memory-output-stream.

Direct methods

• check-if-open.
• (setf in-memory-stream-transformer).
• in-memory-stream-transformer.
• stream-element-type.
• transform-octet.

Direct slots

Slot: transformer ¶

A function used to transform the
written/read octet to the value stored/retrieved in/from the underlying vector.

Initargs

:transformer

Readers

in-memory-stream-transformer.

Writers

(setf in-memory-stream-transformer).

Class: list-stream ¶

A LIST-STREAM is a mixin for IN-MEMORY streams where the underlying sequence is a list.

Package

flexi-streams.

Source

in-memory.lisp.

Direct subclasses

list-input-stream.

Direct methods

• (setf list-stream-list).
• list-stream-list.

Direct slots

Slot: list ¶

The underlying list of the stream.

Package

common-lisp.

Initargs

:list

Readers

list-stream-list.

Writers

(setf list-stream-list).

Class: vector-stream ¶

A VECTOR-STREAM is a mixin for IN-MEMORY streams where the underlying sequence is a vector.

Package

flexi-streams.

Source

in-memory.lisp.

Direct subclasses

• vector-input-stream.
• vector-output-stream.

Direct methods

• (setf vector-stream-vector).
• vector-stream-vector.

Direct slots

Slot: vector ¶

The underlying vector of the stream which
(for output) must always be adjustable and have a fill pointer.

Package

common-lisp.

Initargs

:vector

Readers

vector-stream-vector.

Writers

(setf vector-stream-vector).

---

5.1.8 Types

Type: octet () ¶

A shortcut for (UNSIGNED-BYTE 8).

Package

flexi-streams.

Source

mapping.lisp.

---

5.2.1 Constants

Constant: +ascii-hash+ ¶

A hash table which maps US-ASCII character codes to the corresponding octets.

Package

flexi-streams.

Source

specials.lisp.

Constant: +ascii-table+ ¶

An array enumerating the character codes for the US-ASCII encoding.

Package

flexi-streams.

Source

ascii.lisp.

Constant: +buffer-size+ ¶

Default size for buffers used for internal purposes.

Package

flexi-streams.

Source

specials.lisp.

Constant: +code-page-hashes+ ¶

An alist which maps IDs of Windows code pages to hash tables which map character codes to the corresponding octets.

Package

flexi-streams.

Source

specials.lisp.

Constant: +code-page-tables+ ¶

A list of 8-bit Windows code pages where each element is a cons with the car being the ID of the code page and the cdr being a vector enumerating the corresponding character codes.

Package

flexi-streams.

Source

code-pages.lisp.

Constant: +cr+ ¶

Package

flexi-streams.

Source

specials.lisp.

Constant: +iso-8859-hashes+ ¶

An alist which maps names for ISO-8859 encodings to hash tables which map character codes to the corresponding octets.

Package

flexi-streams.

Source

specials.lisp.

Constant: +iso-8859-tables+ ¶

A list of the ISO-8859 encodings where each element is a cons with the car being a keyword denoting the encoding and the cdr being a vector enumerating the corresponding character codes.

Package

flexi-streams.

Source

iso-8859.lisp.

Constant: +koi8-r-hash+ ¶

A hash table which maps KOI8-R character codes to the corresponding octets.

Package

flexi-streams.

Source

specials.lisp.

Constant: +koi8-r-table+ ¶

An array enumerating the character codes for the KOI8-R encoding.

Package

flexi-streams.

Source

koi8-r.lisp.

Constant: +lf+ ¶

Package

flexi-streams.

Source

specials.lisp.

Constant: +mac-roman-hash+ ¶

A hash table which maps MAC-ROMAN character codes to the corresponding octets.

Package

flexi-streams.

Source

specials.lisp.

Constant: +mac-roman-table+ ¶

An array enumerating the character codes for the MAC-ROMAN encoding.

Package

flexi-streams.

Source

mac.lisp.

---

5.2.2 Special variables

Special Variable: *current-unreader* ¶

A unary function which might be called to ‘unread’ a character (i.e. the sequence of octets it represents).

Used by the function OCTETS-TO-CHAR-CODE and must always be bound to a suitable functional object when this function is called.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *fixnum-optimize-settings* ¶

Like *STANDARD-OPTIMIZE-SETTINGS*, but (on LispWorks) with all arithmetic being fixnum arithmetic.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *gbk-to-ucs-special-table* ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Special Variable: *gbk-to-ucs-table* ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Special Variable: *hyperdoc-base-uri* ¶

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *standard-optimize-settings* ¶

The standard optimize settings used by most declaration expressions.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: *ucs-to-gbk-special-table* ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Special Variable: *ucs-to-gbk-table* ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Special Variable: +name-map+ ¶

An alist which mapes alternative names for external formats to their canonical counterparts.

Package

flexi-streams.

Source

specials.lisp.

Special Variable: +shortcut-map+ ¶

An alist which maps shortcuts for external formats to their long forms.

Package

flexi-streams.

Source

specials.lisp.

---

5.2.3 Macros

Macro: ash* (integer count) ¶

Solely for optimization purposes. Some Lisps need it, some don’t.

Package

flexi-streams.

Source

util.lisp.

Macro: defconstant (name value &optional doc) ¶

Make sure VALUE is evaluated only once (to appease SBCL).

Package

flexi-streams.

Source

mapping.lisp.

Macro: define-char-decoders ((lf-format-class cr-format-class crlf-format-class) &body body) ¶

Non-hygienic utility macro which defines several decoding-related methods for the classes LF-FORMAT-CLASS, CR-FORMAT-CLASS, and CRLF-FORMAT-CLASS where it is assumed that CR-FORMAT-CLASS is the same encoding as LF-FORMAT-CLASS but with CR instead of LF line endings and similar for CRLF-FORMAT-CLASS, i.e. LF-FORMAT-CLASS is the base class. BODY is a code template for the code to read octets and return one character code. BODY must contain a symbol OCTET-GETTER representing the form which is used to obtain the next octet.

Package

flexi-streams.

Source

decode.lisp.

Macro: define-char-encoders ((lf-format-class cr-format-class crlf-format-class) &body body) ¶

Non-hygienic utility macro which defines several encoding-related methods for the classes LF-FORMAT-CLASS, CR-FORMAT-CLASS, and CRLF-FORMAT-CLASS where it is assumed that CR-FORMAT-CLASS is the same encoding as LF-FORMAT-CLASS but with CR instead of LF line endings and similar for CRLF-FORMAT-CLASS, i.e. LF-FORMAT-CLASS is the base class. BODY is a code template for the code to convert one character to octets. BODY must contain a symbol CHAR-GETTER representing the form which is used to obtain the character and a forms like (OCTET-WRITE <thing>) to write the octet <thing>. The CHAR-GETTER form might be called more than once.

Package

flexi-streams.

Source

encode.lisp.

Macro: define-multibyte-mapper (name list) ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Macro: define-sequence-readers ((format-class) &body body) ¶

Non-hygienic utility macro which defines methods for READ-SEQUENCE* and OCTETS-TO-STRING* for the class FORMAT-CLASS. BODY is described in the docstring of DEFINE-CHAR-ENCODERS but can additionally contain a form (UNGET <form>) which has to be replaced by the correct code to ‘unread’ the octets for the character designated by <form>.

Package

flexi-streams.

Source

decode.lisp.

Macro: define-sequence-writers ((format-class) &body body) ¶

Non-hygienic utility macro which defines methods for WRITE-SEQUENCE* and STRING-TO-OCTETS* for the class FORMAT-CLASS. For BODY see the docstring of DEFINE-CHAR-ENCODERS.

Package

flexi-streams.

Source

encode.lisp.

Macro: logand* (x y) ¶

Solely for optimization purposes. Some Lisps need it, some don’t.

Package

flexi-streams.

Source

util.lisp.

Macro: logior* (x y) ¶

Solely for optimization purposes. Some Lisps need it, some don’t.

Package

flexi-streams.

Source

util.lisp.

Macro: when-let ((var form) &body body) ¶

Evaluates FORM and binds VAR to the result, then executes BODY if VAR has a true value.

Package

flexi-streams.

Source

util.lisp.

Macro: with-rebinding (bindings &body body) ¶

WITH-REBINDING ( { var | (var prefix) }* ) form*

Evaluates a series of forms in the lexical environment that is formed by adding the binding of each VAR to a fresh, uninterned symbol, and the binding of that fresh, uninterned symbol to VAR’s original value, i.e., its value in the current lexical environment.

The uninterned symbol is created as if by a call to GENSYM with the string denoted by PREFIX - or, if PREFIX is not supplied, the string denoted by VAR - as argument.

The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

Package

flexi-streams.

Source

util.lisp.

Macro: with-unique-names ((&rest bindings) &body body) ¶

Syntax: WITH-UNIQUE-NAMES ( { var | (var x) }* ) declaration* form*

Executes a series of forms with each VAR bound to a fresh, uninterned symbol. The uninterned symbol is as if returned by a call to GENSYM with the string denoted by X - or, if X is not supplied, the string denoted by VAR - as argument.

The variable bindings created are lexical unless special declarations are specified. The scopes of the name bindings and declarations do not include the Xs.

The forms are evaluated in order, and the values of all but the last are discarded (that is, the body is an implicit PROGN).

Package

flexi-streams.

Source

util.lisp.

---

5.2.4 Ordinary functions

Function: ascii-name-p (name) ¶

Checks whether NAME is the keyword :ASCII.

Package

flexi-streams.

Source

util.lisp.

Function: code-page-name-p (name) ¶

Checks whether NAME is the keyword :CODE-PAGE.

Package

flexi-streams.

Source

util.lisp.

Function: external-format-class-name (real-name &key eol-style little-endian id) ¶

Given the initargs for a general external format returns the name (a symbol) of the most specific subclass matching these arguments.

Package

flexi-streams.

Source

external-format.lisp.

Function: get-multibyte-mapper (table code) ¶

this function is borrowed from sbcl’s source file "/src/code/external-formats/mb-util.lisp", it search char code in "table" with specified "code"

Package

flexi-streams.

Source

util.lisp.

Function: hyperdoc-lookup (symbol type) ¶

Package

flexi-streams.

Source

specials.lisp.

Function: invert-table (table) ¶

‘Inverts’ an array which maps octets to character codes to a hash table which maps character codes to octets.

Package

flexi-streams.

Source

mapping.lisp.

Function: iso-8859-name-p (name) ¶

Checks whether NAME (a keyword) names one of the known ISO-8859 encodings.

Package

flexi-streams.

Source

util.lisp.

Function: known-code-page-id-p (id) ¶

Checks whether ID (a number) denotes one of the known Windows code pages.

Package

flexi-streams.

Source

util.lisp.

Function: koi8-r-name-p (name) ¶

Checks whether NAME is the keyword :KOI8-R.

Package

flexi-streams.

Source

util.lisp.

Function: mac-roman-name-p (name) ¶

Checks whether NAME is the keyword :MAC-ROMAN.

Package

flexi-streams.

Source

util.lisp.

Function: make-decoding-table (list) ¶

Creates and returns an array which contains the elements in the list LIST and has an element type that’s suitable for character codes.

Package

flexi-streams.

Source

mapping.lisp.

Function: make-external-format% (name &key little-endian id eol-style) ¶

Used internally by MAKE-EXTERNAL-FORMAT to default some of the keywords arguments and to determine the right subclass of EXTERNAL-FORMAT.

Package

flexi-streams.

Source

external-format.lisp.

Function: make-multibyte-mapper (list) ¶

Package

flexi-streams.

Source

enc-cn-tbl.lisp.

Function: make-octet-buffer (&optional size) ¶

Creates and returns a fresh buffer (a specialized array) of size +BUFFER-SIZE+ to hold octets.

Package

flexi-streams.

Source

util.lisp.

Function: make-output-vector (&key element-type) ¶

Creates and returns an array which can be used as the underlying vector for a VECTOR-OUTPUT-STREAM.

Package

flexi-streams.

Source

in-memory.lisp.

Function: maybe-convert-external-format (external-format) ¶

Given an external format designator (a keyword, a list, or an EXTERNAL-FORMAT object) returns the corresponding EXTERNAL-FORMAT object.

Package

flexi-streams.

Source

external-format.lisp.

Function: maybe-rewind (stream octets) ¶

Tries to ‘rewind’ the (binary) stream STREAM by OCTETS octets. Returns T if it succeeds, otherwise NIL.

Package

flexi-streams.

Source

util.lisp.

Function: normalize-external-format (external-format) ¶

Returns a list which is a ‘normalized’ representation of the external format EXTERNAL-FORMAT. Used internally by PRINT-OBJECT, for example. Basically, the result is an argument list that can be fed back to MAKE-EXTERNAL-FORMAT to create an equivalent object.

Package

flexi-streams.

Source

external-format.lisp.

Function: normalize-external-format-name (name) ¶

Converts NAME (a symbol) to a ‘canonical’ name for an external format, e.g. :LATIN1 will be converted to :ISO-8859-1. Also checks if there is an external format with that name and signals an error otherwise.

Package

flexi-streams.

Source

util.lisp.

Function: recover-from-encoding-error (external-format format-control &rest format-args) ¶

Helper function used by OCTETS-TO-CHAR-CODE below to deal with encoding errors. Checks if *SUBSTITUTION-CHAR* is not NIL and returns its character code in this case. Otherwise signals an EXTERNAL-FORMAT-ENCODING-ERROR as determined by the arguments to this function and provides a corresponding USE-VALUE restart.

Package

flexi-streams.

Source

decode.lisp.

Function: sans (plist &rest keys) ¶

Returns PLIST with keyword arguments from KEYS removed.

Package

flexi-streams.

Source

util.lisp.

Function: signal-encoding-error (external-format format-control &rest format-args) ¶

Convenience function similar to ERROR to signal conditions of type EXTERNAL-FORMAT-ENCODING-ERROR.

Package

flexi-streams.

Source

conditions.lisp.

Function: type-equal (type1 type2) ¶

Whether TYPE1 and TYPE2 denote the same type.

Package

flexi-streams.

Source

util.lisp.

Function: unread-char% (char flexi-input-stream) ¶

Used internally to put a character CHAR which was already read back on the stream. Uses the OCTET-STACK slot and decrements the POSITION slot accordingly.

Package

flexi-streams.

Source

input.lisp.

---