The nibbles Reference Manual

4.1.1 nibbles/nibbles.asd

Source

nibbles.asd.

Parent Component

nibbles (system).

ASDF Systems

nibbles.

Packages

nibbles-system.

Public Interface

• perform (method).
• perform (method).

Internals

• css-file (class).
• nibbles-source-file (class).
• txt-file (class).

---

4.1.2 nibbles/package.lisp

Source

nibbles.asd.

Parent Component

nibbles (system).

Packages

nibbles.

---

4.1.3 nibbles/types.lisp

Dependency

package.lisp (file).

Source

nibbles.asd.

Parent Component

nibbles (system).

Public Interface

• index (type).
• make-octet-vector (function).
• octet (type).
• octet-vector (function).
• octet-vector (type).
• simple-octet-vector (type).

---

4.1.4 nibbles/macro-utils.lisp

Dependency

package.lisp (file).

Source

nibbles.asd.

Parent Component

nibbles (system).

Internals

• byte-fun-name (function).
• byte-ref-fun-name (function).
• byte-set-fun-name (function).
• float-fun-name (function).
• float-ref-fun-name (function).
• float-set-fun-name (function).
• format-docstring (function).
• internalify (function).
• ref-form (function).
• set-form (function).
• stream-float-into-seq-fun-name (function).
• stream-float-ref-fun-name (function).
• stream-float-seq-fun-name (function).
• stream-into-seq-fun-name (function).
• stream-ref-fun-name (function).
• stream-seq-fun-name (function).

---

4.1.5 nibbles/vectors.lisp

Dependencies

• types.lisp (file).
• macro-utils.lisp (file).

Source

nibbles.asd.

Parent Component

nibbles (system).

Public Interface

• (setf ieee-double-ref/be) (setf expander).
• ieee-double-ref/be (function).
• (setf ieee-double-ref/le) (setf expander).
• ieee-double-ref/le (function).
• (setf ieee-single-ref/be) (setf expander).
• ieee-single-ref/be (function).
• (setf ieee-single-ref/le) (setf expander).
• ieee-single-ref/le (function).
• (setf sb16ref/be) (setf expander).
• sb16ref/be (function).
• (setf sb16ref/le) (setf expander).
• sb16ref/le (function).
• (setf sb24ref/be) (setf expander).
• sb24ref/be (function).
• (setf sb24ref/le) (setf expander).
• sb24ref/le (function).
• (setf sb32ref/be) (setf expander).
• sb32ref/be (function).
• (setf sb32ref/le) (setf expander).
• sb32ref/le (function).
• (setf sb64ref/be) (setf expander).
• sb64ref/be (function).
• (setf sb64ref/le) (setf expander).
• sb64ref/le (function).
• (setf ub16ref/be) (setf expander).
• ub16ref/be (function).
• (setf ub16ref/le) (setf expander).
• ub16ref/le (function).
• (setf ub24ref/be) (setf expander).
• ub24ref/be (function).
• (setf ub24ref/le) (setf expander).
• ub24ref/le (function).
• (setf ub32ref/be) (setf expander).
• ub32ref/be (function).
• (setf ub32ref/le) (setf expander).
• ub32ref/le (function).
• (setf ub64ref/be) (setf expander).
• ub64ref/be (function).
• (setf ub64ref/le) (setf expander).
• ub64ref/le (function).

Internals

• array-data-and-offsets (function).
• ieee-double-set/be (function).
• ieee-double-set/le (function).
• ieee-single-set/be (function).
• ieee-single-set/le (function).
• sb16set/be (function).
• sb16set/le (function).
• sb24set/be (function).
• sb24set/le (function).
• sb32set/be (function).
• sb32set/le (function).
• sb64set/be (function).
• sb64set/le (function).
• ub16set/be (function).
• ub16set/le (function).
• ub24set/be (function).
• ub24set/le (function).
• ub32set/be (function).
• ub32set/le (function).
• ub64set/be (function).
• ub64set/le (function).

---

4.1.6 nibbles/streams.lisp

Dependency

vectors.lisp (file).

Source

nibbles.asd.

Parent Component

nibbles (system).

Public Interface

• read-ieee-double/be (function).
• read-ieee-double/be-into-sequence (function).
• read-ieee-double/be-sequence (function).
• read-ieee-double/le (function).
• read-ieee-double/le-into-sequence (function).
• read-ieee-double/le-sequence (function).
• read-ieee-single/be (function).
• read-ieee-single/be-into-sequence (function).
• read-ieee-single/be-sequence (function).
• read-ieee-single/le (function).
• read-ieee-single/le-into-sequence (function).
• read-ieee-single/le-sequence (function).
• read-sb16/be (function).
• read-sb16/be-into-sequence (function).
• read-sb16/be-sequence (function).
• read-sb16/le (function).
• read-sb16/le-into-sequence (function).
• read-sb16/le-sequence (function).
• read-sb24/be (function).
• read-sb24/be-into-sequence (function).
• read-sb24/be-sequence (function).
• read-sb24/le (function).
• read-sb24/le-into-sequence (function).
• read-sb24/le-sequence (function).
• read-sb32/be (function).
• read-sb32/be-into-sequence (function).
• read-sb32/be-sequence (function).
• read-sb32/le (function).
• read-sb32/le-into-sequence (function).
• read-sb32/le-sequence (function).
• read-sb64/be (function).
• read-sb64/be-into-sequence (function).
• read-sb64/be-sequence (function).
• read-sb64/le (function).
• read-sb64/le-into-sequence (function).
• read-sb64/le-sequence (function).
• read-ub16/be (function).
• read-ub16/be-into-sequence (function).
• read-ub16/be-sequence (function).
• read-ub16/le (function).
• read-ub16/le-into-sequence (function).
• read-ub16/le-sequence (function).
• read-ub24/be (function).
• read-ub24/be-into-sequence (function).
• read-ub24/be-sequence (function).
• read-ub24/le (function).
• read-ub24/le-into-sequence (function).
• read-ub24/le-sequence (function).
• read-ub32/be (function).
• read-ub32/be-into-sequence (function).
• read-ub32/be-sequence (function).
• read-ub32/le (function).
• read-ub32/le-into-sequence (function).
• read-ub32/le-sequence (function).
• read-ub64/be (function).
• read-ub64/be-into-sequence (function).
• read-ub64/be-sequence (function).
• read-ub64/le (function).
• read-ub64/le-into-sequence (function).
• read-ub64/le-sequence (function).
• write-ieee-double/be (function).
• write-ieee-double/be-sequence (function).
• write-ieee-double/le (function).
• write-ieee-double/le-sequence (function).
• write-ieee-single/be (function).
• write-ieee-single/be-sequence (function).
• write-ieee-single/le (function).
• write-ieee-single/le-sequence (function).
• write-sb16/be (function).
• write-sb16/be-sequence (function).
• write-sb16/le (function).
• write-sb16/le-sequence (function).
• write-sb24/be (function).
• write-sb24/be-sequence (function).
• write-sb24/le (function).
• write-sb24/le-sequence (function).
• write-sb32/be (function).
• write-sb32/be-sequence (function).
• write-sb32/le (function).
• write-sb32/le-sequence (function).
• write-sb64/be (function).
• write-sb64/be-sequence (function).
• write-sb64/le (function).
• write-sb64/le-sequence (function).
• write-ub16/be (function).
• write-ub16/be-sequence (function).
• write-ub16/le (function).
• write-ub16/le-sequence (function).
• write-ub24/be (function).
• write-ub24/be-sequence (function).
• write-ub24/le (function).
• write-ub24/le-sequence (function).
• write-ub32/be (function).
• write-ub32/be-sequence (function).
• write-ub32/le (function).
• write-ub32/le-sequence (function).
• write-ub64/be (function).
• write-ub64/be-sequence (function).
• write-ub64/le (function).
• write-ub64/le-sequence (function).

Internals

• read-byte* (function).
• read-fresh-sequence (function).
• read-into-list* (function).
• read-into-sequence (function).
• read-into-vector* (function).
• read-n-bytes-into (function).
• write-byte* (function).
• write-sequence-with-writer (function).

---

4.1.7 nibbles/sbcl-opt/fndb.lisp

Source

nibbles.asd.

Parent Component

sbcl-opt (module).

---

4.1.8 nibbles/sbcl-opt/nib-tran.lisp

Dependency

fndb.lisp (file).

Source

nibbles.asd.

Parent Component

sbcl-opt (module).

---

4.1.9 nibbles/sbcl-opt/x86-vm.lisp

If Feature

:x86

Dependency

fndb.lisp (file).

Source

nibbles.asd.

Parent Component

sbcl-opt (module).

---

4.1.10 nibbles/sbcl-opt/x86-64-vm.lisp

If Feature

:x86-64

Dependency

fndb.lisp (file).

Source

nibbles.asd.

Parent Component

sbcl-opt (module).

---

4.2.1 nibbles/doc/index.html

Source

nibbles.asd.

Parent Component

doc (module).

---

4.3.1 nibbles/doc/nibbles-doc.txt

Source

nibbles.asd.

Parent Component

doc (module).

---

4.3.2 nibbles/doc/style.css

Source

nibbles.asd.

Parent Component

doc (module).

---

4.4.1 nibbles/README.md

Source

nibbles.asd.

Parent Component

nibbles (system).

---

4.4.2 nibbles/LICENSE

Source

nibbles.asd.

Parent Component

nibbles (system).

---

4.4.3 nibbles/NEWS

Source

nibbles.asd.

Parent Component

nibbles (system).

---

6.1.1 Setf expanders

Setf Expander: (setf ieee-double-ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ieee-double-ref/be (function).

Writer

ieee-double-set/be (function).

Setf Expander: (setf ieee-double-ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ieee-double-ref/le (function).

Writer

ieee-double-set/le (function).

Setf Expander: (setf ieee-single-ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ieee-single-ref/be (function).

Writer

ieee-single-set/be (function).

Setf Expander: (setf ieee-single-ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ieee-single-ref/le (function).

Writer

ieee-single-set/le (function).

Setf Expander: (setf sb16ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb16ref/be (function).

Writer

sb16set/be (function).

Setf Expander: (setf sb16ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb16ref/le (function).

Writer

sb16set/le (function).

Setf Expander: (setf sb24ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb24ref/be (function).

Writer

sb24set/be (function).

Setf Expander: (setf sb24ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb24ref/le (function).

Writer

sb24set/le (function).

Setf Expander: (setf sb32ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb32ref/be (function).

Writer

sb32set/be (function).

Setf Expander: (setf sb32ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb32ref/le (function).

Writer

sb32set/le (function).

Setf Expander: (setf sb64ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb64ref/be (function).

Writer

sb64set/be (function).

Setf Expander: (setf sb64ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

sb64ref/le (function).

Writer

sb64set/le (function).

Setf Expander: (setf ub16ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub16ref/be (function).

Writer

ub16set/be (function).

Setf Expander: (setf ub16ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub16ref/le (function).

Writer

ub16set/le (function).

Setf Expander: (setf ub24ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub24ref/be (function).

Writer

ub24set/be (function).

Setf Expander: (setf ub24ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub24ref/le (function).

Writer

ub24set/le (function).

Setf Expander: (setf ub32ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub32ref/be (function).

Writer

ub32set/be (function).

Setf Expander: (setf ub32ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub32ref/le (function).

Writer

ub32set/le (function).

Setf Expander: (setf ub64ref/be) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub64ref/be (function).

Writer

ub64set/be (function).

Setf Expander: (setf ub64ref/le) (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Reader

ub64ref/le (function).

Writer

ub64set/le (function).

---

6.1.2 Ordinary functions

Function: ieee-double-ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ieee-double-ref/be).

Function: ieee-double-ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ieee-double-ref/le).

Function: ieee-single-ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ieee-single-ref/be).

Function: ieee-single-ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ieee-single-ref/le).

Function: make-octet-vector (count &key initial-element) ¶

Make and return an ‘octet-vector’ with COUNT elements.

If supplied, INITIAL-ELEMENT is used to populate the vector. The value of INITIAL-ELEMENT has to of type ‘octet’.

Package

nibbles.

Source

types.lisp.

Function: octet-vector (&rest args) ¶

Make and return an ‘octet-vector’ containing the elements ARGS. ARGS have to be of type ‘octet’.

Package

nibbles.

Source

types.lisp.

Function: read-ieee-double/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-double/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a DOUBLE-FLOAT read in big-endian byte order. SEQ may be either a vector or a list. STREAM must have na element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-double/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a DOUBLE-FLOAT read in big-endian byte order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-double/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-double/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a DOUBLE-FLOAT read in little-endian byte order. SEQ may be either a vector or a list. STREAM must have na element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-double/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a DOUBLE-FLOAT read in little-endian byte order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a SINGLE-FLOAT read in big-endian byte order. SEQ may be either a vector or a list. STREAM must have na element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a SINGLE-FLOAT read in big-endian byte order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a SINGLE-FLOAT read in little-endian byte order. SEQ may be either a vector or a list. STREAM must have na element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ieee-single/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a SINGLE-FLOAT read in little-endian byte order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 16-bit signed integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 16-bit signed integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 16-bit signed integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb16/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 16-bit signed integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 24-bit signed integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 24-bit signed integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 24-bit signed integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb24/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 24-bit signed integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 32-bit signed integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 32-bit signed integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 32-bit signed integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb32/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 32-bit signed integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 64-bit signed integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 64-bit signed integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 64-bit signed integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-sb64/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 64-bit signed integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 16-bit unsigned integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 16-bit unsigned integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 16-bit unsigned integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub16/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 16-bit unsigned integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 24-bit unsigned integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 24-bit unsigned integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 24-bit unsigned integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub24/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 24-bit unsigned integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 32-bit unsigned integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 32-bit unsigned integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 32-bit unsigned integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub32/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 32-bit unsigned integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/be (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/be-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 64-bit unsigned integer read in big-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/be-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 64-bit unsigned integer read in big-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/le (stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/le-into-sequence (seq stream &key start end) ¶

Destructively modify SEQ by replacing the elements of SEQ between START and END with elements read from STREAM. Each element is a 64-bit unsigned integer read in little-endian order. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: read-ub64/le-sequence (result-type stream count) ¶

Return a sequence of type RESULT-TYPE, containing COUNT elements read from STREAM. Each element is a 64-bit unsigned integer read in little-endian order. RESULT-TYPE must be either CL:VECTOR or CL:LIST. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: sb16ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb16ref/be).

Function: sb16ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb16ref/le).

Function: sb24ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb24ref/be).

Function: sb24ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb24ref/le).

Function: sb32ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb32ref/be).

Function: sb32ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb32ref/le).

Function: sb64ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb64ref/be).

Function: sb64ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf sb64ref/le).

Function: ub16ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub16ref/be).

Function: ub16ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub16ref/le).

Function: ub24ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub24ref/be).

Function: ub24ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub24ref/le).

Function: ub32ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub32ref/be).

Function: ub32ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub32ref/le).

Function: ub64ref/be (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub64ref/be).

Function: ub64ref/le (vector index) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expander for this function

(setf ub64ref/le).

Function: write-ieee-double/be (float stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-double/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as DOUBLE-FLOATs in big-endian byte order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-double/le (float stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-double/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as DOUBLE-FLOATs in little-endian byte order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-single/be (float stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-single/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as SINGLE-FLOATs in big-endian byte order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-single/le (float stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ieee-single/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as SINGLE-FLOATs in little-endian byte order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb16/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb16/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 16-bit signed integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb16/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb16/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 16-bit signed integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb24/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb24/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 24-bit signed integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb24/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb24/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 24-bit signed integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb32/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb32/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 32-bit signed integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb32/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb32/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 32-bit signed integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb64/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb64/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 64-bit signed integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-sb64/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sb64/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 64-bit signed integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub16/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub16/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 16-bit unsigned integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub16/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub16/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 16-bit unsigned integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub24/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub24/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 24-bit unsigned integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub24/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub24/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 24-bit unsigned integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub32/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub32/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 32-bit unsigned integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub32/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub32/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 32-bit unsigned integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub64/be (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub64/be-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 64-bit unsigned integers in big-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

Function: write-ub64/le (integer stream) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-ub64/le-sequence (seq stream &key start end) ¶

Write elements from SEQ between START and END as 64-bit unsigned integers in little-endian order to STREAM. SEQ may be either a vector or a list. STREAM must have an element type of (UNSIGNED-BYTE 8).

Package

nibbles.

Source

streams.lisp.

---

6.1.3 Standalone methods

Method: perform :around ((op load-op) (c nibbles-source-file)) ¶

Package

asdf/action.

Source

nibbles.asd.

Method: perform :around ((op compile-op) (c nibbles-source-file)) ¶

Package

asdf/action.

Source

nibbles.asd.

---

6.1.4 Types

Type: index () ¶

Package

nibbles.

Source

types.lisp.

Type: octet () ¶

Package

nibbles.

Source

types.lisp.

Type: octet-vector (&optional length) ¶

Package

nibbles.

Source

types.lisp.

Type: simple-octet-vector (&optional length) ¶

Package

nibbles.

Source

types.lisp.

---

6.2.1 Ordinary functions

Function: array-data-and-offsets (v start end) ¶

Like ARRAY-DISPLACEMENT, only more useful.

Package

nibbles.

Source

vectors.lisp.

Function: byte-fun-name (bitsize signedp big-endian-p desc) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: byte-ref-fun-name (bitsize signedp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: byte-set-fun-name (bitsize signedp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: float-fun-name (float-type big-endian-p desc) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: float-ref-fun-name (float-type big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: float-set-fun-name (float-type big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: format-docstring (&rest args) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: ieee-double-set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ieee-double-ref/be).

Function: ieee-double-set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ieee-double-ref/le).

Function: ieee-single-set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ieee-single-ref/be).

Function: ieee-single-set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ieee-single-ref/le).

Function: internalify (s) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: read-byte* (stream n-bytes reffer) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-fresh-sequence (result-type stream count element-type n-bytes reffer) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-into-list* (stream list start end n-bytes reffer) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-into-sequence (seq stream start end n-bytes reffer) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-into-vector* (stream vector start end n-bytes reffer) ¶

Package

nibbles.

Source

streams.lisp.

Function: read-n-bytes-into (stream n-bytes v) ¶

Package

nibbles.

Source

streams.lisp.

Function: ref-form (vector-name index-name byte-size signedp big-endian-p) ¶

Return a form that fetches a SIGNEDP BYTE-SIZE value from VECTOR-NAME, starting at INDEX-NAME. The value is stored in the vector according to BIG-ENDIAN-P.

Package

nibbles.

Source

macro-utils.lisp.

Function: sb16set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb16ref/be).

Function: sb16set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb16ref/le).

Function: sb24set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb24ref/be).

Function: sb24set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb24ref/le).

Function: sb32set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb32ref/be).

Function: sb32set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb32ref/le).

Function: sb64set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb64ref/be).

Function: sb64set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf sb64ref/le).

Function: set-form (vector-name index-name value-name byte-size big-endian-p) ¶

Return a form that stores a BYTE-SIZE VALUE-NAME into VECTOR-NAME, starting at INDEX-NAME. The value is stored in the vector according to BIG-ENDIAN-P. The form returns VALUE-NAME.

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-float-into-seq-fun-name (float-type big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-float-ref-fun-name (float-type readp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-float-seq-fun-name (float-type readp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-into-seq-fun-name (bitsize signedp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-ref-fun-name (bitsize readp signedp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: stream-seq-fun-name (bitsize readp signedp big-endian-p) ¶

Package

nibbles.

Source

macro-utils.lisp.

Function: ub16set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub16ref/be).

Function: ub16set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub16ref/le).

Function: ub24set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub24ref/be).

Function: ub24set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub24ref/le).

Function: ub32set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub32ref/be).

Function: ub32set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub32ref/le).

Function: ub64set/be (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub64ref/be).

Function: ub64set/le (vector index value) ¶

Package

nibbles.

Source

vectors.lisp.

Setf expanders to this function

(setf ub64ref/le).

Function: write-byte* (integer stream n-bytes setter) ¶

Package

nibbles.

Source

streams.lisp.

Function: write-sequence-with-writer (seq stream start end writer) ¶

Package

nibbles.

Source

streams.lisp.

---

6.2.2 Classes

Class: css-file ¶

Package

nibbles-system.

Source

nibbles.asd.

Direct superclasses

doc-file.

Direct slots

Slot: type ¶

Package

common-lisp.

Initform

"css"

Class: nibbles-source-file ¶

Package

nibbles-system.

Source

nibbles.asd.

Direct superclasses

cl-source-file.

Direct methods

• perform.
• perform.

Class: txt-file ¶

Package

nibbles-system.

Source

nibbles.asd.

Direct superclasses

doc-file.

Direct slots

Slot: type ¶

Package

common-lisp.

Initform

"txt"

---