The clop Reference Manual

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

The clop Reference Manual

This is the clop Reference Manual, version 0.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 04:25:01 2022 GMT+0.

Table of Contents


1 Introduction

* CLOP - Common Lisp tOml Parser

** Overview

[[https://toml.io][Tom's Obvious Minimal Language (TOML)]] is a human friendly configuration file format. This library implements a parser (decoder) for it.

Clop strictly follows TOML 1.0 specification and is fully compatible with it. It passes all 296 tests defined in [[https://github.com/BurntSushi/toml-test][BurntSushi/toml-test]].

It is implemented by utilizing [[https://github.com/scymtym/esrap][ESRAP]], which is a really awesome library.

** Installation

Once it gets into Quicklisp, you can load it by:

#+BEGIN_SRC lisp
  ;; Load it.
  (ql:quickload "clop")
  
  ;; Run some basic tests.
  (asdf:test-system "clop")
#+END_SRC

If you want to run comprehensive tests, you need to first clone [[https://github.com/BurntSushi/toml-test][toml-test]] and set it up locally.

Use the following command to test it:

#+BEGIN_SRC sh
  cd /path/to/clop/roswell
  ros build decoder.ros
  
  /path/to/toml-test/toml-test ./decoder
#+END_SRC

You should now see a line of:

#+BEGIN_SRC text
  toml-test [/path/to/clop/roswell/decoder]: using embedded tests: 296 passed,  0 failed
#+END_SRC


** Usage

*** Functions

The main entry point of Clop is ~parse~ function.

#+BEGIN_SRC lisp
  (defparameter +toml-text+ "
[server]
port = 5000
print-access-log = false
")
  
  (clop:parse +toml-text+)
  ; => (("server" ("port" . 5000) ("print-access-log")))
#+END_SRC

This function takes an optional keyword argument ~style~ that controls the output style:

- ~:alist~. The default. TOML tables are transformed to alists.
- ~:jsown~. TOML tables are transformed to jsown style ~(:obj "key" "value")~.
- ~:raw~. TOML tables are transformed to Clop internal representations, i.e. classes ~table~, ~table-array~ and ~inline-table~.

*** Configurations

The behavior of Clop can be tuned by settings configuration variables. Wrap them in a let lexical context or change their values globally to make it work.

|---------------+---------------+----------------------------|
| Variable      | Default Value | Meaning                    |
|---------------+---------------+----------------------------|
| *value-+inf*  | :+INF         | The value of +inf          |
| *value--inf*  | :-INF         | The value of -inf          |
| *value-+nan*  | :+NAN         | The value of +nan          |
| *value--nan*  | :-NAN         | The value of -nan          |
| *value-true*  | T             | The value of boolean true  |
| *value-false* | NIL           | The value of boolean false |
|---------------+---------------+----------------------------|

*** Extending Clop

Clop implementation has 2 concepts: value parser and block parser.

- Value parser is used for handling basic values, i.e. string, integer, float, bool, datetime, datetime-local, date-local, time-local.

- Block parser is used for handling TOML blocks, i.e. key-value-pair, table, inline-table and table-array.

**** Tuning Value Parser

For basic values, you may:

1. Define your own value parser function that takes 2 arguments: type and value, and return the resulting value.
2. Set ~clop.config:*value-parser*~ variable to your own function.

You may refer to ~roswell/decoder.ros~ for an example. ~toml-test~ requires values to be a JSON object like:

#+BEGIN_SRC json
  {
    "type": "integer",
    "value": 123
  }
#+END_SRC

Code in ~roswell/decoder.ros~ tunes value parser to return such ~jsown~ object.

**** Tuning Block Parser

Instead of implementing your own block parser, you may pass a ~:raw~ style to ~clop:parse~ function and start from the return value. Check docstrings in ~src/toml-block-parser~ for more detail.


2 Systems

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


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

2.1 clop

CLOP - Common Lisp tOml Parser

Author

YUE Daian

License

MIT

Version

0.1.0

Dependencies
  • alexandria (system).
  • esrap (system).
  • parse-number (system).
  • local-time (system).
  • str (system).
Source

clop.asd.

Child Component

src (module).


Next: , Previous: , Up: The clop Reference Manual   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


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

3.1 clop/src

Source

clop.asd.

Parent Component

clop (system).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 clop/clop.asd

Source

clop.asd.

Parent Component

clop (system).

ASDF Systems

clop.


4.1.2 clop/src/conditions.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.conditions.

Public Interface
Internals

4.1.3 clop/src/toml-value-parser.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.toml-value-parser.

Public Interface

parse-value (generic function).


4.1.4 clop/src/config.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.config.

Public Interface

4.1.5 clop/src/toml-block.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.toml-block.

Public Interface

4.1.6 clop/src/toml-block-parser.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.toml-block-parser.

Public Interface
Internals

4.1.7 clop/src/rules.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.rules.

Internals

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

4.1.8 clop/src/clop.lisp

Source

clop.asd.

Parent Component

src (module).

Packages

clop.

Public Interface

parse (function).

Internals

serialize (generic function).


5 Packages

Packages are listed by definition order.


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

5.1 clop

Source

clop.lisp.

Use List
Public Interface

parse (function).

Internals

serialize (generic function).


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

5.2 clop.toml-block

Source

toml-block.lisp.

Use List

common-lisp.

Used By List
Public Interface

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

5.3 clop.config

Source

config.lisp.

Use List

common-lisp.

Public Interface

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

5.4 clop.conditions

Source

conditions.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

5.5 clop.rules

Source

rules.lisp.

Use List
Used By List

clop.

Internals

5.6 clop.toml-block-parser

Source

toml-block-parser.lisp.

Use List
Used By List

clop.

Public Interface
Internals

5.7 clop.toml-value-parser

Source

toml-value-parser.lisp.

Use List

common-lisp.

Public Interface

parse-value (generic function).


6 Definitions

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


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

6.1 Public Interface


6.1.1 Special variables

Special Variable: *value-+inf*

The value of +inf when decoding TOML.

Package

clop.config.

Source

config.lisp.

Special Variable: *value-+nan*

The value of +nan when decoding TOML.

Package

clop.config.

Source

config.lisp.

Special Variable: *value--inf*

The value of -inf when decoding TOML.

Package

clop.config.

Source

config.lisp.

Special Variable: *value--nan*

The value of -nan when decoding TOML.

Package

clop.config.

Source

config.lisp.

Special Variable: *value-false*

The value of false when decoding TOML.

Package

clop.config.

Source

config.lisp.

Special Variable: *value-parser*
Package

clop.config.

Source

config.lisp.

Special Variable: *value-true*

The value of true when decoding TOML.

Package

clop.config.

Source

config.lisp.


6.1.2 Ordinary functions

Function: parse (text &key style)

Parse given string TEXT and convert the result to given STYLE. The STYLE can be one of:
* :alist (the default)
* :jsown (jsown-like object)
* :raw (should be rarely used)

The top-level of result is an alist.

You may implement your own style by implementing SERIALIZE method.

Package

clop.

Source

clop.lisp.

Function: parse-toml-blocks (list)

Given a LIST of components (tables or key-value pairs), return an alist.

Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.


6.1.3 Generic functions

Generic Reader: children (object)
Generic Writer: (setf children) (object)
Package

clop.toml-block-parser.

Methods
Reader Method: children ((collection collection))
Writer Method: (setf children) ((collection collection))

A table of any kind. Note that for a table, its own name is not stored as a property of itself, but as a hash key in children property of its parent collection. The parsed result is a table representing root table.

Source

toml-block-parser.lisp.

Target Slot

children.

Generic Reader: keys (object)
Package

clop.toml-block.

Methods
Reader Method: keys ((toml-key-value-pair toml-key-value-pair))

automatically generated reader method

Source

toml-block.lisp.

Target Slot

keys.

Generic Writer: (setf keys) (object)
Package

clop.toml-block.

Methods
Writer Method: (setf keys) ((toml-key-value-pair toml-key-value-pair))

automatically generated writer method

Source

toml-block.lisp.

Target Slot

keys.

Generic Reader: names (object)
Package

clop.toml-block.

Methods
Reader Method: names ((toml-named-table toml-named-table))

automatically generated reader method

Source

toml-block.lisp.

Target Slot

names.

Generic Writer: (setf names) (object)
Package

clop.toml-block.

Methods
Writer Method: (setf names) ((toml-named-table toml-named-table))

automatically generated writer method

Source

toml-block.lisp.

Target Slot

names.

Generic Reader: pairs (object)
Package

clop.toml-block.

Methods
Reader Method: pairs ((toml-inline-table toml-inline-table))

automatically generated reader method

Source

toml-block.lisp.

Target Slot

pairs.

Generic Writer: (setf pairs) (object)
Package

clop.toml-block.

Methods
Writer Method: (setf pairs) ((toml-inline-table toml-inline-table))

automatically generated writer method

Source

toml-block.lisp.

Target Slot

pairs.

Generic Function: parse-value (type value)
Package

clop.toml-value-parser.

Source

toml-value-parser.lisp.

Methods
Method: parse-value (type value)
Method: parse-value ((type (eql :time-local)) value)

Return a plist with keys (:hour :minute :second).

Method: parse-value ((type (eql :date-local)) value)

Return a plist with keys (:year :month :day).

Method: parse-value ((type (eql :datetime-local)) value)

Return a plist with keys (:year :month :day :hour :minute :second).

Method: parse-value ((type (eql :datetime)) value)

Return a timestamp.

Generic Reader: value (object)
Package

clop.toml-block.

Methods
Reader Method: value ((toml-key-value-pair toml-key-value-pair))

automatically generated reader method

Source

toml-block.lisp.

Target Slot

value.

Generic Writer: (setf value) (object)
Package

clop.toml-block.

Methods
Writer Method: (setf value) ((toml-key-value-pair toml-key-value-pair))

automatically generated writer method

Source

toml-block.lisp.

Target Slot

value.


6.1.4 Standalone methods

Method: print-object ((table toml-array-table) stream)
Source

toml-block.lisp.

Method: print-object ((table toml-named-table) stream)
Source

toml-block.lisp.

Method: print-object ((table toml-inline-table) stream)
Source

toml-block.lisp.

Method: print-object ((obj toml-key-value-pair) stream)
Source

toml-block.lisp.

Method: print-object ((table table) stream)
Source

toml-block-parser.lisp.

Method: print-object ((table table-array) stream)
Source

toml-block-parser.lisp.

Method: print-object ((table inline-table) stream)
Source

toml-block-parser.lisp.


6.1.5 Conditions

Condition: toml-dotted-key-open-table-array-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-table-error.

Condition: toml-dotted-key-redefine-table-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-table-error.

Condition: toml-invalid-text-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-parse-error.

Direct subclasses

toml-invalid-utf8-error.

Direct methods
Direct slots
Slot: text
Initargs

:text

Readers

text.

Writers

(setf text).

Condition: toml-invalid-utf8-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-invalid-text-error.

Condition: toml-modify-inline-table-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-table-error.

Condition: toml-parse-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses

toml-invalid-text-error.

Condition: toml-redefine-property-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-table-error.

Condition: toml-redefine-table-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

toml-table-error.

Condition: toml-table-error
Package

clop.conditions.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: names
Initargs

:names

Readers

names.

Writers

(setf names).


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

6.1.6 Classes

Class: collection
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: children

A table of any kind. Note that for a table, its own name is not stored as a property of itself, but as a hash key in children property of its parent collection. The parsed result is a table representing root table.

Initform

(make-hash-table :test (function equal))

Readers

children.

Writers

(setf children).

Class: inline-table
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Direct superclasses

collection.

Direct methods
Class: table
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Direct superclasses

collection.

Direct methods
Direct slots
Slot: definition-context

Internal use.

Indicates if the table is defined or not.
A table is defined in the following ways:
1. By [Table] header.
2. By being a path of dotted.key.tables. In this case, all the tables along the way are created and defined.

Its value can be:
- NIL means table is opened but not defined.
- T means defined via [Table] header.
- A table instance means defined under corresponding table section.

Type

boolean

Initargs

:definition-context

Readers

definition-context.

Writers

(setf definition-context).

Class: table-array
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Direct superclasses

collection.

Direct methods
Direct slots
Slot: children
Initform

(list)

Class: toml-array-table
Package

clop.toml-block.

Source

toml-block.lisp.

Direct superclasses

toml-named-table.

Direct methods
Class: toml-block
Package

clop.toml-block.

Source

toml-block.lisp.

Direct subclasses
Class: toml-inline-table
Package

clop.toml-block.

Source

toml-block.lisp.

Direct superclasses

toml-table.

Direct methods
Direct slots
Slot: pairs
Type

list

Initargs

:pairs

Readers

pairs.

Writers

(setf pairs).

Class: toml-key-value-pair
Package

clop.toml-block.

Source

toml-block.lisp.

Direct superclasses

toml-block.

Direct methods
Direct slots
Slot: keys
Type

list

Initargs

:keys

Readers

keys.

Writers

(setf keys).

Slot: value
Initargs

:value

Readers

value.

Writers

(setf value).

Class: toml-named-table
Package

clop.toml-block.

Source

toml-block.lisp.

Direct superclasses

toml-table.

Direct subclasses

toml-array-table.

Direct methods
Direct slots
Slot: names
Type

string

Initargs

:names

Readers

names.

Writers

(setf names).

Class: toml-table
Package

clop.toml-block.

Source

toml-block.lisp.

Direct superclasses

toml-block.

Direct subclasses

6.2 Internals


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

6.2.1 Ordinary functions

Function: append-child (table-array table)

Append TABLE as a child to TABLE-ARRAY.

Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Function: basic-unescaped-char-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: comment-char-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: get-child (table name)

Get the child of TABLE specified by NAME.

Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Function: hexp (char)
Package

clop.rules.

Source

rules.lisp.

Function: last-child (table-array)

Get the last child of TABLE-ARRAY.

Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Function: literal-char-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: multiline-basic-text-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: multiline-literal-char-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: non-ascii-p (char)
Package

clop.rules.

Source

rules.lisp.

Function: parse-number (string &key radix start)

Parse number from STRING with underscores dropped.

Package

clop.rules.

Source

rules.lisp.

Function: parse-pair-value (value context)
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Function: parse-utf8 (text)
Package

clop.rules.

Source

rules.lisp.

Function: parse-value (type text)
Package

clop.rules.

Source

rules.lisp.

Function: set-child (table name value)

Set the child of TABLE specified by NAME to VALUE.

Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.


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

6.2.2 Generic functions

Generic Reader: current-table (object)
Package

clop.toml-block-parser.

Methods
Reader Method: current-table ((parser-context parser-context))

automatically generated reader method

Source

toml-block-parser.lisp.

Target Slot

current-table.

Generic Writer: (setf current-table) (object)
Package

clop.toml-block-parser.

Methods
Writer Method: (setf current-table) ((parser-context parser-context))

automatically generated writer method

Source

toml-block-parser.lisp.

Target Slot

current-table.

Generic Reader: definition-context (object)
Generic Writer: (setf definition-context) (object)
Package

clop.toml-block-parser.

Methods
Reader Method: definition-context ((table table))
Writer Method: (setf definition-context) ((table table))

Internal use.

Indicates if the table is defined or not.
A table is defined in the following ways:
1. By [Table] header.
2. By being a path of dotted.key.tables. In this case, all the tables along the way are created and defined.

Its value can be:
- NIL means table is opened but not defined.
- T means defined via [Table] header.
- A table instance means defined under corresponding table section.

Source

toml-block-parser.lisp.

Target Slot

definition-context.

Generic Reader: names (condition)
Generic Writer: (setf names) (condition)
Package

clop.conditions.

Methods
Reader Method: names ((condition toml-table-error))
Writer Method: (setf names) ((condition toml-table-error))
Source

conditions.lisp.

Target Slot

names.

Generic Function: parse-toml-block (toml-block context)
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Methods
Method: parse-toml-block ((toml-table toml-inline-table) context)
Method: parse-toml-block ((pair toml-key-value-pair) context)
Method: parse-toml-block ((toml-table toml-array-table) context)
Method: parse-toml-block ((toml-table toml-named-table) context)
Generic Reader: root-table (object)
Package

clop.toml-block-parser.

Methods
Reader Method: root-table ((parser-context parser-context))

automatically generated reader method

Source

toml-block-parser.lisp.

Target Slot

root-table.

Generic Function: serialize (table style)

Convert given TABLE to STYLE.
The TABLE should be the root table containing

Package

clop.

Source

clop.lisp.

Methods
Method: serialize (thing (style (eql :raw)))
Method: serialize ((thing list) style)
Method: serialize (thing style)
Method: serialize ((table table-array) style)
Method: serialize ((table inline-table) (style (eql :alist)))
Method: serialize ((table table) (style (eql :alist)))
Method: serialize ((table inline-table) (style (eql :jsown)))
Method: serialize ((table table) (style (eql :jsown)))
Generic Reader: text (condition)
Generic Writer: (setf text) (condition)
Package

clop.conditions.

Methods
Reader Method: text ((condition toml-invalid-text-error))
Writer Method: (setf text) ((condition toml-invalid-text-error))
Source

conditions.lisp.

Target Slot

text.


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

6.2.3 Classes

Class: parser-context
Package

clop.toml-block-parser.

Source

toml-block-parser.lisp.

Direct methods
Direct slots
Slot: root-table
Initform

(make-instance (quote clop.toml-block-parser:table))

Readers

root-table.

Writers

This slot is read-only.

Slot: current-table
Readers

current-table.

Writers

(setf current-table).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   B   C   D   F   G   H   K   L   M   N   P   R   S   T   V  
Index Entry  Section

(
(setf children): Public generic functions
(setf children): Public generic functions
(setf current-table): Private generic functions
(setf current-table): Private generic functions
(setf definition-context): Private generic functions
(setf definition-context): Private generic functions
(setf keys): Public generic functions
(setf keys): Public generic functions
(setf names): Public generic functions
(setf names): Public generic functions
(setf names): Private generic functions
(setf names): Private generic functions
(setf pairs): Public generic functions
(setf pairs): Public generic functions
(setf text): Private generic functions
(setf text): Private generic functions
(setf value): Public generic functions
(setf value): Public generic functions

A
append-child: Private ordinary functions

B
basic-unescaped-char-p: Private ordinary functions

C
children: Public generic functions
children: Public generic functions
comment-char-p: Private ordinary functions
current-table: Private generic functions
current-table: Private generic functions

D
definition-context: Private generic functions
definition-context: Private generic functions

F
Function, append-child: Private ordinary functions
Function, basic-unescaped-char-p: Private ordinary functions
Function, comment-char-p: Private ordinary functions
Function, get-child: Private ordinary functions
Function, hexp: Private ordinary functions
Function, last-child: Private ordinary functions
Function, literal-char-p: Private ordinary functions
Function, multiline-basic-text-p: Private ordinary functions
Function, multiline-literal-char-p: Private ordinary functions
Function, non-ascii-p: Private ordinary functions
Function, parse: Public ordinary functions
Function, parse-number: Private ordinary functions
Function, parse-pair-value: Private ordinary functions
Function, parse-toml-blocks: Public ordinary functions
Function, parse-utf8: Private ordinary functions
Function, parse-value: Private ordinary functions
Function, set-child: Private ordinary functions

G
Generic Function, (setf children): Public generic functions
Generic Function, (setf current-table): Private generic functions
Generic Function, (setf definition-context): Private generic functions
Generic Function, (setf keys): Public generic functions
Generic Function, (setf names): Public generic functions
Generic Function, (setf names): Private generic functions
Generic Function, (setf pairs): Public generic functions
Generic Function, (setf text): Private generic functions
Generic Function, (setf value): Public generic functions
Generic Function, children: Public generic functions
Generic Function, current-table: Private generic functions
Generic Function, definition-context: Private generic functions
Generic Function, keys: Public generic functions
Generic Function, names: Public generic functions
Generic Function, names: Private generic functions
Generic Function, pairs: Public generic functions
Generic Function, parse-toml-block: Private generic functions
Generic Function, parse-value: Public generic functions
Generic Function, root-table: Private generic functions
Generic Function, serialize: Private generic functions
Generic Function, text: Private generic functions
Generic Function, value: Public generic functions
get-child: Private ordinary functions

H
hexp: Private ordinary functions

K
keys: Public generic functions
keys: Public generic functions

L
last-child: Private ordinary functions
literal-char-p: Private ordinary functions

M
Method, (setf children): Public generic functions
Method, (setf current-table): Private generic functions
Method, (setf definition-context): Private generic functions
Method, (setf keys): Public generic functions
Method, (setf names): Public generic functions
Method, (setf names): Private generic functions
Method, (setf pairs): Public generic functions
Method, (setf text): Private generic functions
Method, (setf value): Public generic functions
Method, children: Public generic functions
Method, current-table: Private generic functions
Method, definition-context: Private generic functions
Method, keys: Public generic functions
Method, names: Public generic functions
Method, names: Private generic functions
Method, pairs: Public generic functions
Method, parse-toml-block: Private generic functions
Method, parse-toml-block: Private generic functions
Method, parse-toml-block: Private generic functions
Method, parse-toml-block: Private generic functions
Method, parse-value: Public generic functions
Method, parse-value: Public generic functions
Method, parse-value: Public generic functions
Method, parse-value: Public generic functions
Method, parse-value: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, root-table: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, serialize: Private generic functions
Method, text: Private generic functions
Method, value: Public generic functions
multiline-basic-text-p: Private ordinary functions
multiline-literal-char-p: Private ordinary functions

N
names: Public generic functions
names: Public generic functions
names: Private generic functions
names: Private generic functions
non-ascii-p: Private ordinary functions

P
pairs: Public generic functions
pairs: Public generic functions
parse: Public ordinary functions
parse-number: Private ordinary functions
parse-pair-value: Private ordinary functions
parse-toml-block: Private generic functions
parse-toml-block: Private generic functions
parse-toml-block: Private generic functions
parse-toml-block: Private generic functions
parse-toml-block: Private generic functions
parse-toml-blocks: Public ordinary functions
parse-utf8: Private ordinary functions
parse-value: Public generic functions
parse-value: Public generic functions
parse-value: Public generic functions
parse-value: Public generic functions
parse-value: Public generic functions
parse-value: Public generic functions
parse-value: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

R
root-table: Private generic functions
root-table: Private generic functions

S
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
serialize: Private generic functions
set-child: Private ordinary functions

T
text: Private generic functions
text: Private generic functions

V
value: Public generic functions
value: Public generic functions

Jump to:   (  
A   B   C   D   F   G   H   K   L   M   N   P   R   S   T   V  

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

A.3 Variables

Jump to:   *  
C   D   K   N   P   R   S   T   V  
Index Entry  Section

*
*value-+inf*: Public special variables
*value-+nan*: Public special variables
*value--inf*: Public special variables
*value--nan*: Public special variables
*value-false*: Public special variables
*value-parser*: Public special variables
*value-true*: Public special variables

C
children: Public classes
children: Public classes
current-table: Private classes

D
definition-context: Public classes

K
keys: Public classes

N
names: Public conditions
names: Public classes

P
pairs: Public classes

R
root-table: Private classes

S
Slot, children: Public classes
Slot, children: Public classes
Slot, current-table: Private classes
Slot, definition-context: Public classes
Slot, keys: Public classes
Slot, names: Public conditions
Slot, names: Public classes
Slot, pairs: Public classes
Slot, root-table: Private classes
Slot, text: Public conditions
Slot, value: Public classes
Special Variable, *value-+inf*: Public special variables
Special Variable, *value-+nan*: Public special variables
Special Variable, *value--inf*: Public special variables
Special Variable, *value--nan*: Public special variables
Special Variable, *value-false*: Public special variables
Special Variable, *value-parser*: Public special variables
Special Variable, *value-true*: Public special variables

T
text: Public conditions

V
value: Public classes

Jump to:   *  
C   D   K   N   P   R   S   T   V  

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

A.4 Data types

Jump to:   C   F   I   M   P   R   S   T  
Index Entry  Section

C
Class, collection: Public classes
Class, inline-table: Public classes
Class, parser-context: Private classes
Class, table: Public classes
Class, table-array: Public classes
Class, toml-array-table: Public classes
Class, toml-block: Public classes
Class, toml-inline-table: Public classes
Class, toml-key-value-pair: Public classes
Class, toml-named-table: Public classes
Class, toml-table: Public classes
clop: The clop system
clop: The clop package
clop.asd: The clop/clop․asd file
clop.conditions: The clop․conditions package
clop.config: The clop․config package
clop.lisp: The clop/src/clop․lisp file
clop.rules: The clop․rules package
clop.toml-block: The clop․toml-block package
clop.toml-block-parser: The clop․toml-block-parser package
clop.toml-value-parser: The clop․toml-value-parser package
collection: Public classes
Condition, toml-dotted-key-open-table-array-error: Public conditions
Condition, toml-dotted-key-redefine-table-error: Public conditions
Condition, toml-invalid-text-error: Public conditions
Condition, toml-invalid-utf8-error: Public conditions
Condition, toml-modify-inline-table-error: Public conditions
Condition, toml-parse-error: Public conditions
Condition, toml-redefine-property-error: Public conditions
Condition, toml-redefine-table-error: Public conditions
Condition, toml-table-error: Public conditions
conditions.lisp: The clop/src/conditions․lisp file
config.lisp: The clop/src/config․lisp file

F
File, clop.asd: The clop/clop․asd file
File, clop.lisp: The clop/src/clop․lisp file
File, conditions.lisp: The clop/src/conditions․lisp file
File, config.lisp: The clop/src/config․lisp file
File, rules.lisp: The clop/src/rules․lisp file
File, toml-block-parser.lisp: The clop/src/toml-block-parser․lisp file
File, toml-block.lisp: The clop/src/toml-block․lisp file
File, toml-value-parser.lisp: The clop/src/toml-value-parser․lisp file

I
inline-table: Public classes

M
Module, src: The clop/src module

P
Package, clop: The clop package
Package, clop.conditions: The clop․conditions package
Package, clop.config: The clop․config package
Package, clop.rules: The clop․rules package
Package, clop.toml-block: The clop․toml-block package
Package, clop.toml-block-parser: The clop․toml-block-parser package
Package, clop.toml-value-parser: The clop․toml-value-parser package
parser-context: Private classes

R
rules.lisp: The clop/src/rules․lisp file

S
src: The clop/src module
System, clop: The clop system

T
table: Public classes
table-array: Public classes
toml-array-table: Public classes
toml-block: Public classes
toml-block-parser.lisp: The clop/src/toml-block-parser․lisp file
toml-block.lisp: The clop/src/toml-block․lisp file
toml-dotted-key-open-table-array-error: Public conditions
toml-dotted-key-redefine-table-error: Public conditions
toml-inline-table: Public classes
toml-invalid-text-error: Public conditions
toml-invalid-utf8-error: Public conditions
toml-key-value-pair: Public classes
toml-modify-inline-table-error: Public conditions
toml-named-table: Public classes
toml-parse-error: Public conditions
toml-redefine-property-error: Public conditions
toml-redefine-table-error: Public conditions
toml-table: Public classes
toml-table-error: Public conditions
toml-value-parser.lisp: The clop/src/toml-value-parser․lisp file

Jump to:   C   F   I   M   P   R   S   T