Common Lisp Package: NIBBLES

README:

FUNCTION

Public

MAKE-OCTET-VECTOR (COUNT &KEY (INITIAL-ELEMENT 0))

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

OCTET-VECTOR (&REST ARGS)

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

READ-IEEE-DOUBLE/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-IEEE-DOUBLE/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-IEEE-SINGLE/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-IEEE-SINGLE/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB16/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB16/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB32/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB32/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB64/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-SB64/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB16/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB16/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB32/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB32/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB64/BE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

READ-UB64/LE-INTO-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

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

WRITE-IEEE-DOUBLE/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-IEEE-DOUBLE/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-IEEE-SINGLE/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-IEEE-SINGLE/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB16/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB16/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB32/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB32/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB64/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-SB64/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB16/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB16/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB32/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB32/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB64/BE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

WRITE-UB64/LE-SEQUENCE (SEQ STREAM &KEY (START 0) 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).

Undocumented

IEEE-DOUBLE-REF/BE (VECTOR INDEX)

IEEE-DOUBLE-REF/LE (VECTOR INDEX)

IEEE-SINGLE-REF/BE (VECTOR INDEX)

IEEE-SINGLE-REF/LE (VECTOR INDEX)

READ-IEEE-DOUBLE/BE (STREAM)

READ-IEEE-DOUBLE/LE (STREAM)

READ-IEEE-SINGLE/BE (STREAM)

READ-IEEE-SINGLE/LE (STREAM)

READ-SB16/BE (STREAM)

READ-SB16/LE (STREAM)

READ-SB32/BE (STREAM)

READ-SB32/LE (STREAM)

READ-SB64/BE (STREAM)

READ-SB64/LE (STREAM)

READ-UB16/BE (STREAM)

READ-UB16/LE (STREAM)

READ-UB32/BE (STREAM)

READ-UB32/LE (STREAM)

READ-UB64/BE (STREAM)

READ-UB64/LE (STREAM)

SB16REF/BE (VECTOR INDEX)

SB16REF/LE (VECTOR INDEX)

SB32REF/BE (VECTOR INDEX)

SB32REF/LE (VECTOR INDEX)

SB64REF/BE (VECTOR INDEX)

SB64REF/LE (VECTOR INDEX)

UB16REF/BE (VECTOR INDEX)

UB16REF/LE (VECTOR INDEX)

UB32REF/BE (VECTOR INDEX)

UB32REF/LE (VECTOR INDEX)

UB64REF/BE (VECTOR INDEX)

UB64REF/LE (VECTOR INDEX)

WRITE-IEEE-DOUBLE/BE (FLOAT STREAM)

WRITE-IEEE-DOUBLE/LE (FLOAT STREAM)

WRITE-IEEE-SINGLE/BE (FLOAT STREAM)

WRITE-IEEE-SINGLE/LE (FLOAT STREAM)

WRITE-SB16/BE (INTEGER STREAM)

WRITE-SB16/LE (INTEGER STREAM)

WRITE-SB32/BE (INTEGER STREAM)

WRITE-SB32/LE (INTEGER STREAM)

WRITE-SB64/BE (INTEGER STREAM)

WRITE-SB64/LE (INTEGER STREAM)

WRITE-UB16/BE (INTEGER STREAM)

WRITE-UB16/LE (INTEGER STREAM)

WRITE-UB32/BE (INTEGER STREAM)

WRITE-UB32/LE (INTEGER STREAM)

WRITE-UB64/BE (INTEGER STREAM)

WRITE-UB64/LE (INTEGER STREAM)

Private

ARRAY-DATA-AND-OFFSETS (V START END)

Like ARRAY-DISPLACEMENT, only more useful.

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.

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.

Undocumented

BYTE-FUN-NAME (BITSIZE SIGNEDP BIG-ENDIAN-P DESC)

BYTE-REF-FUN-NAME (BITSIZE SIGNEDP BIG-ENDIAN-P)

BYTE-SET-FUN-NAME (BITSIZE SIGNEDP BIG-ENDIAN-P)

FLOAT-FUN-NAME (FLOAT-TYPE BIG-ENDIAN-P DESC)

FLOAT-REF-FUN-NAME (FLOAT-TYPE BIG-ENDIAN-P)

FLOAT-SET-FUN-NAME (FLOAT-TYPE BIG-ENDIAN-P)

FORMAT-DOCSTRING (&REST ARGS)

IEEE-DOUBLE-SET/BE (VECTOR INDEX VALUE)

IEEE-DOUBLE-SET/LE (VECTOR INDEX VALUE)

IEEE-SINGLE-SET/BE (VECTOR INDEX VALUE)

IEEE-SINGLE-SET/LE (VECTOR INDEX VALUE)

INTERNALIFY (S)

NOT-SUPPORTED

READ-BYTE* (STREAM N-BYTES REFFER)

READ-FRESH-SEQUENCE (RESULT-TYPE STREAM COUNT ELEMENT-TYPE N-BYTES REFFER)

READ-INTO-LIST* (STREAM LIST START END N-BYTES REFFER)

READ-INTO-SEQUENCE (SEQ STREAM START END N-BYTES REFFER)

READ-INTO-VECTOR* (STREAM VECTOR START END N-BYTES REFFER)

READ-N-BYTES-INTO (STREAM N-BYTES V)

SB16SET/BE (VECTOR INDEX VALUE)

SB16SET/LE (VECTOR INDEX VALUE)

SB32SET/BE (VECTOR INDEX VALUE)

SB32SET/LE (VECTOR INDEX VALUE)

SB64SET/BE (VECTOR INDEX VALUE)

SB64SET/LE (VECTOR INDEX VALUE)

STREAM-FLOAT-REF-FUN-NAME (FLOAT-TYPE READP BIG-ENDIAN-P)

STREAM-FLOAT-SEQ-FUN-NAME (FLOAT-TYPE READP BIG-ENDIAN-P)

STREAM-REF-FUN-NAME (BITSIZE READP SIGNEDP BIG-ENDIAN-P)

STREAM-SEQ-FUN-NAME (BITSIZE READP SIGNEDP BIG-ENDIAN-P)

UB16SET/BE (VECTOR INDEX VALUE)

UB16SET/LE (VECTOR INDEX VALUE)

UB32SET/BE (VECTOR INDEX VALUE)

UB32SET/LE (VECTOR INDEX VALUE)

UB64SET/BE (VECTOR INDEX VALUE)

UB64SET/LE (VECTOR INDEX VALUE)

WRITE-BYTE* (INTEGER STREAM N-BYTES SETTER)

WRITE-SEQUENCE-WITH-WRITER (SEQ STREAM START END WRITER)