The flexi-streams Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The flexi-streams Reference Manual

This is the flexi-streams Reference Manual, version 1.0.19, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:33:39 2022 GMT+0.

Table of Contents


1 Introduction


FLEXI-STREAMS - Flexible bivalent streams for Common Lisp

FLEXI-STREAMS implements "virtual" bivalent streams that can be layered atop real binary or bivalent streams and that can be used to read and write character data in various single- or multi-octet encodings which can be changed on the fly. It also supplies in-memory binary streams which are similar to string streams.

Complete documentation can be found in the docs directory or at the project documentation site.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 flexi-streams

Flexible bivalent streams for Common Lisp

License

BSD-2-Clause

Version

1.0.19

Dependency

trivial-gray-streams (system).

Source

flexi-streams.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

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

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

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
Internals

3.1.11 flexi-streams/util.lisp

Dependency

specials.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

3.1.13 flexi-streams/external-format.lisp

Dependency

conditions.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface
Internals

3.1.14 flexi-streams/length.lisp

Dependency

external-format.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

3.1.15 flexi-streams/encode.lisp

Dependency

length.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

3.1.16 flexi-streams/decode.lisp

Dependency

encode.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Internals

3.1.17 flexi-streams/in-memory.lisp

Dependency

decode.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface
Internals

3.1.18 flexi-streams/stream.lisp

Dependency

in-memory.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface
Internals

3.1.19 flexi-streams/output.lisp

Dependency

stream.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface
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
Internals

3.1.21 flexi-streams/io.lisp

Dependency

input.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface
Internals

Previous: , Up: Lisp   [Contents][Index]

3.1.22 flexi-streams/strings.lisp

Dependency

io.lisp (file).

Source

flexi-streams.asd.

Parent Component

flexi-streams (system).

Public Interface

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 flexi-streams

Source

packages.lisp.

Nickname

flex

Use List
  • common-lisp.
  • trivial-gray-streams.
Public Interface
Internals

Previous: , Up: Packages   [Contents][Index]

4.2 flexi-streams-system

Source

flexi-streams.asd.

Use List
  • asdf/interface.
  • common-lisp.

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

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 ((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-input :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-clear-output :before ((stream flexi-io-stream))
Package

sb-gray.

Source

io.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: stream-element-type ((stream in-memory-stream))

The element type is always OCTET by definition.

Source

in-memory.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 ((stream flexi-input-stream))

Reads one byte (octet) from the underlying stream.

Package

sb-gray.

Source

input.lisp.

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

sb-gray.

Source

io.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 ((stream flexi-input-stream))
Package

sb-gray.

Source

input.lisp.

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

sb-gray.

Source

io.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 ((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 :before ((stream flexi-io-stream) sequence start end &key)
Package

trivial-gray-streams.

Source

io.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 ((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-unread-char :before ((stream flexi-io-stream) char)
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 :before ((stream flexi-io-stream) byte)
Package

sb-gray.

Source

io.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 :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-char :before ((stream flexi-io-stream) char)
Package

sb-gray.

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 :before ((stream flexi-io-stream) sequence start end &key)
Package

trivial-gray-streams.

Source

io.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
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
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
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.


Next: , Previous: , Up: Public Interface   [Contents][Index]

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
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
Direct methods
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
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
Direct methods
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
Direct subclasses
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
Direct subclasses

vector-output-stream.

Direct methods
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
Direct methods
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
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
Direct methods
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).


Previous: , Up: Public Interface   [Contents][Index]

5.1.8 Types

Type: octet ()

A shortcut for (UNSIGNED-BYTE 8).

Package

flexi-streams.

Source

mapping.lisp.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

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.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.5 Generic functions

Generic Function: char-to-octets (format char writer)

Converts the character CHAR to a sequence of octets
using the external format FORMAT. The conversion is performed by calling the unary function (which must be a functional object) WRITER repeatedly each octet. The return value of this function is unspecified.

Package

flexi-streams.

Source

encode.lisp.

Methods
Method: char-to-octets ((format flexi-crlf-mixin) char writer)
Method: char-to-octets ((format flexi-cr-mixin) char writer)
Method: char-to-octets ((format flexi-utf-32-be-format) char writer)
Method: char-to-octets ((format flexi-utf-32-le-format) char writer)
Method: char-to-octets ((format flexi-gbk-format) char writer)
Method: char-to-octets ((format flexi-utf-16-be-format) char writer)
Method: char-to-octets ((format flexi-utf-16-le-format) char writer)
Method: char-to-octets ((format flexi-utf-8-format) char writer)
Method: char-to-octets ((format flexi-8-bit-format) char writer)
Method: char-to-octets ((format flexi-ascii-format) char writer)
Method: char-to-octets ((format flexi-latin-1-format) char writer)
Generic Function: character-length (format char)

Returns the number of octets needed to encode the single character CHAR.

Package

flexi-streams.

Source

length.lisp.

Methods
Method: character-length ((format flexi-utf-32-format) char)
Method: character-length ((format flexi-8-bit-format) char)
Method: character-length :around ((format flexi-crlf-mixin) (char (eql #\newline)))
Method: character-length (format char)
Generic Function: check-end (format start end i)

Helper function used below to determine if we tried to read past the end of the sequence.

Package

flexi-streams.

Source

length.lisp.

Methods
Method: check-end (format start end i)
Method: check-end ((format flexi-utf-16-format) start end i)
Generic Function: check-if-open (stream)
Package

flexi-streams.

Methods
Method: check-if-open ((stream in-memory-stream))

Checks if STREAM is open and signals an error otherwise.

Source

in-memory.lisp.

Generic Function: compute-number-of-chars (format sequence start end)

Computes the exact number of characters required to
decode the sequence of octets in SEQUENCE from START to END using the external format FORMAT.

Package

flexi-streams.

Source

length.lisp.

Methods
Method: compute-number-of-chars ((format flexi-crlf-utf-32-be-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-utf-32-le-format) sequence start end)
Method: compute-number-of-chars ((format flexi-utf-32-format) sequence start end)
Method: compute-number-of-chars :before ((format flexi-utf-32-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-gbk-format) sequence start end)
Method: compute-number-of-chars ((format flexi-gbk-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-utf-16-be-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-utf-16-le-format) sequence start end)
Method: compute-number-of-chars ((format flexi-utf-16-be-format) sequence start end)
Method: compute-number-of-chars ((format flexi-utf-16-le-format) sequence start end)
Method: compute-number-of-chars :before ((format flexi-utf-16-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-utf-8-format) sequence start end)
Method: compute-number-of-chars ((format flexi-utf-8-format) sequence start end)
Method: compute-number-of-chars ((format flexi-crlf-mixin) sequence start end)
Method: compute-number-of-chars ((format flexi-8-bit-format) sequence start end)
Method: compute-number-of-chars :around (format (list list) start end)
Generic Function: compute-number-of-octets (format sequence start end)

Computes the exact number of octets required to
encode the sequence of characters in SEQUENCE from START to END using the external format FORMAT.

Package

flexi-streams.

Source

length.lisp.

Methods
Method: compute-number-of-octets ((format flexi-crlf-mixin) string start end)
Method: compute-number-of-octets ((format flexi-utf-32-format) string start end)
Method: compute-number-of-octets ((format flexi-crlf-utf-16-be-format) string start end)
Method: compute-number-of-octets ((format flexi-crlf-utf-16-le-format) string start end)
Method: compute-number-of-octets ((format flexi-utf-16-format) string start end)
Method: compute-number-of-octets ((format flexi-crlf-utf-8-format) string start end)
Method: compute-number-of-octets ((format flexi-utf-8-format) string start end)
Method: compute-number-of-octets ((format flexi-crlf-gbk-format) string start end)
Method: compute-number-of-octets ((format flexi-gbk-format) string start end)
Method: compute-number-of-octets ((format flexi-8-bit-format) string start end)
Method: compute-number-of-octets :around (format (list list) start end)
Generic Function: encoding-factor (format)

Given an external format FORMAT, returns a factor
which denotes the octets to characters ratio to expect when encoding/decoding. If the returned value is an integer, the factor is assumed to be exact. If it is a (double) float, the factor is supposed to be based on heuristics and usually not exact.

This factor is used in string.lisp.

Package

flexi-streams.

Source

length.lisp.

Methods
Method: encoding-factor ((format flexi-crlf-mixin))
Method: encoding-factor ((format flexi-utf-32-format))
Method: encoding-factor ((format flexi-gbk-format))
Method: encoding-factor ((format flexi-utf-16-format))
Method: encoding-factor ((format flexi-utf-8-format))
Method: encoding-factor ((format flexi-8-bit-format))
Generic Reader: external-format-decoding-table (object)
Package

flexi-streams.

Methods
Reader Method: external-format-decoding-table ((flexi-8-bit-format flexi-8-bit-format))

automatically generated reader method

Source

external-format.lisp.

Target Slot

decoding-table.

Generic Writer: (setf external-format-decoding-table) (object)
Package

flexi-streams.

Methods
Writer Method: (setf external-format-decoding-table) ((flexi-8-bit-format flexi-8-bit-format))

automatically generated writer method

Source

external-format.lisp.

Target Slot

decoding-table.

Generic Reader: external-format-encoding-hash (object)
Package

flexi-streams.

Methods
Reader Method: external-format-encoding-hash ((flexi-8-bit-format flexi-8-bit-format))

automatically generated reader method

Source

external-format.lisp.

Target Slot

encoding-hash.

Generic Writer: (setf external-format-encoding-hash) (object)
Package

flexi-streams.

Methods
Writer Method: (setf external-format-encoding-hash) ((flexi-8-bit-format flexi-8-bit-format))

automatically generated writer method

Source

external-format.lisp.

Target Slot

encoding-hash.

Generic Reader: flexi-stream-last-char-code (object)
Generic Writer: (setf flexi-stream-last-char-code) (object)
Package

flexi-streams.

Methods
Reader Method: flexi-stream-last-char-code ((flexi-input-stream flexi-input-stream))
Writer Method: (setf flexi-stream-last-char-code) ((flexi-input-stream flexi-input-stream))

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

Source

stream.lisp.

Target Slot

last-char-code.

Generic Reader: flexi-stream-last-octet (object)
Generic Writer: (setf flexi-stream-last-octet) (object)
Package

flexi-streams.

Methods
Reader Method: flexi-stream-last-octet ((flexi-input-stream flexi-input-stream))
Writer Method: (setf flexi-stream-last-octet) ((flexi-input-stream flexi-input-stream))

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.

Source

stream.lisp.

Target Slot

last-octet.

Generic Reader: flexi-stream-octet-stack (object)
Generic Writer: (setf flexi-stream-octet-stack) (object)
Package

flexi-streams.

Methods
Reader Method: flexi-stream-octet-stack ((flexi-input-stream flexi-input-stream))
Writer Method: (setf flexi-stream-octet-stack) ((flexi-input-stream flexi-input-stream))

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.

Source

stream.lisp.

Target Slot

octet-stack.

Generic Reader: in-memory-stream-transformer (object)
Generic Writer: (setf in-memory-stream-transformer) (object)
Package

flexi-streams.

Methods
Reader Method: in-memory-stream-transformer ((in-memory-stream in-memory-stream))
Writer Method: (setf in-memory-stream-transformer) ((in-memory-stream in-memory-stream))

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

Source

in-memory.lisp.

Target Slot

transformer.

Generic Reader: list-stream-list (object)
Generic Writer: (setf list-stream-list) (object)
Package

flexi-streams.

Methods
Reader Method: list-stream-list ((list-stream list-stream))
Writer Method: (setf list-stream-list) ((list-stream list-stream))

The underlying list of the stream.

Source

in-memory.lisp.

Target Slot

list.

Generic Function: octets-to-char-code (format reader)

Converts a sequence of octets to a character code
(which is returned, or NIL in case of EOF) using the external format FORMAT. The sequence is obtained by calling the function (which must be a functional object) READER with no arguments which should return one octet per call. In the case of EOF, READER should return NIL.

The special variable *CURRENT-UNREADER* must be bound correctly whenever this function is called.

Package

flexi-streams.

Source

decode.lisp.

Methods
Method: octets-to-char-code ((format flexi-crlf-mixin) reader)
Method: octets-to-char-code ((format flexi-cr-mixin) reader)
Method: octets-to-char-code ((format flexi-utf-32-be-format) reader)
Method: octets-to-char-code ((format flexi-utf-32-le-format) reader)
Method: octets-to-char-code ((format flexi-gbk-format) reader)
Method: octets-to-char-code ((format flexi-utf-16-be-format) reader)
Method: octets-to-char-code ((format flexi-utf-16-le-format) reader)
Method: octets-to-char-code ((format flexi-utf-8-format) reader)
Method: octets-to-char-code ((format flexi-8-bit-format) reader)
Method: octets-to-char-code ((format flexi-ascii-format) reader)
Method: octets-to-char-code ((format flexi-latin-1-format) reader)
Generic Function: octets-to-string* (format sequence start end)

A generic function which dispatches on the external format and does the real work for OCTETS-TO-STRING.

Package

flexi-streams.

Source

decode.lisp.

Methods
Method: octets-to-string* ((format flexi-crlf-utf-32-be-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-utf-32-be-format) sequence start end)
Method: octets-to-string* ((format flexi-utf-32-be-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-utf-32-le-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-utf-32-le-format) sequence start end)
Method: octets-to-string* ((format flexi-utf-32-le-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-gbk-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-gbk-format) sequence start end)
Method: octets-to-string* ((format flexi-gbk-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-utf-16-be-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-utf-16-be-format) sequence start end)
Method: octets-to-string* ((format flexi-utf-16-be-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-utf-16-le-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-utf-16-le-format) sequence start end)
Method: octets-to-string* ((format flexi-utf-16-le-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-utf-8-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-utf-8-format) sequence start end)
Method: octets-to-string* ((format flexi-utf-8-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-8-bit-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-8-bit-format) sequence start end)
Method: octets-to-string* ((format flexi-8-bit-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-ascii-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-ascii-format) sequence start end)
Method: octets-to-string* ((format flexi-ascii-format) sequence start end)
Method: octets-to-string* ((format flexi-crlf-latin-1-format) sequence start end)
Method: octets-to-string* ((format flexi-cr-latin-1-format) sequence start end)
Method: octets-to-string* ((format flexi-latin-1-format) sequence start end)
Method: octets-to-string* :around (format (list list) start end)
Generic Function: read-byte* (flexi-input-stream)
Package

flexi-streams.

Methods
Method: read-byte* ((flexi-input-stream flexi-input-stream))

Reads one byte (octet) from the underlying stream of FLEXI-OUTPUT-STREAM (or from the internal stack if it’s not empty).

Source

input.lisp.

Generic Function: read-sequence* (format flexi-input-stream sequence start end)
Package

flexi-streams.

Methods
Method: read-sequence* ((format flexi-crlf-utf-32-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-utf-32-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-utf-32-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-utf-32-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-utf-32-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-utf-32-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-gbk-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-gbk-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-gbk-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-utf-16-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-utf-16-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-utf-16-be-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-utf-16-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-utf-16-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-utf-16-le-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-utf-8-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-utf-8-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-utf-8-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-8-bit-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-8-bit-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-8-bit-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-ascii-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-ascii-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-ascii-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-crlf-latin-1-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-cr-latin-1-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Method: read-sequence* ((format flexi-latin-1-format) flexi-input-stream sequence start end)
Source

decode.lisp.

Generic Function: reset-input-state (flexi-io-stream)
Package

flexi-streams.

Methods
Method: reset-input-state ((flexi-io-stream flexi-io-stream))

This method is used to clear any state associated with previous input before output is attempted on the stream. It can fail if the octet stack is not empty and the stream can’t be ‘rewound’.

Source

io.lisp.

Generic Function: reset-output-state (flexi-io-stream)
Package

flexi-streams.

Methods
Method: reset-output-state ((flexi-io-stream flexi-io-stream))

This method is used to clear any state associated with previous output before the stream is used for input.

Source

io.lisp.

Generic Function: string-to-octets* (format string start end)

A generic function which dispatches on the external format and does the real work for STRING-TO-OCTETS.

Package

flexi-streams.

Source

encode.lisp.

Methods
Method: string-to-octets* ((format flexi-crlf-utf-32-be-format) string start end)
Method: string-to-octets* ((format flexi-cr-utf-32-be-format) string start end)
Method: string-to-octets* ((format flexi-utf-32-be-format) string start end)
Method: string-to-octets* ((format flexi-crlf-utf-32-le-format) string start end)
Method: string-to-octets* ((format flexi-cr-utf-32-le-format) string start end)
Method: string-to-octets* ((format flexi-utf-32-le-format) string start end)
Method: string-to-octets* ((format flexi-crlf-gbk-format) string start end)
Method: string-to-octets* ((format flexi-cr-gbk-format) string start end)
Method: string-to-octets* ((format flexi-gbk-format) string start end)
Method: string-to-octets* ((format flexi-crlf-utf-16-be-format) string start end)
Method: string-to-octets* ((format flexi-cr-utf-16-be-format) string start end)
Method: string-to-octets* ((format flexi-utf-16-be-format) string start end)
Method: string-to-octets* ((format flexi-crlf-utf-16-le-format) string start end)
Method: string-to-octets* ((format flexi-cr-utf-16-le-format) string start end)
Method: string-to-octets* ((format flexi-utf-16-le-format) string start end)
Method: string-to-octets* ((format flexi-crlf-utf-8-format) string start end)
Method: string-to-octets* ((format flexi-cr-utf-8-format) string start end)
Method: string-to-octets* ((format flexi-utf-8-format) string start end)
Method: string-to-octets* ((format flexi-crlf-8-bit-format) string start end)
Method: string-to-octets* ((format flexi-cr-8-bit-format) string start end)
Method: string-to-octets* ((format flexi-8-bit-format) string start end)
Method: string-to-octets* ((format flexi-crlf-ascii-format) string start end)
Method: string-to-octets* ((format flexi-cr-ascii-format) string start end)
Method: string-to-octets* ((format flexi-ascii-format) string start end)
Method: string-to-octets* ((format flexi-crlf-latin-1-format) string start end)
Method: string-to-octets* ((format flexi-cr-latin-1-format) string start end)
Method: string-to-octets* ((format flexi-latin-1-format) string start end)
Method: string-to-octets* :around (format (list list) start end)
Generic Function: transform-octet (stream octet)
Package

flexi-streams.

Methods
Method: transform-octet ((stream in-memory-stream) octet)

Applies the transformer of STREAM to octet and returns the result.

Source

in-memory.lisp.

Generic Reader: vector-stream-end (object)
Generic Writer: (setf vector-stream-end) (object)
Package

flexi-streams.

Methods
Reader Method: vector-stream-end ((vector-input-stream vector-input-stream))
Writer Method: (setf vector-stream-end) ((vector-input-stream vector-input-stream))

An index into the underlying vector denoting the end of the available data.

Source

in-memory.lisp.

Target Slot

end.

Generic Reader: vector-stream-index (object)
Generic Writer: (setf vector-stream-index) (object)
Package

flexi-streams.

Methods
Reader Method: vector-stream-index ((vector-input-stream vector-input-stream))
Writer Method: (setf vector-stream-index) ((vector-input-stream vector-input-stream))

An index into the underlying vector denoting the current position.

Source

in-memory.lisp.

Target Slot

index.

Generic Reader: vector-stream-vector (object)
Generic Writer: (setf vector-stream-vector) (object)
Package

flexi-streams.

Methods
Reader Method: vector-stream-vector ((vector-stream vector-stream))
Writer Method: (setf vector-stream-vector) ((vector-stream vector-stream))

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

Source

in-memory.lisp.

Target Slot

vector.

Generic Function: write-byte* (byte stream)

Writes one byte (octet) to the underlying stream STREAM.

Package

flexi-streams.

Source

output.lisp.

Methods
Method: write-byte* :after (byte (stream flexi-io-stream))

Keep POSITION slot up to date even when performing output.

Source

io.lisp.

Method: write-byte* (byte (flexi-output-stream flexi-output-stream))
Generic Function: write-sequence* (format stream sequence start end)

A generic function which dispatches on the external format and does the real work for STREAM-WRITE-SEQUENCE.

Package

flexi-streams.

Source

encode.lisp.

Methods
Method: write-sequence* ((format flexi-crlf-utf-32-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-utf-32-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-utf-32-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-utf-32-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-utf-32-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-utf-32-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-gbk-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-gbk-format) stream sequence start end)
Method: write-sequence* ((format flexi-gbk-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-utf-16-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-utf-16-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-utf-16-be-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-utf-16-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-utf-16-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-utf-16-le-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-utf-8-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-utf-8-format) stream sequence start end)
Method: write-sequence* ((format flexi-utf-8-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-8-bit-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-8-bit-format) stream sequence start end)
Method: write-sequence* ((format flexi-8-bit-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-ascii-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-ascii-format) stream sequence start end)
Method: write-sequence* ((format flexi-ascii-format) stream sequence start end)
Method: write-sequence* ((format flexi-crlf-latin-1-format) stream sequence start end)
Method: write-sequence* ((format flexi-cr-latin-1-format) stream sequence start end)
Method: write-sequence* ((format flexi-latin-1-format) stream sequence start end)

Next: , Previous: , Up: Internals   [Contents][Index]

5.2.6 Conditions

Condition: flexi-stream-simple-error

Like FLEXI-STREAM-ERROR but with formatting capabilities.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses
Condition: in-memory-stream-simple-error

Like IN-MEMORY-STREAM-ERROR but with formatting capabilities.

Package

flexi-streams.

Source

conditions.lisp.

Direct superclasses
Direct subclasses

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


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.7 Classes

Class: external-format

EXTERNAL-FORMAT objects are used to denote
encodings for flexi streams or for the string functions defined in strings.lisp.

Package

flexi-streams.

Source

external-format.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name

The name of the external format - a keyword.

Initargs

:name

Readers

external-format-name.

Writers

This slot is read-only.

Slot: id

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

Initargs

:id

Readers

external-format-id.

Writers

This slot is read-only.

Slot: little-endian

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.

Initform

flexi-streams:*default-little-endian*

Initargs

:little-endian

Readers

external-format-little-endian.

Writers

This slot is read-only.

Slot: eol-style

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

Initargs

:eol-style

Readers

external-format-eol-style.

Writers

This slot is read-only.

Class: flexi-8-bit-format

The class for all flexi streams which use an 8-bit
encoding and thus need additional slots for the encoding/decoding tables.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

external-format.

Direct subclasses
Direct methods
Direct slots
Slot: encoding-hash
Readers

external-format-encoding-hash.

Writers

(setf external-format-encoding-hash).

Slot: decoding-table
Readers

external-format-decoding-table.

Writers

(setf external-format-decoding-table).

Class: flexi-ascii-format

Special class for external formats which use the US-ASCII encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-8-bit-format.

Direct subclasses
Direct methods
Class: flexi-cr-8-bit-format

Special class for external formats which use an
8-bit encoding /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-ascii-format

Special class for external formats which use the
US-ASCII encoding /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-gbk-format

Special class for external formats which use the
gbk encoding /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-latin-1-format

Special class for external formats which use the
ISO-8859-1 encoding /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-mixin

A mixin for external-formats where the end-of-line designator is #Return.

Package

flexi-streams.

Source

external-format.lisp.

Direct subclasses
Direct methods
Class: flexi-cr-utf-16-be-format

Special class for external formats which use the
UTF-16 encoding with big-endian byte ordering /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-utf-16-le-format

Special class for external formats which use the
UTF-16 encoding with little-endian byte ordering /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-utf-32-be-format

Special class for external formats which use the
UTF-32 encoding with big-endian byte ordering /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-utf-32-le-format

Special class for external formats which use the
UTF-32 encoding with little-endian byte ordering /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-cr-utf-8-format

Special class for external formats which use the
UTF-8 encoding /and/ have #Return as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-8-bit-format

Special class for external formats which use an
8-bit encoding /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-ascii-format

Special class for external formats which use the
US-ASCII encoding /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-gbk-format

Special class for external formats which use the
gbk encoding /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-latin-1-format

Special class for external formats which use the
ISO-8859-1 encoding /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-mixin

A mixin for external-formats where the end-of-line designator is the sequence #Return #Linefeed.

Package

flexi-streams.

Source

external-format.lisp.

Direct subclasses
Direct methods
Class: flexi-crlf-utf-16-be-format

Special class for external formats which use the
UTF-16 encoding with big-endian byte ordering /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-utf-16-le-format

Special class for external formats which use the
UTF-16 encoding with little-endian byte ordering /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-utf-32-be-format

Special class for external formats which use the
the UTF-32 encoding with big-endian byte ordering /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-utf-32-le-format

Special class for external formats which use the
UTF-32 encoding with little-endian byte ordering /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-crlf-utf-8-format

Special class for external formats which use the
UTF-8 encoding /and/ have the sequence #Return #Linefeed as the line-end character.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses
Direct methods
Class: flexi-gbk-format

Special class for external formats which use the gbk encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

external-format.

Direct subclasses
Direct methods
Class: flexi-latin-1-format

Special class for external formats which use the ISO-8859-1 encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-8-bit-format.

Direct subclasses
Direct methods
Class: flexi-utf-16-be-format

Special class for external formats which use the UTF-16 encoding with big-endian byte ordering.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-utf-16-format.

Direct subclasses
Direct methods
Class: flexi-utf-16-format

Abstract class for external formats which use the UTF-16 encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

external-format.

Direct subclasses
Direct methods
Class: flexi-utf-16-le-format

Special class for external formats which use the UTF-16 encoding with little-endian byte ordering.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-utf-16-format.

Direct subclasses
Direct methods
Class: flexi-utf-32-be-format

Special class for external formats which use the UTF-32 encoding with big-endian byte ordering.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-utf-32-format.

Direct subclasses
Direct methods
Class: flexi-utf-32-format

Abstract class for external formats which use the UTF-32 encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

external-format.

Direct subclasses
Direct methods
Class: flexi-utf-32-le-format

Special class for external formats which use the UTF-32 encoding with little-endian byte ordering.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

flexi-utf-32-format.

Direct subclasses
Direct methods
Class: flexi-utf-8-format

Special class for external formats which use the UTF-8 encoding.

Package

flexi-streams.

Source

external-format.lisp.

Direct superclasses

external-format.

Direct subclasses
Direct methods
Class: list-input-stream

A binary input stream that gets its data from an associated list of octets.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses
Direct methods
Class: vector-input-stream

A binary input stream that gets its data from an associated vector of octets.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: index

An index into the underlying vector denoting the current position.

Type

(integer 0 4611686018427387901)

Initargs

:index

Readers

vector-stream-index.

Writers

(setf vector-stream-index).

Slot: end

An index into the underlying vector denoting the end of the available data.

Type

(integer 0 4611686018427387901)

Initargs

:end

Readers

vector-stream-end.

Writers

(setf vector-stream-end).

Class: vector-output-stream

A binary output stream that writes its data to an associated vector.

Package

flexi-streams.

Source

in-memory.lisp.

Direct superclasses
Direct methods

Previous: , Up: Internals   [Contents][Index]

5.2.8 Types

Type: char* ()

Convenience shortcut to paper over the difference between LispWorks and the other Lisps.

Package

flexi-streams.

Source

mapping.lisp.

Type: char-code-integer ()

The subtype of integers which can be returned by the function CHAR-CODE.

Package

flexi-streams.

Source

mapping.lisp.

Type: code-point ()

The subtype of integers that’s just big enough to hold all Unicode codepoints.

See for example <http://unicode.org/glossary/#C>.

Package

flexi-streams.

Source

mapping.lisp.

Type: string* ()

Convenience shortcut to paper over the difference between LispWorks and the other Lisps.

Package

flexi-streams.

Source

mapping.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf external-format-decoding-table): Private generic functions
(setf external-format-decoding-table): Private generic functions
(setf external-format-encoding-hash): Private generic functions
(setf external-format-encoding-hash): Private generic functions
(setf flexi-stream-bound): Public generic functions
(setf flexi-stream-bound): Public generic functions
(setf flexi-stream-column): Public generic functions
(setf flexi-stream-column): Public generic functions
(setf flexi-stream-element-type): Public generic functions
(setf flexi-stream-element-type): Public generic functions
(setf flexi-stream-element-type): Public generic functions
(setf flexi-stream-external-format): Public generic functions
(setf flexi-stream-external-format): Public generic functions
(setf flexi-stream-external-format): Public generic functions
(setf flexi-stream-last-char-code): Private generic functions
(setf flexi-stream-last-char-code): Private generic functions
(setf flexi-stream-last-octet): Private generic functions
(setf flexi-stream-last-octet): Private generic functions
(setf flexi-stream-octet-stack): Private generic functions
(setf flexi-stream-octet-stack): Private generic functions
(setf flexi-stream-position): Public generic functions
(setf flexi-stream-position): Public generic functions
(setf in-memory-stream-transformer): Private generic functions
(setf in-memory-stream-transformer): Private generic functions
(setf list-stream-list): Private generic functions
(setf list-stream-list): Private generic functions
(setf stream-file-position): Public standalone methods
(setf stream-file-position): Public standalone methods
(setf stream-file-position): Public standalone methods
(setf vector-stream-end): Private generic functions
(setf vector-stream-end): Private generic functions
(setf vector-stream-index): Private generic functions
(setf vector-stream-index): Private generic functions
(setf vector-stream-vector): Private generic functions
(setf vector-stream-vector): Private generic functions

A
ascii-name-p: Private ordinary functions
ash*: Private macros

C
char-length: Public ordinary functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
char-to-octets: Private generic functions
character-length: Private generic functions
character-length: Private generic functions
character-length: Private generic functions
character-length: Private generic functions
character-length: Private generic functions
check-end: Private generic functions
check-end: Private generic functions
check-end: Private generic functions
check-if-open: Private generic functions
check-if-open: Private generic functions
close: Public standalone methods
code-page-name-p: Private ordinary functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-chars: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions
compute-number-of-octets: Private generic functions

D
defconstant: Private macros
define-char-decoders: Private macros
define-char-encoders: Private macros
define-multibyte-mapper: Private macros
define-sequence-readers: Private macros
define-sequence-writers: Private macros

E
encoding-factor: Private generic functions
encoding-factor: Private generic functions
encoding-factor: Private generic functions
encoding-factor: Private generic functions
encoding-factor: Private generic functions
encoding-factor: Private generic functions
encoding-factor: Private generic functions
external-format-class-name: Private ordinary functions
external-format-condition-external-format: Public generic functions
external-format-condition-external-format: Public generic functions
external-format-decoding-table: Private generic functions
external-format-decoding-table: Private generic functions
external-format-encoding-hash: Private generic functions
external-format-encoding-hash: Private generic functions
external-format-eol-style: Public generic functions
external-format-eol-style: Public generic functions
external-format-equal: Public ordinary functions
external-format-id: Public generic functions
external-format-id: Public generic functions
external-format-little-endian: Public generic functions
external-format-little-endian: Public generic functions
external-format-name: Public generic functions
external-format-name: Public generic functions

F
flexi-stream-bound: Public generic functions
flexi-stream-bound: Public generic functions
flexi-stream-column: Public generic functions
flexi-stream-column: Public generic functions
flexi-stream-element-type: Public generic functions
flexi-stream-element-type: Public generic functions
flexi-stream-element-type-error-element-type: Public generic functions
flexi-stream-element-type-error-element-type: Public generic functions
flexi-stream-external-format: Public generic functions
flexi-stream-external-format: Public generic functions
flexi-stream-last-char-code: Private generic functions
flexi-stream-last-char-code: Private generic functions
flexi-stream-last-octet: Private generic functions
flexi-stream-last-octet: Private generic functions
flexi-stream-octet-stack: Private generic functions
flexi-stream-octet-stack: Private generic functions
flexi-stream-position: Public generic functions
flexi-stream-position: Public generic functions
flexi-stream-stream: Public generic functions
flexi-stream-stream: Public generic functions
Function, ascii-name-p: Private ordinary functions
Function, char-length: Public ordinary functions
Function, code-page-name-p: Private ordinary functions
Function, external-format-class-name: Private ordinary functions
Function, external-format-equal: Public ordinary functions
Function, get-multibyte-mapper: Private ordinary functions
Function, hyperdoc-lookup: Private ordinary functions
Function, invert-table: Private ordinary functions
Function, iso-8859-name-p: Private ordinary functions
Function, known-code-page-id-p: Private ordinary functions
Function, koi8-r-name-p: Private ordinary functions
Function, mac-roman-name-p: Private ordinary functions
Function, make-decoding-table: Private ordinary functions
Function, make-external-format: Public ordinary functions
Function, make-external-format%: Private ordinary functions
Function, make-flexi-stream: Public ordinary functions
Function, make-in-memory-output-stream: Public ordinary functions
Function, make-multibyte-mapper: Private ordinary functions
Function, make-octet-buffer: Private ordinary functions
Function, make-output-vector: Private ordinary functions
Function, maybe-convert-external-format: Private ordinary functions
Function, maybe-rewind: Private ordinary functions
Function, normalize-external-format: Private ordinary functions
Function, normalize-external-format-name: Private ordinary functions
Function, octet-length: Public ordinary functions
Function, octets-to-string: Public ordinary functions
Function, recover-from-encoding-error: Private ordinary functions
Function, sans: Private ordinary functions
Function, signal-encoding-error: Private ordinary functions
Function, string-to-octets: Public ordinary functions
Function, type-equal: Private ordinary functions
Function, unread-char%: Private ordinary functions

G
Generic Function, (setf external-format-decoding-table): Private generic functions
Generic Function, (setf external-format-encoding-hash): Private generic functions
Generic Function, (setf flexi-stream-bound): Public generic functions
Generic Function, (setf flexi-stream-column): Public generic functions
Generic Function, (setf flexi-stream-element-type): Public generic functions
Generic Function, (setf flexi-stream-external-format): Public generic functions
Generic Function, (setf flexi-stream-last-char-code): Private generic functions
Generic Function, (setf flexi-stream-last-octet): Private generic functions
Generic Function, (setf flexi-stream-octet-stack): Private generic functions
Generic Function, (setf flexi-stream-position): Public generic functions
Generic Function, (setf in-memory-stream-transformer): Private generic functions
Generic Function, (setf list-stream-list): Private generic functions
Generic Function, (setf vector-stream-end): Private generic functions
Generic Function, (setf vector-stream-index): Private generic functions
Generic Function, (setf vector-stream-vector): Private generic functions
Generic Function, char-to-octets: Private generic functions
Generic Function, character-length: Private generic functions
Generic Function, check-end: Private generic functions
Generic Function, check-if-open: Private generic functions
Generic Function, compute-number-of-chars: Private generic functions
Generic Function, compute-number-of-octets: Private generic functions
Generic Function, encoding-factor: Private generic functions
Generic Function, external-format-condition-external-format: Public generic functions
Generic Function, external-format-decoding-table: Private generic functions
Generic Function, external-format-encoding-hash: Private generic functions
Generic Function, external-format-eol-style: Public generic functions
Generic Function, external-format-id: Public generic functions
Generic Function, external-format-little-endian: Public generic functions
Generic Function, external-format-name: Public generic functions
Generic Function, flexi-stream-bound: Public generic functions
Generic Function, flexi-stream-column: Public generic functions
Generic Function, flexi-stream-element-type: Public generic functions
Generic Function, flexi-stream-element-type-error-element-type: Public generic functions
Generic Function, flexi-stream-external-format: Public generic functions
Generic Function, flexi-stream-last-char-code: Private generic functions
Generic Function, flexi-stream-last-octet: Private generic functions
Generic Function, flexi-stream-octet-stack: Private generic functions
Generic Function, flexi-stream-position: Public generic functions
Generic Function, flexi-stream-stream: Public generic functions
Generic Function, get-output-stream-sequence: Public generic functions
Generic Function, in-memory-stream-position-spec-error-position-spec: Public generic functions
Generic Function, in-memory-stream-transformer: Private generic functions
Generic Function, list-stream-list: Private generic functions
Generic Function, make-in-memory-input-stream: Public generic functions
Generic Function, octets-to-char-code: Private generic functions
Generic Function, octets-to-string*: Private generic functions
Generic Function, output-stream-sequence-length: Public generic functions
Generic Function, peek-byte: Public generic functions
Generic Function, read-byte*: Private generic functions
Generic Function, read-sequence*: Private generic functions
Generic Function, reset-input-state: Private generic functions
Generic Function, reset-output-state: Private generic functions
Generic Function, string-to-octets*: Private generic functions
Generic Function, transform-octet: Private generic functions
Generic Function, unread-byte: Public generic functions
Generic Function, vector-stream-end: Private generic functions
Generic Function, vector-stream-index: Private generic functions
Generic Function, vector-stream-vector: Private generic functions
Generic Function, write-byte*: Private generic functions
Generic Function, write-sequence*: Private generic functions
get-multibyte-mapper: Private ordinary functions
get-output-stream-sequence: Public generic functions
get-output-stream-sequence: Public generic functions

H
hyperdoc-lookup: Private ordinary functions

I
in-memory-stream-position-spec-error-position-spec: Public generic functions
in-memory-stream-position-spec-error-position-spec: Public generic functions
in-memory-stream-transformer: Private generic functions
in-memory-stream-transformer: Private generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
invert-table: Private ordinary functions
iso-8859-name-p: Private ordinary functions

K
known-code-page-id-p: Private ordinary functions
koi8-r-name-p: Private ordinary functions

L
list-stream-list: Private generic functions
list-stream-list: Private generic functions
logand*: Private macros
logior*: Private macros

M
mac-roman-name-p: Private ordinary functions
Macro, ash*: Private macros
Macro, defconstant: Private macros
Macro, define-char-decoders: Private macros
Macro, define-char-encoders: Private macros
Macro, define-multibyte-mapper: Private macros
Macro, define-sequence-readers: Private macros
Macro, define-sequence-writers: Private macros
Macro, logand*: Private macros
Macro, logior*: Private macros
Macro, when-let: Private macros
Macro, with-input-from-sequence: Public macros
Macro, with-output-to-sequence: Public macros
Macro, with-rebinding: Private macros
Macro, with-unique-names: Private macros
make-decoding-table: Private ordinary functions
make-external-format: Public ordinary functions
make-external-format%: Private ordinary functions
make-flexi-stream: Public ordinary functions
make-in-memory-input-stream: Public generic functions
make-in-memory-input-stream: Public generic functions
make-in-memory-input-stream: Public generic functions
make-in-memory-output-stream: Public ordinary functions
make-load-form: Public standalone methods
make-multibyte-mapper: Private ordinary functions
make-octet-buffer: Private ordinary functions
make-output-vector: Private ordinary functions
maybe-convert-external-format: Private ordinary functions
maybe-rewind: Private ordinary functions
Method, (setf external-format-decoding-table): Private generic functions
Method, (setf external-format-encoding-hash): Private generic functions
Method, (setf flexi-stream-bound): Public generic functions
Method, (setf flexi-stream-column): Public generic functions
Method, (setf flexi-stream-element-type): Public generic functions
Method, (setf flexi-stream-element-type): Public generic functions
Method, (setf flexi-stream-external-format): Public generic functions
Method, (setf flexi-stream-external-format): Public generic functions
Method, (setf flexi-stream-last-char-code): Private generic functions
Method, (setf flexi-stream-last-octet): Private generic functions
Method, (setf flexi-stream-octet-stack): Private generic functions
Method, (setf flexi-stream-position): Public generic functions
Method, (setf in-memory-stream-transformer): Private generic functions
Method, (setf list-stream-list): Private generic functions
Method, (setf stream-file-position): Public standalone methods
Method, (setf stream-file-position): Public standalone methods
Method, (setf stream-file-position): Public standalone methods
Method, (setf vector-stream-end): Private generic functions
Method, (setf vector-stream-index): Private generic functions
Method, (setf vector-stream-vector): Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, char-to-octets: Private generic functions
Method, character-length: Private generic functions
Method, character-length: Private generic functions
Method, character-length: Private generic functions
Method, character-length: Private generic functions
Method, check-end: Private generic functions
Method, check-end: Private generic functions
Method, check-if-open: Private generic functions
Method, close: Public standalone methods
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-chars: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, compute-number-of-octets: Private generic functions
Method, encoding-factor: Private generic functions
Method, encoding-factor: Private generic functions
Method, encoding-factor: Private generic functions
Method, encoding-factor: Private generic functions
Method, encoding-factor: Private generic functions
Method, encoding-factor: Private generic functions
Method, external-format-condition-external-format: Public generic functions
Method, external-format-decoding-table: Private generic functions
Method, external-format-encoding-hash: Private generic functions
Method, external-format-eol-style: Public generic functions
Method, external-format-id: Public generic functions
Method, external-format-little-endian: Public generic functions
Method, external-format-name: Public generic functions
Method, flexi-stream-bound: Public generic functions
Method, flexi-stream-column: Public generic functions
Method, flexi-stream-element-type: Public generic functions
Method, flexi-stream-element-type-error-element-type: Public generic functions
Method, flexi-stream-external-format: Public generic functions
Method, flexi-stream-last-char-code: Private generic functions
Method, flexi-stream-last-octet: Private generic functions
Method, flexi-stream-octet-stack: Private generic functions
Method, flexi-stream-position: Public generic functions
Method, flexi-stream-stream: Public generic functions
Method, get-output-stream-sequence: Public generic functions
Method, in-memory-stream-position-spec-error-position-spec: Public generic functions
Method, in-memory-stream-transformer: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, list-stream-list: Private generic functions
Method, make-in-memory-input-stream: Public generic functions
Method, make-in-memory-input-stream: Public generic functions
Method, make-load-form: Public standalone methods
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-char-code: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, octets-to-string*: Private generic functions
Method, open-stream-p: Public standalone methods
Method, output-stream-sequence-length: Public generic functions
Method, peek-byte: Public generic functions
Method, peek-byte: Public generic functions
Method, peek-byte: Public generic functions
Method, print-object: Public standalone methods
Method, read-byte*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, read-sequence*: Private generic functions
Method, reset-input-state: Private generic functions
Method, reset-output-state: Private generic functions
Method, stream-clear-input: Public standalone methods
Method, stream-clear-input: Public standalone methods
Method, stream-clear-output: Public standalone methods
Method, stream-clear-output: Public standalone methods
Method, stream-element-type: Public standalone methods
Method, stream-element-type: Public standalone methods
Method, stream-file-position: Public standalone methods
Method, stream-file-position: Public standalone methods
Method, stream-file-position: Public standalone methods
Method, stream-finish-output: Public standalone methods
Method, stream-force-output: Public standalone methods
Method, stream-line-column: Public standalone methods
Method, stream-listen: Public standalone methods
Method, stream-listen: Public standalone methods
Method, stream-listen: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-char: Public standalone methods
Method, stream-read-char: Public standalone methods
Method, stream-read-char-no-hang: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-unread-char: Public standalone methods
Method, stream-unread-char: Public standalone methods
Method, stream-write-byte: Public standalone methods
Method, stream-write-byte: Public standalone methods
Method, stream-write-byte: Public standalone methods
Method, stream-write-char: Public standalone methods
Method, stream-write-char: Public standalone methods
Method, stream-write-char: Public standalone methods
Method, stream-write-sequence: Public standalone methods
Method, stream-write-sequence: Public standalone methods
Method, stream-write-sequence: Public standalone methods
Method, stream-write-string: Public standalone methods
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, string-to-octets*: Private generic functions
Method, transform-octet: Private generic functions
Method, unread-byte: Public generic functions
Method, unread-byte: Public generic functions
Method, vector-stream-end: Private generic functions
Method, vector-stream-index: Private generic functions
Method, vector-stream-vector: Private generic functions
Method, write-byte*: Private generic functions
Method, write-byte*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions
Method, write-sequence*: Private generic functions

N
normalize-external-format: Private ordinary functions
normalize-external-format-name: Private ordinary functions

O
octet-length: Public ordinary functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-char-code: Private generic functions
octets-to-string: Public ordinary functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
octets-to-string*: Private generic functions
open-stream-p: Public standalone methods
output-stream-sequence-length: Public generic functions
output-stream-sequence-length: Public generic functions

P
peek-byte: Public generic functions
peek-byte: Public generic functions
peek-byte: Public generic functions
peek-byte: Public generic functions
print-object: Public standalone methods

R
read-byte*: Private generic functions
read-byte*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
read-sequence*: Private generic functions
recover-from-encoding-error: Private ordinary functions
reset-input-state: Private generic functions
reset-input-state: Private generic functions
reset-output-state: Private generic functions
reset-output-state: Private generic functions

S
sans: Private ordinary functions
signal-encoding-error: Private ordinary functions
stream-clear-input: Public standalone methods
stream-clear-input: Public standalone methods
stream-clear-output: Public standalone methods
stream-clear-output: Public standalone methods
stream-element-type: Public standalone methods
stream-element-type: Public standalone methods
stream-file-position: Public standalone methods
stream-file-position: Public standalone methods
stream-file-position: Public standalone methods
stream-finish-output: Public standalone methods
stream-force-output: Public standalone methods
stream-line-column: Public standalone methods
stream-listen: Public standalone methods
stream-listen: Public standalone methods
stream-listen: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-char: Public standalone methods
stream-read-char: Public standalone methods
stream-read-char-no-hang: Public standalone methods
stream-read-sequence: Public standalone methods
stream-read-sequence: Public standalone methods
stream-read-sequence: Public standalone methods
stream-read-sequence: Public standalone methods
stream-unread-char: Public standalone methods
stream-unread-char: Public standalone methods
stream-write-byte: Public standalone methods
stream-write-byte: Public standalone methods
stream-write-byte: Public standalone methods
stream-write-char: Public standalone methods
stream-write-char: Public standalone methods
stream-write-char: Public standalone methods
stream-write-sequence: Public standalone methods
stream-write-sequence: Public standalone methods
stream-write-sequence: Public standalone methods
stream-write-string: Public standalone methods
string-to-octets: Public ordinary functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions
string-to-octets*: Private generic functions

T
transform-octet: Private generic functions
transform-octet: Private generic functions
type-equal: Private ordinary functions

U
unread-byte: Public generic functions
unread-byte: Public generic functions
unread-byte: Public generic functions
unread-char%: Private ordinary functions

V
vector-stream-end: Private generic functions
vector-stream-end: Private generic functions
vector-stream-index: Private generic functions
vector-stream-index: Private generic functions
vector-stream-vector: Private generic functions
vector-stream-vector: Private generic functions

W
when-let: Private macros
with-input-from-sequence: Public macros
with-output-to-sequence: Public macros
with-rebinding: Private macros
with-unique-names: Private macros
write-byte*: Private generic functions
write-byte*: Private generic functions
write-byte*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions
write-sequence*: Private generic functions

Jump to:   (  
A   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
B   C   D   E   I   L   N   O   P   S   T   V  
Index Entry  Section

*
*current-unreader*: Private special variables
*default-eol-style*: Public special variables
*default-little-endian*: Public special variables
*fixnum-optimize-settings*: Private special variables
*gbk-to-ucs-special-table*: Private special variables
*gbk-to-ucs-table*: Private special variables
*hyperdoc-base-uri*: Private special variables
*standard-optimize-settings*: Private special variables
*substitution-char*: Public special variables
*ucs-to-gbk-special-table*: Private special variables
*ucs-to-gbk-table*: Private special variables

+
+ascii-hash+: Private constants
+ascii-table+: Private constants
+buffer-size+: Private constants
+code-page-hashes+: Private constants
+code-page-tables+: Private constants
+cr+: Private constants
+iso-8859-hashes+: Private constants
+iso-8859-tables+: Private constants
+koi8-r-hash+: Private constants
+koi8-r-table+: Private constants
+lf+: Private constants
+mac-roman-hash+: Private constants
+mac-roman-table+: Private constants
+name-map+: Private special variables
+shortcut-map+: Private special variables

B
bound: Public classes

C
column: Public classes
Constant, +ascii-hash+: Private constants
Constant, +ascii-table+: Private constants
Constant, +buffer-size+: Private constants
Constant, +code-page-hashes+: Private constants
Constant, +code-page-tables+: Private constants
Constant, +cr+: Private constants
Constant, +iso-8859-hashes+: Private constants
Constant, +iso-8859-tables+: Private constants
Constant, +koi8-r-hash+: Private constants
Constant, +koi8-r-table+: Private constants
Constant, +lf+: Private constants
Constant, +mac-roman-hash+: Private constants
Constant, +mac-roman-table+: Private constants

D
decoding-table: Private classes

E
element-type: Public conditions
element-type: Public classes
encoding-hash: Private classes
end: Private classes
eol-style: Private classes
external-format: Public conditions
external-format: Public classes

I
id: Private classes
index: Private classes

L
last-char-code: Public classes
last-octet: Public classes
list: Public classes
little-endian: Private classes

N
name: Private classes

O
octet-stack: Public classes

P
position: Public classes
position-spec: Public conditions

S
Slot, bound: Public classes
Slot, column: Public classes
Slot, decoding-table: Private classes
Slot, element-type: Public conditions
Slot, element-type: Public classes
Slot, encoding-hash: Private classes
Slot, end: Private classes
Slot, eol-style: Private classes
Slot, external-format: Public conditions
Slot, external-format: Public classes
Slot, id: Private classes
Slot, index: Private classes
Slot, last-char-code: Public classes
Slot, last-octet: Public classes
Slot, list: Public classes
Slot, little-endian: Private classes
Slot, name: Private classes
Slot, octet-stack: Public classes
Slot, position: Public classes
Slot, position-spec: Public conditions
Slot, stream: Public classes
Slot, transformer: Public classes
Slot, vector: Public classes
Special Variable, *current-unreader*: Private special variables
Special Variable, *default-eol-style*: Public special variables
Special Variable, *default-little-endian*: Public special variables
Special Variable, *fixnum-optimize-settings*: Private special variables
Special Variable, *gbk-to-ucs-special-table*: Private special variables
Special Variable, *gbk-to-ucs-table*: Private special variables
Special Variable, *hyperdoc-base-uri*: Private special variables
Special Variable, *standard-optimize-settings*: Private special variables
Special Variable, *substitution-char*: Public special variables
Special Variable, *ucs-to-gbk-special-table*: Private special variables
Special Variable, *ucs-to-gbk-table*: Private special variables
Special Variable, +name-map+: Private special variables
Special Variable, +shortcut-map+: Private special variables
stream: Public classes

T
transformer: Public classes

V
vector: Public classes

Jump to:   *   +  
B   C   D   E   I   L   N   O   P   S   T   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   C   D   E   F   I   K   L   M   O   P   S   T   U   V  
Index Entry  Section

A
ascii.lisp: The flexi-streams/ascii․lisp file

C
char*: Private types
char-code-integer: Private types
Class, external-format: Private classes
Class, flexi-8-bit-format: Private classes
Class, flexi-ascii-format: Private classes
Class, flexi-cr-8-bit-format: Private classes
Class, flexi-cr-ascii-format: Private classes
Class, flexi-cr-gbk-format: Private classes
Class, flexi-cr-latin-1-format: Private classes
Class, flexi-cr-mixin: Private classes
Class, flexi-cr-utf-16-be-format: Private classes
Class, flexi-cr-utf-16-le-format: Private classes
Class, flexi-cr-utf-32-be-format: Private classes
Class, flexi-cr-utf-32-le-format: Private classes
Class, flexi-cr-utf-8-format: Private classes
Class, flexi-crlf-8-bit-format: Private classes
Class, flexi-crlf-ascii-format: Private classes
Class, flexi-crlf-gbk-format: Private classes
Class, flexi-crlf-latin-1-format: Private classes
Class, flexi-crlf-mixin: Private classes
Class, flexi-crlf-utf-16-be-format: Private classes
Class, flexi-crlf-utf-16-le-format: Private classes
Class, flexi-crlf-utf-32-be-format: Private classes
Class, flexi-crlf-utf-32-le-format: Private classes
Class, flexi-crlf-utf-8-format: Private classes
Class, flexi-gbk-format: Private classes
Class, flexi-input-stream: Public classes
Class, flexi-io-stream: Public classes
Class, flexi-latin-1-format: Private classes
Class, flexi-output-stream: Public classes
Class, flexi-stream: Public classes
Class, flexi-utf-16-be-format: Private classes
Class, flexi-utf-16-format: Private classes
Class, flexi-utf-16-le-format: Private classes
Class, flexi-utf-32-be-format: Private classes
Class, flexi-utf-32-format: Private classes
Class, flexi-utf-32-le-format: Private classes
Class, flexi-utf-8-format: Private classes
Class, in-memory-input-stream: Public classes
Class, in-memory-output-stream: Public classes
Class, in-memory-stream: Public classes
Class, list-input-stream: Private classes
Class, list-stream: Public classes
Class, vector-input-stream: Private classes
Class, vector-output-stream: Private classes
Class, vector-stream: Public classes
code-pages.lisp: The flexi-streams/code-pages․lisp file
code-point: Private types
Condition, external-format-condition: Public conditions
Condition, external-format-encoding-error: Public conditions
Condition, external-format-error: Public conditions
Condition, flexi-stream-element-type-error: Public conditions
Condition, flexi-stream-error: Public conditions
Condition, flexi-stream-out-of-sync-error: Public conditions
Condition, flexi-stream-simple-error: Private conditions
Condition, in-memory-stream-closed-error: Public conditions
Condition, in-memory-stream-error: Public conditions
Condition, in-memory-stream-position-spec-error: Public conditions
Condition, in-memory-stream-simple-error: Private conditions
conditions.lisp: The flexi-streams/conditions․lisp file

D
decode.lisp: The flexi-streams/decode․lisp file

E
enc-cn-tbl.lisp: The flexi-streams/enc-cn-tbl․lisp file
encode.lisp: The flexi-streams/encode․lisp file
external-format: Private classes
external-format-condition: Public conditions
external-format-encoding-error: Public conditions
external-format-error: Public conditions
external-format.lisp: The flexi-streams/external-format․lisp file

F
File, ascii.lisp: The flexi-streams/ascii․lisp file
File, code-pages.lisp: The flexi-streams/code-pages․lisp file
File, conditions.lisp: The flexi-streams/conditions․lisp file
File, decode.lisp: The flexi-streams/decode․lisp file
File, enc-cn-tbl.lisp: The flexi-streams/enc-cn-tbl․lisp file
File, encode.lisp: The flexi-streams/encode․lisp file
File, external-format.lisp: The flexi-streams/external-format․lisp file
File, flexi-streams.asd: The flexi-streams/flexi-streams․asd file
File, in-memory.lisp: The flexi-streams/in-memory․lisp file
File, input.lisp: The flexi-streams/input․lisp file
File, io.lisp: The flexi-streams/io․lisp file
File, iso-8859.lisp: The flexi-streams/iso-8859․lisp file
File, koi8-r.lisp: The flexi-streams/koi8-r․lisp file
File, length.lisp: The flexi-streams/length․lisp file
File, mac.lisp: The flexi-streams/mac․lisp file
File, mapping.lisp: The flexi-streams/mapping․lisp file
File, output.lisp: The flexi-streams/output․lisp file
File, packages.lisp: The flexi-streams/packages․lisp file
File, specials.lisp: The flexi-streams/specials․lisp file
File, stream.lisp: The flexi-streams/stream․lisp file
File, strings.lisp: The flexi-streams/strings․lisp file
File, util.lisp: The flexi-streams/util․lisp file
flexi-8-bit-format: Private classes
flexi-ascii-format: Private classes
flexi-cr-8-bit-format: Private classes
flexi-cr-ascii-format: Private classes
flexi-cr-gbk-format: Private classes
flexi-cr-latin-1-format: Private classes
flexi-cr-mixin: Private classes
flexi-cr-utf-16-be-format: Private classes
flexi-cr-utf-16-le-format: Private classes
flexi-cr-utf-32-be-format: Private classes
flexi-cr-utf-32-le-format: Private classes
flexi-cr-utf-8-format: Private classes
flexi-crlf-8-bit-format: Private classes
flexi-crlf-ascii-format: Private classes
flexi-crlf-gbk-format: Private classes
flexi-crlf-latin-1-format: Private classes
flexi-crlf-mixin: Private classes
flexi-crlf-utf-16-be-format: Private classes
flexi-crlf-utf-16-le-format: Private classes
flexi-crlf-utf-32-be-format: Private classes
flexi-crlf-utf-32-le-format: Private classes
flexi-crlf-utf-8-format: Private classes
flexi-gbk-format: Private classes
flexi-input-stream: Public classes
flexi-io-stream: Public classes
flexi-latin-1-format: Private classes
flexi-output-stream: Public classes
flexi-stream: Public classes
flexi-stream-element-type-error: Public conditions
flexi-stream-error: Public conditions
flexi-stream-out-of-sync-error: Public conditions
flexi-stream-simple-error: Private conditions
flexi-streams: The flexi-streams system
flexi-streams: The flexi-streams package
flexi-streams-system: The flexi-streams-system package
flexi-streams.asd: The flexi-streams/flexi-streams․asd file
flexi-utf-16-be-format: Private classes
flexi-utf-16-format: Private classes
flexi-utf-16-le-format: Private classes
flexi-utf-32-be-format: Private classes
flexi-utf-32-format: Private classes
flexi-utf-32-le-format: Private classes
flexi-utf-8-format: Private classes

I
in-memory-input-stream: Public classes
in-memory-output-stream: Public classes
in-memory-stream: Public classes
in-memory-stream-closed-error: Public conditions
in-memory-stream-error: Public conditions
in-memory-stream-position-spec-error: Public conditions
in-memory-stream-simple-error: Private conditions
in-memory.lisp: The flexi-streams/in-memory․lisp file
input.lisp: The flexi-streams/input․lisp file
io.lisp: The flexi-streams/io․lisp file
iso-8859.lisp: The flexi-streams/iso-8859․lisp file

K
koi8-r.lisp: The flexi-streams/koi8-r․lisp file

L
length.lisp: The flexi-streams/length․lisp file
list-input-stream: Private classes
list-stream: Public classes

M
mac.lisp: The flexi-streams/mac․lisp file
mapping.lisp: The flexi-streams/mapping․lisp file

O
octet: Public types
output.lisp: The flexi-streams/output․lisp file

P
Package, flexi-streams: The flexi-streams package
Package, flexi-streams-system: The flexi-streams-system package
packages.lisp: The flexi-streams/packages․lisp file

S
specials.lisp: The flexi-streams/specials․lisp file
stream.lisp: The flexi-streams/stream․lisp file
string*: Private types
strings.lisp: The flexi-streams/strings․lisp file
System, flexi-streams: The flexi-streams system

T
Type, char*: Private types
Type, char-code-integer: Private types
Type, code-point: Private types
Type, octet: Public types
Type, string*: Private types

U
util.lisp: The flexi-streams/util․lisp file

V
vector-input-stream: Private classes
vector-output-stream: Private classes
vector-stream: Public classes

Jump to:   A   C   D   E   F   I   K   L   M   O   P   S   T   U   V