The qbase64 Reference Manual

Table of Contents

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

The qbase64 Reference Manual

This is the qbase64 Reference Manual, version 0.1.1, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:12:33 2018 GMT+0.


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

1 Introduction

qbase64

qbase64 provides a fast and flexible base64 encoder and decoder for Common Lisp. It provides three interfaces for both encoding and decoding:

Table of Contents

Why qbase64?

Given that a couple of Lisp libraries already exist for working with base64 - cl-base64 and s-base64 - why might you want to pick qbase64? There are two reasons:

  1. Stream-based APIs - neither of the alternatives provide a (gray) stream implementation where you can write bytes to a binary stream that is automatically encoded to an underlying character stream and vice-versa.

  2. Performance - qbase64 was written with the objective of being fast while keeping memory consumption independent of the input size. See the Performance section for benchmarks and other details.

Installation

Install using quicklisp:

(ql:quickload :qbase64)

Usage

Encoding

The examples below use ENCODE-BYTES and ENCODE-STREAM.

;;; ENCODE-BYTES
(qbase64:encode-bytes #(1 2 3 4 5 6 7 8))
=> "AQIDBAUGBwg="

;;; ENCODE-STREAM
(with-output-to-string (s)
  (with-open-stream (out (make-instance 'qbase64:encode-stream
                                        :underlying-stream s))
    (write-sequence #(1 2 3 4) out)
    (write-sequence #(5 6 7 8) out)))
=> "AQIDBAUGBwg="

Decoding

The examples below use DECODE-STRING and DECODE-STREAM.

;;; DECODE-STRING
(qbase64:decode-string "AQIDBAUGBwg=")
=> #(1 2 3 4 5 6 7 8)

;;; DECODE-STREAM
(with-input-from-string (s "AQIDBAUGBwg=")
  (with-open-stream (in (make-instance 'qbase64:decode-stream
                                       :underlying-stream s))
    (let ((bytes (make-array 4)))
      (loop
         for position = (read-sequence bytes in)
         do (print (subseq bytes 0 position))
         while (= position (length bytes))))))
; #(1 2 3 4) 
; #(5 6 7 8) 
; #() 

Advanced

Normally you wouldn't need to use ENCODER and DECODER directly, but if you do (say you want more control over memory management), you can refer to the examples below.

In these examples, fixed length sequences are used for both input and output, and any input buffered by the encoder/decoder is first cleared before further input is fed to it. This allows very tight control over how much memory gets used.

Refer to the doc strings for ENCODER, ENCODE, DECODER and DECODE for more details.

Note that running the following examples requires FLEXI-STREAMS.

;;; ENCODER
(flexi-streams:with-input-from-sequence (in #(1 2 3 4 5 6 7 8))
  (let* ((encoder (qbase64:make-encoder))
         (bytes (make-array 4))
         (string (make-string 5))
         (read-bytes t)
         (buffered nil)
         (eof nil))
    (loop
       while (or buffered (not eof))
       for end1 = (when read-bytes (read-sequence bytes in))
       if (and read-bytes (< end1 (length bytes))) do (setf eof t)
       do
         (multiple-value-bind (end2 pending)
             (if read-bytes
                 (qbase64:encode encoder bytes string :end1 end1 :finish eof)
                 (qbase64:encode encoder #() string :finish eof))
           (write-string string nil :end end2)
           (setf buffered pending
                 read-bytes (or (not pending) (zerop end2)))))))
; AQIDBAUGBwg=

;;; DECODER
(with-input-from-string (in "AQIDBAUGBwg=")
  (let* ((decoder (qbase64:make-decoder))
         (string (make-string 4))
         (bytes (make-array 5))
         (read-string t)
         (buffered nil)
         (eof nil))
    (loop
       while (or buffered (not eof))
       for end1 = (when read-string (read-sequence string in))
       if (and read-string (< end1 (length string))) do (setf eof t)
       do
         (multiple-value-bind (end2 pending)
             (if read-string
                 (qbase64:decode decoder string bytes :end1 end1)
                 (qbase64:decode decoder "" bytes))
           (print (subseq bytes 0 end2))
           (setf buffered pending
                 read-string (or (not pending) (zerop end2)))))))
; #(1 2 3)
; #(4 5 6)
; #(7 8)
; #()

Limits and Assertions

The library relies on (UNSIGNED-BYTE 8) and fixnum arithmetic to achieve good performance. Consequently,

Performance

See this page for CPU and memory benchmarks vs other CL libraries.

Encoding and decoding should be very fast under these conditions:

Additional Features

Encoding Schemes

Two base64 encoding schemes are supported: original (the default) and URI.

URI encoding scheme is useful when base64 strings are used as GET or POST values in an HTTP request.

The scheme can be set by using the :SCHEME keyword.

(qbase64:encode-bytes #(251 252 253 254 255) :scheme :original)
=> "+/z9/v8="

(qbase64:encode-bytes #(251 252 253 254 255) :scheme :uri)
=> "-_z9_v8="

Linebreaks

The encoded base64 stream can broken into multiple lines using the :LINEBREAK keyword. By default it is 0, which means that no newlines are output. Setting it to a positive integer indicates the column number at which lines should be broken.

(princ (qbase64:encode-bytes #(1 2 3 4 5 6 7 8) :linebreak 4))
; AQID
; BAUG
; Bwg=

During decoding, all whitespace (including newlines) is ignored.

API Reference

At the moment, API reference is available in the form of doc strings for all the exported symbols.

Reporting Bugs

To report a bug in the library, create a Github issue.


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

2 Systems

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


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

2.1 qbase64

Author

Chaitanya Gupta <mail@chaitanyagupta.com>

License

BSD-3-Clause

Description

Fast and flexible base64 encoder and decoder

Version

0.1.1

Dependencies
Source

qbase64.asd (file)

Components

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

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 files   [Contents][Index]

3.1.1 qbase64.asd

Location

qbase64.asd

Systems

qbase64 (system)


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

3.1.2 qbase64/package.lisp

Parent

qbase64 (system)

Location

package.lisp

Packages

qbase64


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

3.1.3 qbase64/utils.lisp

Dependency

package.lisp (file)

Parent

qbase64 (system)

Location

utils.lisp

Internal Definitions

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

3.1.4 qbase64/stream-utils.lisp

Dependency

utils.lisp (file)

Parent

qbase64 (system)

Location

stream-utils.lisp

Internal Definitions

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

3.1.5 qbase64/qbase64.lisp

Dependency

stream-utils.lisp (file)

Parent

qbase64 (system)

Location

qbase64.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 qbase64

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Constants

Constant: +max-bytes-length+

Max length of the byte array that is used as encoding input or decoding output

Package

qbase64

Source

qbase64.lisp (file)

Constant: +max-string-length+

Max length of the string that is used as encoding output or decoding input

Package

qbase64

Source

qbase64.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Functions

Function: decode DECODER STRING BYTES &key START1 END1 START2 END2

Decodes the given STRING and writes the resultant bytes to BYTES.

DECODER: The decoder

STRING: The string to decode.

BYTES: This is where the resultant bytes are written into. Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

START1, END1: Bounds for STRING

START2, END2: Bounds for BYTES

Whitespace in string is ignored. It is not necessary that the entire STRING is decoded in one go. For example,

* There may not be enough space left in BYTES,

* or the length of the string (minus whitespace chars) may not be a multiple of 4 (base64 decoding works on groups of four characters at at time).

In these cases, DECODE will decode as much of the string as it can and write the resultant bytes into BYTES. The remaining string is copied to an internal buffer by the decoder and used the next time DECODE is called. Also, the second return value (called PENDINGP, see below) is set to true.

DECODE can be given an empty STRING in which case the buffered string is decoded as much as possible.

Returns POSITION, PENDINGP.

POSITION: First index of BYTES that wasn’t updated

PENDINGP: True if not all of the STRING was decoded

Package

qbase64

Source

qbase64.lisp (file)

Function: decode-string STRING &key SCHEME

Decodes base64 chars in STRING and returns an array of (UNSIGNED-BYTE 8) elements.

STRING: The string to decode.

SCHEME: The base64 encoding scheme to use. Must be :ORIGINAL (default) or :URI.

Package

qbase64

Source

qbase64.lisp (file)

Function: encode ENCODER BYTES STRING &key START1 END1 START2 END2 FINISH

Encodes given BYTES and writes the resultant chars to STRING.

ENCODER: The encoder

BYTES: Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

STRING: The encoded characters are written into this string.

START1, END1: Bounds for BYTES

START2, END2: Bounds for STRING

FINISH: Padding characters are output if required, and no new bytes can be accepted until all the pending bytes are written out.

It is not necessary that all of BYTES are encoded in one go. For example,

* There may not be enough space left in STRING

* FINISH is not true and the cumulative length of all the bytes given till now is not a multiple of 3 (base64 encoding works on groups of three bytes).

In these cases, as much as possible BYTES are encoded and the resultant chars written into STRING, the remaining bytes are copied to an internal buffer by the encoder and used the next time DECODE is called. Also, the second value returned (called PENDINGP, see below) is set to true.

If FINISH is true but cumulative length of all the BYTES is not a multiple of 3, padding characters are written into STRING.

ENCODE can be given an empty BYTES array in which case the internal buffer is encoded as much as possible.

Returns POSITION, PENDINGP.

POSITION: First index of STRING that wasn’t updated

PENDINGP: True if not all BYTES were encoded

Package

qbase64

Source

qbase64.lisp (file)

Function: encode-bytes BYTES &key SCHEME LINEBREAK

Encode BYTES to base64 and return the string.

BYTES: Should be a single-dimentional array of (UNSIGNED-BYTE 8) elements.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

LINEBREAK: If 0 (the default), no linebreaks are written. Otherwise its value must be the max number of characters per line.

Package

qbase64

Source

qbase64.lisp (file)

Function: make-decoder &key SCHEME

Creates a DECODER.

SCHEME: The base64 encoding scheme to use. Can be :ORIGINAL or :URI

Package

qbase64

Source

qbase64.lisp (file)

Function: make-encoder &key SCHEME

Creates an ENCODER.

SCHEME: The base64 encoding scheme to use. Can be :ORIGINAL or :URI

Package

qbase64

Source

qbase64.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Structures

Structure: decoder ()

Use a DECODER to decode base64 characters to bytes. Use MAKE-DECODER to create a decoder, then decode base64 chars using DECODE.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: scheme
Readers

decoder-scheme (function)

Writers

(setf decoder-scheme) (function)

Slot: pchars
Type

simple-base-string

Initform

(make-string 0 :element-type (quote base-char))

Readers

decoder-pchars (function)

Writers

(setf decoder-pchars) (function)

Slot: pchars-end
Initform

0

Readers

decoder-pchars-end (function)

Writers

(setf decoder-pchars-end) (function)

Structure: encoder ()

Use an ENCODER to encode bytes to string. Create an encoder using MAKE-ENCODER, then start encoding bytes using ENCODE.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: scheme
Type

qbase64::scheme

Initform

:original

Readers

encoder-scheme (function)

Writers

(setf encoder-scheme) (function)

Slot: pbytes
Type

(simple-array (unsigned-byte 8))

Initform

qbase64::+empty-bytes+

Readers

encoder-pbytes (function)

Writers

(setf encoder-pbytes) (function)

Slot: pbytes-end
Type

qbase64::positive-fixnum

Initform

0

Readers

encoder-pbytes-end (function)

Writers

(setf encoder-pbytes-end) (function)

Slot: finish-p
Readers

encoder-finish-p (function)

Writers

(setf encoder-finish-p) (function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Classes

Class: decode-stream ()

A binary input stream that converts base64 chars from an underlying stream to bytes.

Create a DECODE-STREAM using MAKE-INSTANCE. The following initialization keywords are provided:

UNDERLYING-STREAM: The underlying character input stream from which base64 chars are read. Must be given.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

Note that DECODE-STREAM does not close the underlying stream when CLOSE is invoked.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses
  • trivial-gray-stream-mixin (class)
  • fundamental-binary-input-stream (class)
  • stream-mixin (class)
Direct methods
  • stream-read-byte (method)
  • stream-read-sequence (method)
  • stream-element-type (method)
  • input-stream-p (method)
  • initialize-instance (method)
Direct slots
Slot: underlying-stream
Initargs

:underlying-stream

Slot: decoder
Slot: string
Initform

qbase64::+empty-string+

Slot: buffer
Initform

(qbase64::make-byte-vector 3)

Slot: buffer-end
Initform

0

Slot: single-byte-vector
Initform

(qbase64::make-byte-vector 1)

Class: encode-stream ()

A binary output stream that converts bytes to base64 characters and writes them to an underlyihng character output stream.

Create an ENCODE-STREAM using MAKE-INSTANCE. The following initialization keywords are provided:

UNDERLYING-STREAM: The underlying character output stream to which base64 characters are written. Must be given.

SCHEME: The base64 encoding scheme to use. Must
be :ORIGINAL (default) or :URI.

LINEBREAK: If 0 (the default), no linebreaks are written. Otherwise its value must be the max number of characters per line.

Note that ENCODE-STREAM does not close the underlying stream when CLOSE is invoked.

Package

qbase64

Source

qbase64.lisp (file)

Direct superclasses
  • trivial-gray-stream-mixin (class)
  • fundamental-binary-output-stream (class)
  • stream-mixin (class)
Direct methods
  • close (method)
  • stream-finish-output (method)
  • stream-force-output (method)
  • stream-write-byte (method)
  • stream-write-sequence (method)
  • stream-element-type (method)
  • output-stream-p (method)
  • initialize-instance (method)
Direct slots
Slot: underlying-stream
Initargs

:underlying-stream

Slot: encoder
Slot: string
Initform

qbase64::+empty-string+

Slot: single-byte-vector
Initform

(qbase64::make-byte-vector 1)

Slot: linebreak
Initargs

:linebreak

Initform

0

Slot: column
Initform

0


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

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Constants

Constant: +empty-bytes+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +empty-string+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +original-reverse-set+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +original-set+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +pad-char+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +uri-reverse-set+
Package

qbase64

Source

qbase64.lisp (file)

Constant: +uri-set+
Package

qbase64

Source

qbase64.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: define-constant NAME VALUE &optional DOC
Package

qbase64

Source

utils.lisp (file)

Macro: defun/td NAME LAMBDA-LIST TYPE-DECLS-LIST &body BODY
Package

qbase64

Source

utils.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: %decode STRING BYTES &key SCHEME START1 END1 START2 END2
Package

qbase64

Source

qbase64.lisp (file)

Function: %encode BYTES STRING &key SCHEME ENCODE-TRAILING-BYTES START1 END1 START2 END2
Package

qbase64

Source

qbase64.lisp (file)

Function: %make-decoder &key (SCHEME SCHEME) (PCHARS PCHARS) (PCHARS-END PCHARS-END)
Package

qbase64

Source

qbase64.lisp (file)

Function: %make-encoder &key (SCHEME SCHEME) (PBYTES PBYTES) (PBYTES-END PBYTES-END) (FINISH-P FINISH-P)
Package

qbase64

Source

qbase64.lisp (file)

Function: %stream-write-sequence STREAM SEQUENCE START END FINISH
Package

qbase64

Source

qbase64.lisp (file)

Function: bytes &rest CONTENTS
Package

qbase64

Source

utils.lisp (file)

Function: copy-decoder INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: copy-encoder INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: decode-length LENGTH
Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-p OBJECT
Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-pchars INSTANCE
Function: (setf decoder-pchars) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-pchars-end INSTANCE
Function: (setf decoder-pchars-end) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: decoder-scheme INSTANCE
Function: (setf decoder-scheme) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: encode-length LENGTH ENCODE-TRAILING-BYTES
Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-finish-p INSTANCE
Function: (setf encoder-finish-p) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-p OBJECT
Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-pbytes INSTANCE
Function: (setf encoder-pbytes) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-pbytes-end INSTANCE
Function: (setf encoder-pbytes-end) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: encoder-scheme INSTANCE
Function: (setf encoder-scheme) VALUE INSTANCE
Package

qbase64

Source

qbase64.lisp (file)

Function: fill-pchars DECODER STRING &key START END
Package

qbase64

Source

qbase64.lisp (file)

Function: flush-pending-bytes STREAM
Package

qbase64

Source

qbase64.lisp (file)

Function: least-multiple-upfrom MULTIPLE-OF UPFROM
Package

qbase64

Source

utils.lisp (file)

Function: make-byte-vector SIZE
Package

qbase64

Source

utils.lisp (file)

Function: parse-body BODY &key DOCUMENTATION WHOLE

Parses BODY into (values remaining-forms declarations doc-string). Documentation strings are recognized only if DOCUMENTATION is true. Syntax errors in body are signalled and WHOLE is used in the signal arguments when given.

Package

qbase64

Source

utils.lisp (file)

Function: resize-pchars PCHARS PCHARS-END NEW-LENGTH
Package

qbase64

Source

qbase64.lisp (file)

Function: reverse-set SET
Package

qbase64

Source

qbase64.lisp (file)

Function: whitespace-p C

Returns T for a whitespace character.

Package

qbase64

Source

qbase64.lisp (file)

Function: write-buffer-to-sequence STREAM SEQUENCE START END
Package

qbase64

Source

qbase64.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: stream-open-p OBJECT
Generic Function: (setf stream-open-p) NEW-VALUE OBJECT
Package

qbase64

Methods
Method: stream-open-p (STREAM-MIXIN stream-mixin)

automatically generated reader method

Source

stream-utils.lisp (file)

Method: (setf stream-open-p) NEW-VALUE (STREAM-MIXIN stream-mixin)

automatically generated writer method

Source

stream-utils.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Classes

Class: stream-mixin ()
Package

qbase64

Source

stream-utils.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • output-stream-p (method)
  • input-stream-p (method)
  • close (method)
  • open-stream-p (method)
  • stream-open-p (method)
  • stream-open-p (method)
Direct slots
Slot: openp
Initform

t

Readers

stream-open-p (generic function)

Writers

(setf stream-open-p) (generic function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Types

Type: positive-fixnum ()
Package

qbase64

Source

utils.lisp (file)

Type: scheme ()
Package

qbase64

Source

qbase64.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   Q  
Index Entry  Section

F
File, Lisp, qbase64.asd: The qbase64<dot>asd file
File, Lisp, qbase64/package.lisp: The qbase64/package<dot>lisp file
File, Lisp, qbase64/qbase64.lisp: The qbase64/qbase64<dot>lisp file
File, Lisp, qbase64/stream-utils.lisp: The qbase64/stream-utils<dot>lisp file
File, Lisp, qbase64/utils.lisp: The qbase64/utils<dot>lisp file

L
Lisp File, qbase64.asd: The qbase64<dot>asd file
Lisp File, qbase64/package.lisp: The qbase64/package<dot>lisp file
Lisp File, qbase64/qbase64.lisp: The qbase64/qbase64<dot>lisp file
Lisp File, qbase64/stream-utils.lisp: The qbase64/stream-utils<dot>lisp file
Lisp File, qbase64/utils.lisp: The qbase64/utils<dot>lisp file

Q
qbase64.asd: The qbase64<dot>asd file
qbase64/package.lisp: The qbase64/package<dot>lisp file
qbase64/qbase64.lisp: The qbase64/qbase64<dot>lisp file
qbase64/stream-utils.lisp: The qbase64/stream-utils<dot>lisp file
qbase64/utils.lisp: The qbase64/utils<dot>lisp file

Jump to:   F   L   Q  

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

A.2 Functions

Jump to:   %   (  
B   C   D   E   F   G   L   M   P   R   S   W  
Index Entry  Section

%
%decode: Internal functions
%encode: Internal functions
%make-decoder: Internal functions
%make-encoder: Internal functions
%stream-write-sequence: Internal functions

(
(setf decoder-pchars): Internal functions
(setf decoder-pchars-end): Internal functions
(setf decoder-scheme): Internal functions
(setf encoder-finish-p): Internal functions
(setf encoder-pbytes): Internal functions
(setf encoder-pbytes-end): Internal functions
(setf encoder-scheme): Internal functions
(setf stream-open-p): Internal generic functions
(setf stream-open-p): Internal generic functions

B
bytes: Internal functions

C
copy-decoder: Internal functions
copy-encoder: Internal functions

D
decode: Exported functions
decode-length: Internal functions
decode-string: Exported functions
decoder-p: Internal functions
decoder-pchars: Internal functions
decoder-pchars-end: Internal functions
decoder-scheme: Internal functions
define-constant: Internal macros
defun/td: Internal macros

E
encode: Exported functions
encode-bytes: Exported functions
encode-length: Internal functions
encoder-finish-p: Internal functions
encoder-p: Internal functions
encoder-pbytes: Internal functions
encoder-pbytes-end: Internal functions
encoder-scheme: Internal functions

F
fill-pchars: Internal functions
flush-pending-bytes: Internal functions
Function, %decode: Internal functions
Function, %encode: Internal functions
Function, %make-decoder: Internal functions
Function, %make-encoder: Internal functions
Function, %stream-write-sequence: Internal functions
Function, (setf decoder-pchars): Internal functions
Function, (setf decoder-pchars-end): Internal functions
Function, (setf decoder-scheme): Internal functions
Function, (setf encoder-finish-p): Internal functions
Function, (setf encoder-pbytes): Internal functions
Function, (setf encoder-pbytes-end): Internal functions
Function, (setf encoder-scheme): Internal functions
Function, bytes: Internal functions
Function, copy-decoder: Internal functions
Function, copy-encoder: Internal functions
Function, decode: Exported functions
Function, decode-length: Internal functions
Function, decode-string: Exported functions
Function, decoder-p: Internal functions
Function, decoder-pchars: Internal functions
Function, decoder-pchars-end: Internal functions
Function, decoder-scheme: Internal functions
Function, encode: Exported functions
Function, encode-bytes: Exported functions
Function, encode-length: Internal functions
Function, encoder-finish-p: Internal functions
Function, encoder-p: Internal functions
Function, encoder-pbytes: Internal functions
Function, encoder-pbytes-end: Internal functions
Function, encoder-scheme: Internal functions
Function, fill-pchars: Internal functions
Function, flush-pending-bytes: Internal functions
Function, least-multiple-upfrom: Internal functions
Function, make-byte-vector: Internal functions
Function, make-decoder: Exported functions
Function, make-encoder: Exported functions
Function, parse-body: Internal functions
Function, resize-pchars: Internal functions
Function, reverse-set: Internal functions
Function, whitespace-p: Internal functions
Function, write-buffer-to-sequence: Internal functions

G
Generic Function, (setf stream-open-p): Internal generic functions
Generic Function, stream-open-p: Internal generic functions

L
least-multiple-upfrom: Internal functions

M
Macro, define-constant: Internal macros
Macro, defun/td: Internal macros
make-byte-vector: Internal functions
make-decoder: Exported functions
make-encoder: Exported functions
Method, (setf stream-open-p): Internal generic functions
Method, stream-open-p: Internal generic functions

P
parse-body: Internal functions

R
resize-pchars: Internal functions
reverse-set: Internal functions

S
stream-open-p: Internal generic functions
stream-open-p: Internal generic functions

W
whitespace-p: Internal functions
write-buffer-to-sequence: Internal functions

Jump to:   %   (  
B   C   D   E   F   G   L   M   P   R   S   W  

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

A.3 Variables

Jump to:   +  
B   C   D   E   F   L   O   P   S   U  
Index Entry  Section

+
+empty-bytes+: Internal constants
+empty-string+: Internal constants
+max-bytes-length+: Exported constants
+max-string-length+: Exported constants
+original-reverse-set+: Internal constants
+original-set+: Internal constants
+pad-char+: Internal constants
+uri-reverse-set+: Internal constants
+uri-set+: Internal constants

B
buffer: Exported classes
buffer-end: Exported classes

C
column: Exported classes
Constant, +empty-bytes+: Internal constants
Constant, +empty-string+: Internal constants
Constant, +max-bytes-length+: Exported constants
Constant, +max-string-length+: Exported constants
Constant, +original-reverse-set+: Internal constants
Constant, +original-set+: Internal constants
Constant, +pad-char+: Internal constants
Constant, +uri-reverse-set+: Internal constants
Constant, +uri-set+: Internal constants

D
decoder: Exported classes

E
encoder: Exported classes

F
finish-p: Exported structures

L
linebreak: Exported classes

O
openp: Internal classes

P
pbytes: Exported structures
pbytes-end: Exported structures
pchars: Exported structures
pchars-end: Exported structures

S
scheme: Exported structures
scheme: Exported structures
single-byte-vector: Exported classes
single-byte-vector: Exported classes
Slot, buffer: Exported classes
Slot, buffer-end: Exported classes
Slot, column: Exported classes
Slot, decoder: Exported classes
Slot, encoder: Exported classes
Slot, finish-p: Exported structures
Slot, linebreak: Exported classes
Slot, openp: Internal classes
Slot, pbytes: Exported structures
Slot, pbytes-end: Exported structures
Slot, pchars: Exported structures
Slot, pchars-end: Exported structures
Slot, scheme: Exported structures
Slot, scheme: Exported structures
Slot, single-byte-vector: Exported classes
Slot, single-byte-vector: Exported classes
Slot, string: Exported classes
Slot, string: Exported classes
Slot, underlying-stream: Exported classes
Slot, underlying-stream: Exported classes
string: Exported classes
string: Exported classes

U
underlying-stream: Exported classes
underlying-stream: Exported classes

Jump to:   +  
B   C   D   E   F   L   O   P   S   U  

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

A.4 Data types

Jump to:   C   D   E   P   Q   S   T  
Index Entry  Section

C
Class, decode-stream: Exported classes
Class, encode-stream: Exported classes
Class, stream-mixin: Internal classes

D
decode-stream: Exported classes
decoder: Exported structures

E
encode-stream: Exported classes
encoder: Exported structures

P
Package, qbase64: The qbase64 package
positive-fixnum: Internal types

Q
qbase64: The qbase64 system
qbase64: The qbase64 package

S
scheme: Internal types
stream-mixin: Internal classes
Structure, decoder: Exported structures
Structure, encoder: Exported structures
System, qbase64: The qbase64 system

T
Type, positive-fixnum: Internal types
Type, scheme: Internal types

Jump to:   C   D   E   P   Q   S   T