Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-rfc4251 Reference Manual, version 0.1.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 15:15:10 2021 GMT+0.
| • Introduction | What cl-rfc4251 is all about | |
| • Systems | The systems documentation | |
| • Modules | The modules documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
cl-rfc4251 is a Common Lisp system, which provides support for
parsing RFC 4251 encoded binary
data, as described in the Data Type Representations Used in the SSH
Protocols section of
the document.
Clone the cl-rfc4251 repo in your Quicklisp local-projects directory.
git clone https://github.com/dnaeon/cl-rfc4251.git
Load the system.
CL-USER> (ql:quickload :cl-rfc4251)
The following table summarizes the supported data types, that can be
decoded or encoded by the respective RFC4251:DECODE and
RFC4251:ENCODE generic functions. The RFC 4251 and cl-rfc4251 type columns specify the mapping between the RFC-defined data type
name and the keywords used to decode or encode a given value in Common
Lisp.
| RFC 4251 | cl-rfc4251 type | Description |
|-------------|-----------------|--------------------------------------------------|
| byte | :byte | An arbitrary 8-bit value (octet) |
| byte[n] | :raw-bytes | A sequence of raw bytes up to a given length |
| boolean | :boolean | A boolean value |
| uint32 | :uint32 | Unsigned 32-bit integer in big-endian byte order |
| uint64 | :uint64 | Unsigned 64-bit integer in big-endian byte order |
| string | :string | Arbitrary length string |
| mpint | :mpint | Multiple precision integer |
| name-list | :name-list | A string of comma-separated names |
In addition to the above data types the cl-rfc4251 system supports
encoding and decoding of these types as well. Note, that these are not
mentioned in RFC 4251.
| cl-rfc4251 type | Description |
|-----------------|-------------------------------------------------------|
| :uint16-be | Unsigned 16-bit integer in big-endian byte order |
| :uint16-le | Unsigned 16-bit integer in little-endian byte order |
| :uint32-le | Unsigned 32-bit integer in little-endian byte order |
| :uint64-le | Unsigned 64-bit integer in little-endian byte order |
| :c-string | NULL-terminated C string |
| :buffer | A buffer similar to :string, but contains raw bytes |
The following section provides various examples showing how to encode
and decode values using the cl-rfc4251 system.
For additional examples, make sure to check the test suite.
The cl-rfc4251 system exports the generic functions DECODE and
ENCODE via the CL-RFC4251 (also available via its nickname
RFC4251) package.
The RFC4251:DECODE function takes a type and a binary stream
from which to decode. Some types also take additional keyword
parameters (e.g. :raw-bytes), which allow to specify the number of
bytes to be decoded.
In all of the examples that follow below s represents a binary
stream. You can also use the RFC4251:MAKE-BINARY-INPUT-STREAM
function to create a binary stream, which uses a vector for the
underlying data.
RFC4251:DECODE returns multiple values -- the actual decoded value,
and the number of bytes that were read from the binary stream in order
to produce the value.
Decode raw bytes with a given length from the binary stream s.
CL-USER> (rfc4251:decode :raw-bytes s :length 4)
#(0 0 0 8)
4
The second value in above example indicates the actual bytes that were read from the binary stream.
This example decodes a 16-bit unsigned integer represented in
big-endian byte order from a given binary stream s.
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(0 #x80))))
(rfc4251:decode :uint16 s))
128
2
The following example decodes a multiple precision integer represented
in two's complement format from the binary stream s.
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(#x00 #x00 #x00 #x05 #xFF #x21 #x52 #x41 #x11))))
(rfc4251:decode :mpint s))
-3735928559
9
The second value in the example above, which specifies the number of
bytes being read is 9, because we had to read one uint32 value
(the header) and additional 5 bytes (the value partition).
A bytes buffer is similar to a :string, except that the bytes are
not explicitely converted to a string value, but instead the result
contains the raw bytes.
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(#x00 #x00 #x00 #x04 #x0A #x0B #x0C #x0D))))
(rfc4251:decode :buffer s))
#(10 11 12 13)
8
The RFC4251:ENCODE generic function is used to encode data. The
function returns the total number of bytes written to the binary
stream.
You can also use the RFC4251:MAKE-BINARY-OUTPUT-STREAM function to
create a binary stream, if needed.
The following example encodes an unsigned 16-bit integer value.
CL-USER> (defparameter *s* (rfc4251:make-binary-output-stream))
*S*
CL-USER> (rfc4251:encode :uint16 42 *s*)
2
CL-USER> (rfc4251:binary-output-stream-data *s*)
#(0 42)
Note in the second expression the number of bytes that were written.
Above example, can be written this way as well, if you only care about the actual encoded bytes.
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :uint16 42 s) ;; <- Encode the value into the stream
(rfc4251:binary-output-stream-data s)) ;; <- Return the contents of the stream
#(0 42)
The following example encodes a string value.
CL-USER> (defparameter *s* (rfc4251:make-binary-output-stream))
*S*
CL-USER> (rfc4251:encode :string "Hello, World!" *s*)
17
CL-USER> (rfc4251:binary-output-stream-data *s*)
#(0 0 0 13 72 101 108 108 111 44 32 87 111 114 108 100 33)
The result from the second expression here is 17, which includes the
4 (uint32) bytes required for the header (representing the bytes that follow),
plus the additional 13 bytes representing the actual string data.
The following examples show how to encode mpint values according to
RFC 4251.
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x00 s) ;; <- Encode the zero value
(rfc4251:binary-output-stream-data s)) ;; <- Get the encoded data
#(0 0 0 0)
Here are a few more examples taken directly from the examples described in RFC 4251.
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x-DEADBEEF s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 5 255 33 82 65 17)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x80 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 2 0 128)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x9A378F9B2E332A7 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 8 9 163 120 249 178 227 50 167)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x-1234 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 2 237 204)
Encoding a bytes buffer. A bytes buffer is preceeded by its length,
similar to the way :string values are being encoded.
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :buffer #(#x0A #x0B #x0C #x0D) s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 4 10 11 12 13)
Tests are provided as part of the cl-rfc4251.test system.
In order to run the tests you can evaluate the following expressions.
CL-USER> (ql:quickload :cl-rfc4251.test)
CL-USER> (asdf:test-system :cl-rfc4251.test)
Or you can run the tests in a Docker container instead.
First, build the Docker image.
docker build -t cl-rfc4251 .
Run the tests.
docker run --rm cl-rfc4251
cl-rfc4251 is hosted on
Github. Please contribute by
reporting issues, suggesting features or by sending patches using pull
requests.
This project is Open Source and licensed under the BSD License.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cl-rfc4251 system |
cl-rfc4251
Marin Atanasov Nikolov <dnaeon@gmail.com>
Marin Atanasov Nikolov <dnaeon@gmail.com>
BSD 2-Clause
Common Lisp library for encoding and decoding data in RFC 4251 compliant format
## cl-rfc4251
‘cl-rfc4251‘ is a Common Lisp system, which provides support for
parsing [RFC 4251][RFC 4251] encoded binary
data, as described in the [Data Type Representations Used in the SSH
Protocols](https://tools.ietf.org/html/rfc4251#section-5) section of
the document.
## Requirements
* [Quicklisp][Quicklisp]
## Installation
Clone the [cl-rfc4251][cl-rfc4251] repo in
your [Quicklisp local-projects
directory][Quicklisp FAQ].
“‘ shell
git clone https://github.com/dnaeon/cl-rfc4251.git
“‘
Load the system.
“‘ shell
CL-USER> (ql:quickload :cl-rfc4251)
“‘
## Supported Data Types
The following table summarizes the supported data types, that can be
decoded or encoded by the respective ‘RFC4251:DECODE‘ and
‘RFC4251:ENCODE‘ generic functions. The ‘RFC 4251‘ and ‘cl-rfc4251
type‘ columns specify the mapping between the RFC-defined data type
name and the keywords used to decode or encode a given value in Common
Lisp.
| RFC 4251 | cl-rfc4251 type | Description |
|————-|—————–|————————————————–|
| ‘byte‘ | ‘:byte‘ | An arbitrary 8-bit value (octet) |
| ‘byte[n]‘ | ‘:raw-bytes‘ | A sequence of raw bytes up to a given length |
| ‘boolean‘ | ‘:boolean‘ | A boolean value |
| ‘uint32‘ | ‘:uint32‘ | Unsigned 32-bit integer in big-endian byte order |
| ‘uint64‘ | ‘:uint64‘ | Unsigned 64-bit integer in big-endian byte order |
| ‘string‘ | ‘:string‘ | Arbitrary length string |
| ‘mpint‘ | ‘:mpint‘ | Multiple precision integer |
| ‘name-list‘ | ‘:name-list‘ | A string of comma-separated names |
In addition to the above data types the ‘cl-rfc4251‘ system supports
encoding and decoding of these types as well. Note, that these are not
mentioned in RFC 4251.
| cl-rfc4251 type | Description |
|—————–|——————————————————-|
| ‘:uint16-be‘ | Unsigned 16-bit integer in big-endian byte order |
| ‘:uint16-le‘ | Unsigned 16-bit integer in little-endian byte order |
| ‘:uint32-le‘ | Unsigned 32-bit integer in little-endian byte order |
| ‘:uint64-le‘ | Unsigned 64-bit integer in little-endian byte order |
| ‘:c-string‘ | NULL-terminated C string |
| ‘:buffer‘ | A buffer similar to ‘:string‘, but contains raw bytes |
## Usage
The following section provides various examples showing how to encode
and decode values using the ‘cl-rfc4251‘ system.
For additional examples, make sure to check the [test
suite](./t/test-suite.lisp).
### Decoding
The ‘cl-rfc4251‘ system exports the generic functions ‘DECODE‘ and
‘ENCODE‘ via the ‘CL-RFC4251‘ (also available via its nickname
‘RFC4251‘) package.
The ‘RFC4251:DECODE‘ function takes a *type* and a *binary stream*
from which to decode. Some types also take additional keyword
parameters (e.g. ‘:raw-bytes‘), which allow to specify the number of
bytes to be decoded.
In all of the examples that follow below ‘s‘ represents a binary
stream. You can also use the ‘RFC4251:MAKE-BINARY-INPUT-STREAM‘
function to create a binary stream, which uses a vector for the
underlying data.
‘RFC4251:DECODE‘ returns multiple values – the actual decoded value,
and the number of bytes that were read from the binary stream in order
to produce the value.
Decode raw bytes with a given length from the binary stream ‘s‘.
“‘ common-lisp
CL-USER> (rfc4251:decode :raw-bytes s :length 4)
#(0 0 0 8)
4
“‘
The second value in above example indicates the actual bytes that were
read from the binary stream.
This example decodes a 16-bit unsigned integer represented in
big-endian byte order from a given binary stream ‘s‘.
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(0 #x80))))
(rfc4251:decode :uint16 s))
128
2
“‘
The following example decodes a multiple precision integer represented
in two’s complement format from the binary stream ‘s‘.
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(#x00 #x00 #x00 #x05 #xFF #x21 #x52 #x41 #x11))))
(rfc4251:decode :mpint s))
-3735928559
9
“‘
The second value in the example above, which specifies the number of
bytes being read is ‘9‘, because we had to read one ‘uint32‘ value
(the header) and additional ‘5‘ bytes (the value partition).
A bytes buffer is similar to a ‘:string‘, except that the bytes are
not explicitely converted to a string value, but instead the result
contains the raw bytes.
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-input-stream #(#x00 #x00 #x00 #x04 #x0A #x0B #x0C #x0D))))
(rfc4251:decode :buffer s))
#(10 11 12 13)
8
“‘
### Encoding
The ‘RFC4251:ENCODE‘ generic function is used to encode data. The
function returns the total number of bytes written to the binary
stream.
You can also use the ‘RFC4251:MAKE-BINARY-OUTPUT-STREAM‘ function to
create a binary stream, if needed.
The following example encodes an unsigned 16-bit integer value.
“‘ common-lisp
CL-USER> (defparameter *s* (rfc4251:make-binary-output-stream))
*S*
CL-USER> (rfc4251:encode :uint16 42 *s*)
2
CL-USER> (rfc4251:binary-output-stream-data *s*)
#(0 42)
“‘
Note in the second expression the number of bytes that were written.
Above example, can be written this way as well, if you only care about
the actual encoded bytes.
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :uint16 42 s) ;; <- Encode the value into the stream
(rfc4251:binary-output-stream-data s)) ;; <- Return the contents of the stream
#(0 42)
“‘
The following example encodes a string value.
“‘ common-lisp
CL-USER> (defparameter *s* (rfc4251:make-binary-output-stream))
*S*
CL-USER> (rfc4251:encode :string "Hello, World!" *s*)
17
CL-USER> (rfc4251:binary-output-stream-data *s*)
#(0 0 0 13 72 101 108 108 111 44 32 87 111 114 108 100 33)
“‘
The result from the second expression here is ‘17‘, which includes the
‘4‘ (uint32) bytes required for the header (representing the bytes that follow),
plus the additional ‘13‘ bytes representing the actual string data.
The following examples show how to encode ‘mpint‘ values according to
[RFC 4251][RFC 4251].
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x00 s) ;; <- Encode the zero value
(rfc4251:binary-output-stream-data s)) ;; <- Get the encoded data
#(0 0 0 0)
“‘
Here are a few more examples taken directly from the examples described in
[RFC 4251][RFC 4251].
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x-DEADBEEF s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 5 255 33 82 65 17)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x80 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 2 0 128)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x9A378F9B2E332A7 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 8 9 163 120 249 178 227 50 167)
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :mpint #x-1234 s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 2 237 204)
“‘
Encoding a bytes buffer. A bytes buffer is preceeded by its length,
similar to the way ‘:string‘ values are being encoded.
“‘ common-lisp
CL-USER> (let ((s (rfc4251:make-binary-output-stream)))
(rfc4251:encode :buffer #(#x0A #x0B #x0C #x0D) s)
(rfc4251:binary-output-stream-data s))
#(0 0 0 4 10 11 12 13)
“‘
## Tests
Tests are provided as part of the ‘cl-rfc4251.test‘ system.
In order to run the tests you can evaluate the following expressions.
“‘ common-lisp
CL-USER> (ql:quickload :cl-rfc4251.test)
CL-USER> (asdf:test-system :cl-rfc4251.test)
“‘
Or you can run the tests in a Docker container instead.
First, build the Docker image.
“‘ shell
docker build -t cl-rfc4251 .
“‘
Run the tests.
“‘ shell
docker run –rm cl-rfc4251
“‘
## Contributing
‘cl-rfc4251‘ is hosted on
[Github](https://github.com/dnaeon/cl-rfc4251). Please contribute by
reporting issues, suggesting features or by sending patches using pull
requests.
## Authors
* Marin Atanasov Nikolov (dnaeon@gmail.com)
## License
This project is Open Source and licensed under the [BSD
License](http://opensource.org/licenses/BSD-2-Clause).
[RFC 4251]: https://tools.ietf.org/html/rfc4251
[Quicklisp]: https://www.quicklisp.org/beta/
[Quicklisp FAQ]: https://www.quicklisp.org/beta/faq.html
[cl-rfc4251]: https://github.com/dnaeon/cl-rfc4251
0.1.0
cl-rfc4251.asd (file)
Modules are listed depth-first from the system components tree.
| • The cl-rfc4251/util module | ||
| • The cl-rfc4251/core module | ||
| • The cl-rfc4251/client-package module |
Next: The cl-rfc4251/core module, Previous: Modules, Up: Modules [Contents][Index]
cl-rfc4251 (system)
src/
util.lisp (file)
Next: The cl-rfc4251/client-package module, Previous: The cl-rfc4251/util module, Up: Modules [Contents][Index]
util (module)
cl-rfc4251 (system)
src/
Previous: The cl-rfc4251/core module, Up: Modules [Contents][Index]
core (module)
cl-rfc4251 (system)
src/
package.lisp (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The cl-rfc4251/util/util․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-rfc4251.asd
cl-rfc4251 (system)
Next: The cl-rfc4251/core/decoder․lisp file, Previous: The cl-rfc4251․asd file, Up: Lisp files [Contents][Index]
util (module)
src/util.lisp
Next: The cl-rfc4251/core/encoder․lisp file, Previous: The cl-rfc4251/util/util․lisp file, Up: Lisp files [Contents][Index]
core (module)
src/decoder.lisp
Next: The cl-rfc4251/core/stream․lisp file, Previous: The cl-rfc4251/core/decoder․lisp file, Up: Lisp files [Contents][Index]
core (module)
src/encoder.lisp
Next: The cl-rfc4251/client-package/package․lisp file, Previous: The cl-rfc4251/core/encoder․lisp file, Up: Lisp files [Contents][Index]
core (module)
src/stream.lisp
Previous: The cl-rfc4251/core/stream․lisp file, Up: Lisp files [Contents][Index]
client-package (module)
src/package.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The cl-rfc4251-system package | ||
| • The cl-rfc4251.util package | ||
| • The cl-rfc4251.decoder package | ||
| • The cl-rfc4251.encoder package | ||
| • The cl-rfc4251.stream package | ||
| • The cl-rfc4251 package |
Next: The cl-rfc4251․util package, Previous: Packages, Up: Packages [Contents][Index]
cl-rfc4251.asd
Next: The cl-rfc4251․decoder package, Previous: The cl-rfc4251-system package, Up: Packages [Contents][Index]
util.lisp (file)
rfc4251.util
common-lisp
Next: The cl-rfc4251․encoder package, Previous: The cl-rfc4251․util package, Up: Packages [Contents][Index]
decoder.lisp (file)
rfc4251.decoder
common-lisp
Next: The cl-rfc4251․stream package, Previous: The cl-rfc4251․decoder package, Up: Packages [Contents][Index]
encoder.lisp (file)
rfc4251.encoder
common-lisp
Next: The cl-rfc4251 package, Previous: The cl-rfc4251․encoder package, Up: Packages [Contents][Index]
stream.lisp (file)
rfc4251.stream
common-lisp
Previous: The cl-rfc4251․stream package, Up: Packages [Contents][Index]
package.lisp (file)
rfc4251
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions |
Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported classes |
Next: Exported generic functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Decode a vector of bytes into an integer, using big-endian byte order
util.lisp (file)
Decode a vector of bytes into integer, using litte-endian byte order
util.lisp (file)
Encode the given value as bytes in big-endian byte order
util.lisp (file)
Convert an integer value to a vector of bytes in little-endian byte order
util.lisp (file)
Creates a new instance of BINARY-INPUT-STREAM class
stream.lisp (file)
Creates a new instance of BINARY-OUTPUT-STREAM
stream.lisp (file)
Returns the two’s complement of the given number
util.lisp (file)
Next: Exported classes, Previous: Exported functions, Up: Exported definitions [Contents][Index]
A vector providing the underlying data
stream.lisp (file)
End marker up to which bytes are to be read
stream.lisp (file)
Current index position in the data
stream.lisp (file)
The underlying vector to which data is written
stream.lisp (file)
Decode a value with the given type from the binary
stream. Returns multiple values – the decoded value and the number of
bytes that were actually read to produce the value.
decoder.lisp (file)
Decode a bytes buffer from the given stream
Decode a NULL-terminated C string from the given stream
Decode a comma-separated list of names from the given binary stream
Decode a multiple precision integer in two’s complement format
Decode a string value from the given binary stream
Synonym for :uint64-be
Decode 64-bit unsigned integer using little-endian byte order
Decode 64-bit unsigned integer using big-endian byte order
Synonym for :uint32-be
Decode 32-bit unsigned integer using little-endian byte order
Decode 32-bit unsigned integer using big-endian byte order
Synonym for :uint16-be
Decode 16-bit unsigned integer using little-endian byte order
Decode 16-bit unsigned integer using big-endian byte order
Decode a boolean value from the given binary stream
Decode a single byte (octet) from the given binary stream
Read up to the given length of raw bytes from the stream
Encodes the value of the given type into the binary stream. Returns the number of bytes that were written to the stream.
encoder.lisp (file)
Encode a bytes buffer into the given stream
Encode a NULL-terminated C string into the binary stream
Encode a list of strings into the binary stream
Encode the given multiple precision integer value into the binary stream
Encode a string value into the given binary stream
Synonym for :uint64-be
Encode an unsigned 64-bit integer in little-endian byte order
Encode an unsigned 64-bit integer in big-endian byte order
Synonym for :uint32-be
Encode an unsigned 32-bit integer in little-endian byte order
Encode an unsigned 32-bit integer in big-endian byte order
Synonym for :uint16-be
Encode an unsigned 16-bit integer in little-endian byte order
Encode an unsigned 16-bit integer in big-endian byte order
Encodes a raw byte into the given binary stream
Returns the underlying bytes for a binary stream
stream.lisp (file)
Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
Binary input stream class using a vector as the underlying data
stream.lisp (file)
fundamental-binary-input-stream (class)
A vector providing the underlying data
:data
(error "must provide vector data")
binary-input-stream-data (generic function)
Current index position in the data
:index
0
binary-input-stream-index (generic function)
End marker up to which bytes are to be read
:end
binary-input-stream-end (generic function)
Binary output stream class using a vector for the underlying data
stream.lisp (file)
fundamental-binary-output-stream (class)
The underlying vector to which data is written
:data
(make-array 0 :element-type (quote (unsigned-byte 8)) :adjustable t :fill-pointer 0)
binary-output-stream-data (generic function)
(setf binary-output-stream-data) (generic function)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C F L M |
|---|
| Jump to: | C F L M |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
B D E F G M T |
|---|
| Jump to: | (
B D E F G M T |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | D E I S |
|---|
| Index Entry | Section | ||
|---|---|---|---|
| | |||
| D | |||
data: | Exported classes | ||
data: | Exported classes | ||
| | |||
| E | |||
end: | Exported classes | ||
| | |||
| I | |||
index: | Exported classes | ||
| | |||
| S | |||
Slot, data: | Exported classes | ||
Slot, data: | Exported classes | ||
Slot, end: | Exported classes | ||
Slot, index: | Exported classes | ||
| | |||
| Jump to: | D E I S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | B C P S |
|---|
| Jump to: | B C P S |
|---|