The cl-markless Reference Manual

Table of Contents

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

The cl-markless Reference Manual

This is the cl-markless Reference Manual, version 1.0.0, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Jul 29 15:01:02 2019 GMT+0.


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

1 Introduction

## About cl-markless
This is an implementation of the "Markless standard"(link https://github.com/shirakumo/markless) at version 1.0. It handles the parsing of plaintext from a stream into an abstract syntax tree composed out of strings and component objects. From there the AST can be easily compiled into a target markup language like HTML.

## How To
To parse a Markless document, simply call the function ``parse``:

:: common-lisp
(cl-markless:parse "Hello!" T)
::

This will return the generated AST. From there on you can manipulate, inspect, or compile it further.

:: common-lisp
(cl-markless:output * :format 'cl-markless:debug)
::

One thing in particular to note is that cl-markless requires LF (unix-style) line endings. CR (mac) or CRLF (windows) //have// to be converted ahead of time, or parse results will not be as expected.

### Writing Markless
You can find a lengthy tutorial on the "Markless website"(https://shirakumo.github.io/markless).

### Extending cl-markless
The Markless standard permits extension in a few ways, all of which cl-markless supports. Furthermore, cl-markless allows the seamless addition of output compilers to allow integrating more target languages.

#### Directives
Adding a new directive will involve some work, as parsing the proper syntax can be complicated. Please read the section for the "parser algorithm"(#parser algorithm) as well. Generally the parsing behaviour is controlled via 6 central functions.

- ``prefix``
- ``begin``
- ``invoke``
- ``end``
- ``consume-prefix``
- ``consume-end``

All of these functions return a cursor -- an index into the current line. ``consume-prefix`` and ``consume-end`` may also return ``NIL`` in order to signify a failed match.

Depending on the type of directive and the complexity of its syntax, some or most of these functions require specific methods for your directive. Within those methods, the directive can manipulate the parser state using

- ``commit``
- ``read-block``
- ``read-inline``
- ``stack-pop``
- ``stack-push``

Naturally a directive can do whatever it pleases when called, so the above is only an outline of the most useful functions.

##### Block Directives
Block directives must be a subclass of ``block-directive`` and define methods on ``prefix``, ``begin``, ``consume-prefix``, and optionally ``invoke``. By default the ``invoke`` on a block directive will call ``read-block``, causing further blocks to be read.

If your directive can only span a single line, you should subclass ``singular-line-directive`` instead, for which only methods on ``prefix``, ``begin``, and optionally ``invoke`` are necessary. By default ``read-inline`` is called for ``invoke``.

##### Inline Directives
Inline directives must be a subclass of ``inline-directive`` and define methods on ``prefix``, ``begin``, ``consume-end``, and optionally ``invoke``. By default the ``invoke`` on an inline directive will call ``read-inline``.

If your directive has a constant prefix that is also the same as its ending suffix, you should subclass ``singular-line-directive`` instead.

#### Instructions
Adding a new instruction type requires the following steps:

1. Add a new component that is a subclass of ``instruction``.
2. Add a method to ``parse-instruction`` that specialises on this new component class, and use it to parse the line into the appropriate instance of your instruction component.
3. Add a method to ``evaluate-instruction`` that specialises on your component class and performs whatever task that your instruction should allow.

#### Embed Types
A new embed type requires only two steps:

1. Add a new component that is a subclass of ``embed``.
2. Add methods to ``embed-option-allowed-p`` specialised on your component and each permitted option that simply return ``T``.

#### Embed Options
Adding new embed options requires a couple more steps:

1. Add a new component that is a subclass of ``embed-option``.
2. Add a method to ``parse-embed-option-type`` specialised on your new option class, which parses the given option string into a new instance of your class.
3. Define methods on ``embed-option-allowed-p`` that just return ``T`` for all embed types that your new option would be appropriate for.

#### Compound Options
New compound options requires a similar procedure as for embed options.

1. Add a new component that is a subclass of ``compound-option``.
2. Add a method to ``parse-compound-option-type`` specialised on your new option class, which parses the given option string into a new instance of your class.

Unlike embed options there's no verification step, as any combination of compound options is allowed.

#### Colour and Size Names
Cl-markless includes a number of colour and size names for the compound option out of the box. If you would like to add or modify those, simply modify the ``*color-table*`` and ``*size-table*``.

#### Output Translators
Defining a new output translator is only a matter of adding a subclass to ``output-translator`` and adding the appropriate methods to ``output-component``. To make this a bit shorter for the default case of wanting to output to streams, ``define-output`` can be used. Since each format has very different constraints on what it should look like, nothing beyond these two functions is really offered.

## Parser Algorithm
The parser operates via a set of ``directive``s and a ``stack``. Each entry in the stack holds a ``component`` and a ``directive``. At the beginning of a parse, the stack is emptied and a first stack item is filled composed out of fresh ``root-directive`` and ``root-component`` instances. The parser then operates as follows:

1. If the stream has things to read, it reads a new line via ``read-full-line``.
   1. If it does not have anything new to read, the parse is completed:
   2. The stack is unwound to 0, causing all directives still active to be ``end``ed.
   3. The ``root-component`` is returned.
2. ``process-stack`` is called on the parser, its stack, and the new line.
   1. The stack is traversed upwards, calling ``consume-prefix`` on each directive in turn and updating the cursor.
      1. If ``consume-prefix`` returns ``NIL`` for a directive:
      2. The stack is unwound to and including the current point, calling ``end`` on each directive that is popped off the stack.
   2. ``invoke`` is called on the directive at the top of the stack and the cursor is updated.
   3. If the cursor is not yet at the end of the line, go back to 2.2.
3. Go back to 1.

You may note that in this algorithm it is not typical for the cursor to move backwards, and straight out impossible to go back a line. This is despite the fact that Markless may seem to force a lot of backtracking on invalidly matched inline directives. The crux here is that when an inline directive is aborted via ``end``, it can invoke ``change-class`` on the component it inserted to transform it into an invisible ``parent-component`` and then push its consumed prefix to the front of the child array.

A similar strategy can be employed for block directives that need to match more than the standard two prefix chars: on an invalid match they can pretend to be a paragraph and insert the paragraph directive and component into the stack instead of their own. Since Markless has a guarantee that each directive must match a unique prefix, this strategy is possible without excessive backtracking and reparsing.

## Tests
This implementation includes a test suite that should cover most of the aspects of the Markless standard. The tests are intentionally formatted in a simple way that should allow re-using them to verify other implementations for correctness. See the "tests"(link tests/) directory for more information.

To run the test suite on this implementation:

:: common-lisp
(asdf:test-system :cl-markless)
::

## Output Formats
Additional output formats are provided by external systems.

- "cl-markless-plump"(link cl-markless-plump/index.html) HTML/DOM
- "cl-markless-epub"(link cl-markless-epub/index.html) epub for e-readers

## Standalone Executable
You can create a standalone executable of cl-markless with a command line interface. See "cl-markless-standalone"(link cl-markless-standalone/index.html).

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 cl-markless

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/cl-markless

License

zlib

Description

A parser implementation for Markless

Version

1.0.0

Dependencies
Source

cl-markless.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 cl-markless.asd

Location

cl-markless.asd

Systems

cl-markless (system)


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

3.1.2 cl-markless/package.lisp

Parent

cl-markless (system)

Location

package.lisp

Packages

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

3.1.3 cl-markless/toolkit.lisp

Dependency

package.lisp (file)

Parent

cl-markless (system)

Location

toolkit.lisp

Exported Definitions
Internal Definitions

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

3.1.4 cl-markless/conditions.lisp

Dependency

toolkit.lisp (file)

Parent

cl-markless (system)

Location

conditions.lisp

Exported Definitions
Internal Definitions

*current-line-number* (special variable)


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

3.1.5 cl-markless/component.lisp

Dependency

conditions.lisp (file)

Parent

cl-markless (system)

Location

component.lisp

Exported Definitions
Internal Definitions

define-printer (macro)


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

3.1.6 cl-markless/color-table.lisp

Dependency

component.lisp (file)

Parent

cl-markless (system)

Location

color-table.lisp

Exported Definitions

*color-table* (special variable)

Internal Definitions

make-color-table (function)


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

3.1.7 cl-markless/size-table.lisp

Dependency

color-table.lisp (file)

Parent

cl-markless (system)

Location

size-table.lisp

Exported Definitions

*size-table* (special variable)

Internal Definitions

make-size-table (function)


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

3.1.8 cl-markless/printer.lisp

Dependency

size-table.lisp (file)

Parent

cl-markless (system)

Location

printer.lisp

Exported Definitions
Internal Definitions

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

3.1.9 cl-markless/parser.lisp

Dependency

printer.lisp (file)

Parent

cl-markless (system)

Location

parser.lisp

Exported Definitions
Internal Definitions

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

3.1.10 cl-markless/directive.lisp

Dependency

parser.lisp (file)

Parent

cl-markless (system)

Location

directive.lisp

Exported Definitions
Internal Definitions

noop (class)


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

3.1.11 cl-markless/documentation.lisp

Dependency

directive.lisp (file)

Parent

cl-markless (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 cl-markless-components

Source

package.lisp (file)

Nickname

org.shirakumo.markless.components

Use List

common-lisp

Exported Definitions
Internal Definitions

define-printer (macro)


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

4.2 cl-markless

Source

package.lisp (file)

Nickname

org.shirakumo.markless

Use List

common-lisp

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 Special variables

Special Variable: *color-table*

Hash table associating colour names to color-options.

Each entry should be a case-insensitive string as the key and a CL-MARKLESS-COMPONENTS:COLOR-OPTION as the value. The default table should include all of the colour names and values defined for HTML/CSS.

See CL-MARKLESS-COMPONENTS:COLOR-OPTION

Package

cl-markless

Source

color-table.lisp (file)

Special Variable: *default-directives*

This variable contains the list of by-default available directives.

This list should only ever contain names of directives, not directive instances.

See PARSER

Package

cl-markless

Source

parser.lisp (file)

Special Variable: *size-table*

Hash table associating size names to size-options.

Each entry should be a case-insensitive string as the key and a CL-MARKLESS-COMPONENTS:SIZE-OPTION as the value. The default table should include all of the size names and values defined by the Markless standard.

See CL-MARKLESS-COMPONENTS:SIZE-OPTION

Package

cl-markless

Source

size-table.lisp (file)


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

5.1.2 Macros

Macro: define-output FORMAT (COMPONENT STREAM) &body METHODS

Defines a new output format.

This is a shorthand macro that defines methods for OUTPUT-COMPONENT specialised on streams. Each entry in the body must follow this structure:

CLASS QUALIFIERS . BODY

Which will be translated to the appropriate method. Within the body the following two convenience functions are automatically bound:

- (OUTPUT c)
Calls OUTPUT-COMPONENT on c with the appropriate extra arguments. - (OUTPUT-CHILDREN)
Calls OUTPUT-COMPONENT on each of the children of the current component.

See OUTPUT-COMPONENT

Package

cl-markless

Source

printer.lisp (file)

Macro: match! PREFIX LINE CURSOR

Attempts to match the prefix.

Returns the new cursor on success, and NIL on failure.

Package

cl-markless

Source

toolkit.lisp (file)


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

5.1.3 Functions

Function: commit DIRECTIVE COMPONENT PARSER

Commits the given directive and component.

This pushes the two onto the stack and appends the component to the child array of the component that was previously at the top of the stack.

See DIRECTIVE
See CL-MARKLESS-COMPONENTS:COMPONENT
See PARSER

Package

cl-markless

Source

parser.lisp (file)

Function: compile-dispatch-table DIRECTIVES

Compiles the given list of directives into a dispatch table.

This table forms a tree of tables with either NIL or a directive as the leaves. A directive is only ever a leaf if its full prefix has been matched by traversing the tree of tables. The tree is built using the PREFIX from the directives.

See DIRECTIVE
See PREFIX
See DISPATCH

Package

cl-markless

Source

parser.lisp (file)

Function: condense-children CHILDREN

Returns a new, condensed child array.

This condenses the child array as follows:
- Consecutive strings are concatenated together
- INSTRUCTION and COMMENT components are filtered out
- PARENT-COMPONENTs that are not subclasses thereof have their contents spliced into the new child array.

This does /not/ recursively condense.

Package

cl-markless

Source

toolkit.lisp (file)

Function: condense-component-tree COMPONENT

Condenses the given component destructively and recursively.

See CONDENSE-CHILDREN

Package

cl-markless

Source

toolkit.lisp (file)

Function: dispatch TABLE STRING CURSOR

Dispatches to a directive using the given dispatch table.

Returns the matched directive if a full prefix match has been found and the directive is enabled.

See ENABLED-P

Package

cl-markless

Source

parser.lisp (file)

Function: ends-with ENDING STRING

Returns true if the given string ends with the given ending.

Package

cl-markless

Source

toolkit.lisp (file)

Function: ensure-directive DIRECTIVE-ISH

Resolves the directive-ish to a directive if possible.

The argument can be a DIRECTIVE instance or a symbol naming the class of one. In the latter case, a new instance of the named class is returned if the class is a subclass of DIRECTIVE. Otherwise, an error is signalled.

See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Function: list-output-formats ()

Returns a list of all known output formats.

The list is composed of class names for OUTPUT-FORMAT classes.

See OUTPUT-FORMAT

Package

cl-markless

Source

printer.lisp (file)

Function: output COMPONENT &rest INITARGS &key TARGET FORMAT &allow-other-keys

Outputs the given component to the appropriate stream in the requested format.

If the target is T, it is substituted for *STANDARD-OUTPUT*. If the
target is NIL, it is substituted for a STRING-OUTPUT-STREAM whose
contents are returned in the end. If the target is a PATHNAME, the
denoted file is opened and the target is substituted for a stream to
that file. Otherwise, the target is passed on to OUTPUT-COMPONENT
directly and the return value is format dependent.

If the component is not an instance of COMPONENT, it is replaced by
the return value of calling PARSE on the passed component argument.

Extra keyword arguments are passed as initargs to the FORMAT. If the FORMAT is an instance of OUTPUT-FORMAT, REINITIALIZE-INSTANCE is
called. If the FORMAT is a SYMBOL, MAKE-INSTANCE is called. Otherwise
an error is signalled. Note that the keyword arguments :FORMAT and
:TARGET are excluded from the initarg list.

By default the MARKLESS and DEBUG outputs are provided.

See PARSE
See MARKLESS
See DEBUG
See OUTPUT-COMPONENT

Package

cl-markless

Source

printer.lisp (file)

Function: parse-compound-option CURSOR OPTION

Parses the given option string into an option if possible.

The following tests are performed:
- If the option is found in *COLOR-TABLE*, its entry is returned. - If the option is found in *SIZE-TABLE*, its entry is returned. - If the option starts with a # an INTERNAL-LINK-OPTION is returned. - If the option matches the URL directive, a LINK-OPTION is returned. - Otherwise the function proceeds as follows:

Takes the first space-delimited token of the string and appends "-option" to it to form the potential name of the option type. It then searches for a symbol (in the proper case) of that name in the CL-MARKLESS-COMPONENTS package. If found, and if the symbol names a subtype of COMPOUND-OPTION, PARSE-COMPOUND-OPTION-TYPE is called with a class prototype of the name. Otherwise an error of type BAD-OPTION is signalled.

See *COLOR-TABLE*
See *SIZE-TABLE*
See PARSE-COMPOUND-OPTION-TYPE
See CL-MARKLESS-COMPONENTS:COMPOUND-OPTION

Package

cl-markless

Source

directive.lisp (file)

Function: parse-embed-option CURSOR OPTION COMPONENT

Parses the given option string into an option if possible.

Takes the first space-delimited token of the string and appends "-option" to it to form the potential name of the option type. It then searches for a symbol (in the proper case) of that name in the CL-MARKLESS-COMPONENTS package. If found, and if the symbol names a subtype of EMBED-OPTION, PARSE-EMBED-OPTION-TYPE is called with a class prototype of the name. Otherwise an error of type BAD-OPTION is signalled.

See PARSE-EMBED-OPTION-TYPE
See CL-MARKLESS-COMPONENTS:EMBED-OPTION

Package

cl-markless

Source

directive.lisp (file)

Function: parse-float STRING &key START END

Parses the given string as a floating point number.

Package

cl-markless

Source

toolkit.lisp (file)

Function: read-block PARSER LINE CURSOR

Attempts to match a block directive.

If the cursor is not already at the end of the line, this will dispatch a block directive and call BEGIN on it. It will return the resulting cursor.

See PARSER
See BEGIN
See DISPATCH
See BLOCK-DISPATCH-TABLE

Package

cl-markless

Source

parser.lisp (file)

Function: read-delimited LINE CURSOR DELIMITER

Reads the next character delimited token.

Returns the read token and the new cursor position as multiple values.

This does properly handle backslash escapes.

Package

cl-markless

Source

toolkit.lisp (file)

Function: read-full-line STREAM

Reads a full line of text from the stream, respecting Markless’ line escape syntax.

This means the following
foo\
bar\
baz
will be read as
foobarbaz

Package

cl-markless

Source

parser.lisp (file)

Function: read-inline PARSER LINE CURSOR END-CHAR

Attempts to match inline content.

This constructs a string of content from the line and appends it to the current component at the top of the stack until an inline directive is matched or until the end-char is reached. If an inline directive is matched, BEGIN is called on it and the result thereof is returned. If the end-char is matched, CONSUME-END is called on the directive at the top of the stack. If this returns non-NIL, that value is returned from READ-INLINE after popping the stack.

See PARSER
See BEGIN
See CONSUME-END
See STACK-POP
See STACK-TOP
See DISPATCH
See INLINE-DISPATCH-TABLE

Package

cl-markless

Source

parser.lisp (file)

Function: read-url LINE CURSOR

Attempts to match a URL.

If the match succeeds, a new cursor for the end of the URL is returned and NIL otherwise.

Package

cl-markless

Source

parser.lisp (file)

Function: root PARSER

Returns the ROOT-COMPONENT of the current parse operation.

See ROOT
See PARSER

Package

cl-markless

Source

parser.lisp (file)

Function: split-string STRING SPLIT &optional START

Splits the string by the given split character.

Returns a list of split parts with empty parts removed.

This does NOT handle backslash escapes.

Package

cl-markless

Source

toolkit.lisp (file)

Function: stack-bottom STACK

Returns the stack entry at the bottom of the stack.

This must always be an entry with a ROOT-DIRECTIVE and ROOT-COMPONENT as its contents.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Function: stack-entry-component INSTANCE

Accesses the stack entry’s component.

It is NOT safe to read this value for stack entries that are outside the current fill-pointer of the stack.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Writer

(setf stack-entry-component) (function)

Function: (setf stack-entry-component) VALUE INSTANCE
Package

cl-markless

Source

parser.lisp (file)

Reader

stack-entry-component (function)

Function: stack-entry-directive INSTANCE

Accesses the stack entry’s directive.

It is NOT safe to read this value for stack entries that are outside the current fill-pointer of the stack.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Writer

(setf stack-entry-directive) (function)

Function: (setf stack-entry-directive) VALUE INSTANCE
Package

cl-markless

Source

parser.lisp (file)

Reader

stack-entry-directive (function)

Function: stack-pop STACK

Pops the top directive and component off the stack.

Returns the popped STACK-ENTRY.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Function: stack-push DIRECTIVE COMPONENT STACK

Pushes the given directive and component onto the stack.

Returns the top STACK-ENTRY.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Function: stack-top STACK

Returns the stack entry at the top of the stack.

See STACK-ENTRY

Package

cl-markless

Source

parser.lisp (file)

Function: stack-unwind STACK PARSER UNTIL

Unwinds the stack to the given index.

Makes sure to call END on all the directives that are popped off the stack.

See END
See STACK-POP
See PARSER

Package

cl-markless

Source

parser.lisp (file)

Function: starts-with BEGINNING STRING &optional START

Returns true if the given string starts with the given beginning.

Package

cl-markless

Source

toolkit.lisp (file)

Function: to-readtable-case STRING CASE

Turns the given string into the case as appropriate for the requested readtable case.

This acts as if the string was parsed into a symbol token by READ but
without actually interning or invoking any of the heavy READ
machinery. This is useful in order to translate names for symbols into
the appropriate case for lookups.

Package

cl-markless

Source

toolkit.lisp (file)


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

5.1.4 Generic functions

Generic Function: author OBJECT

Accesses the author metadata of the document.

See ROOT-COMPONENT

Package

cl-markless-components

Writer

(setf author) (generic function)

Methods
Method: author (ROOT-COMPONENT root-component)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf author) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

author (generic function)

Methods
Method: (setf author) NEW-VALUE (ROOT-COMPONENT root-component)

automatically generated writer method

Source

component.lisp (file)

Generic Function: begin DIRECTIVE PARSER LINE CURSOR

Function called to match the beginning of a directive.

Every directive must provide a method for this function.

This function is called if the PREFIX of the directive has been matched. This function should then consume the remainder of the prefix (if any) and return the new position of the cursor. The method is responsible for putting the directive and its component onto the stack if an actual match is found. This can be done via COMMIT.

On an invalid match, the directive should delegate parsing to another directive, or in the very least advance the cursor somehow as otherwise the parser will enter an infinite loop of invoking BEGIN on the same directive after matching its prefix.

See COMMIT
See DIRECTIVE
See READ-BLOCK
See READ-INLINE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: begin (_ newline) PARSER LINE CURSOR
Method: begin (_ dash) PARSER LINE CURSOR
Method: begin (_ url) PARSER LINE CURSOR
Method: begin (_ footnote-reference) PARSER LINE CURSOR
Method: begin (_ compound) PARSER LINE CURSOR
Method: begin (_ subtext) PARSER LINE CURSOR
Method: begin (_ supertext) PARSER LINE CURSOR
Method: begin (_ code) PARSER LINE CURSOR
Method: begin (_ strikethrough) PARSER LINE CURSOR
Method: begin (_ underline) PARSER LINE CURSOR
Method: begin (_ italic) PARSER LINE CURSOR
Method: begin (_ bold) PARSER LINE CURSOR
Method: begin (_ footnote) PARSER LINE CURSOR
Method: begin (_ embed) PARSER LINE START-CURSOR
Method: begin (_ comment) PARSER LINE CURSOR
Method: begin (_ instruction) PARSER LINE CURSOR
Method: begin (_ code-block) PARSER LINE CURSOR
Method: begin (_ horizontal-rule) PARSER LINE CURSOR
Method: begin (_ header) PARSER LINE CURSOR
Method: begin (_ ordered-list) PARSER LINE CURSOR
Method: begin (_ unordered-list) PARSER LINE CURSOR
Method: begin (_ blockquote) PARSER LINE CURSOR
Method: begin (_ blockquote-header) PARSER LINE CURSOR
Method: begin (_ paragraph) PARSER LINE CURSOR
Method: begin (_ surrounding-inline-directive) PARSER LINE CURSOR around
Generic Function: block-dispatch-table OBJECT

Accesses the dispatch table for block directives.

It is NOT safe to modify or set this table after the parser has been constructed.

See PARSER
See DISPATCH

Package

cl-markless

Writer

(setf block-dispatch-table) (generic function)

Methods
Method: block-dispatch-table (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf block-dispatch-table) NEW-VALUE OBJECT
Package

cl-markless

Reader

block-dispatch-table (generic function)

Methods
Method: (setf block-dispatch-table) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: blue OBJECT

Accesses the blue component of the color-option.

The value must be an integer in [0,255].

See COLOR-OPTION

Package

cl-markless-components

Writer

(setf blue) (generic function)

Methods
Method: blue (COLOR-OPTION color-option)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf blue) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

blue (generic function)

Methods
Method: (setf blue) NEW-VALUE (COLOR-OPTION color-option)

automatically generated writer method

Source

component.lisp (file)

Generic Function: children OBJECT

Accessor for the vector of child objects.

The vector must be adjustable and have a fill-pointer.

See PARENT-COMPONENT

Package

cl-markless-components

Writer

(setf children) (generic function)

Methods
Method: children (PARENT-COMPONENT parent-component)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf children) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

children (generic function)

Methods
Method: (setf children) NEW-VALUE (PARENT-COMPONENT parent-component)

automatically generated writer method

Source

component.lisp (file)

Generic Function: consume-end DIRECTIVE COMPONENT PARSER LINE CURSOR

Function called to consume the end of an inline directive.

Every inline-directive must provide a method for this function.

This function is called by READ-INLINE if the supplied end-char has been encountered. CONSUME-END should then return the updated cursor position on a successful end match, or NIL on an unsuccessful one.

If it returns successfully, the directive and its component will automatically be popped off the stack.

See READ-INLINE
See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: consume-end (_ compound) COMPONENT PARSER LINE CURSOR
Method: consume-end (_ subtext) COMPONENT PARSER LINE CURSOR
Method: consume-end (_ supertext) COMPONENT PARSER LINE CURSOR
Method: consume-end (_ strikethrough) COMPONENT PARSER LINE CURSOR
Generic Function: consume-prefix DIRECTIVE COMPONENT PARSER LINE CURSOR

Function called to consume the prefix of a directive on the next line.

Every block-directive must provide a method for this function.

This function is called on subsequent lines after the directive has been dispatched and BEGIN has been called. The directive should match the correct prefix for subsequent lines and return the updated cursor on a successful match, or NIL if the match has failed.

See PROCESS-STACK
See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: consume-prefix (_ code-block) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ ordered-list) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ unordered-list) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ blockquote) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ paragraph) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ noop) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ inline-directive) COMPONENT PARSER LINE CURSOR
Method: consume-prefix (_ singular-line-directive) COMPONENT PARSER LINE CURSOR

Accesses the copyright metadata of the document.

See ROOT-COMPONENT

Package

cl-markless-components

Writer

(setf copyright) (generic function)

Methods

automatically generated reader method

Source

component.lisp (file)

Package

cl-markless-components

Reader

copyright (generic function)

Methods

automatically generated writer method

Source

component.lisp (file)

Generic Function: cursor CONDITION

Returns the cursor position after which the condition occurred.

The cursor indexes into the line character by character starting from 0.

See PARSER-CONDITION

Package

cl-markless

Methods
Method: cursor (CONDITION parser-condition)
Source

conditions.lisp (file)

Generic Function: depth OBJECT

Accesses the section depth of the header.

This must be a positive integer.

See HEADER

Package

cl-markless-components

Writer

(setf depth) (generic function)

Methods
Method: depth (CODE-BLOCK code-block)

automatically generated reader method

Source

component.lisp (file)

Method: depth (HEADER header)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf depth) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

depth (generic function)

Methods
Method: (setf depth) NEW-VALUE (CODE-BLOCK code-block)

automatically generated writer method

Source

component.lisp (file)

Method: (setf depth) NEW-VALUE (HEADER header)

automatically generated writer method

Source

component.lisp (file)

Generic Function: direction OBJECT
Generic Function: (setf direction) NEW-VALUE OBJECT
Package

cl-markless-components

Methods
Method: direction (FLOAT-OPTION float-option)

automatically generated reader method

Source

component.lisp (file)

Method: (setf direction) NEW-VALUE (FLOAT-OPTION float-option)

automatically generated writer method

Source

component.lisp (file)

Generic Function: directive NAME PARSER

Returns the directive in the parser with the given name, if any.

The name can be either a symbol or a string.

See PARSER
See DIRECTIVE

Package

cl-markless

Methods
Method: directive (NAME string) PARSER
Source

parser.lisp (file)

Method: directive (NAME symbol) (PARSER parser)
Source

parser.lisp (file)

Generic Function: directive-instance CONDITION

Returns the instance of the directive related to the condition.

See DEACTIVATION-DISALLOWED

Package

cl-markless

Methods
Method: directive-instance (CONDITION deactivation-disallowed)
Source

conditions.lisp (file)

Generic Function: directives OBJECT

Accesses the list of directives that this instruction manipulates.

Each entry in the list should be a string representing the name of a directive.

See DIRECTIVES-INSTRUCTION

Package

cl-markless-components

Writer

(setf directives) (generic function)

Methods
Method: directives (DIRECTIVES-INSTRUCTION directives-instruction)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf directives) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

directives (generic function)

Methods
Method: (setf directives) NEW-VALUE (DIRECTIVES-INSTRUCTION directives-instruction)

automatically generated writer method

Source

component.lisp (file)

Generic Function: directives OBJECT

Accesses the list of directive instances the parser supports.

It is NOT safe to modify or set this list after the parser has been constructed.

See PARSER
See DIRECTIVE

Package

cl-markless

Writer

(setf directives) (generic function)

Methods
Method: directives (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf directives) NEW-VALUE OBJECT
Package

cl-markless

Reader

directives (generic function)

Methods
Method: (setf directives) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: directives-of TYPE PARSER

Returns all directives of a given type in the parser.

See PARSER
See DIRECTIVE

Package

cl-markless

Methods
Method: directives-of TYPE (PARSER parser)
Source

parser.lisp (file)

Generic Function: disable PARSER TEST

Disables all directives in the parser that pass the test function.

See PARSER
See DIRECTIVE
See ENABLED-P

Package

cl-markless

Methods
Method: disable (PARSER parser) (TEST function)
Source

parser.lisp (file)

Generic Function: embed-option-allowed-p OPTION EMBED

Returns T if the combination of option and embed type are allowed.

The user should add appropriate methods to this function when new embed types or options are added. Such methods should simply return T, as the default method will always return NIL.

See CL-MARKLESS-COMPONENTS:EMBED-OPTION
See CL-MARKLESS-COMPONENTS:EMBED

Package

cl-markless

Methods
Method: embed-option-allowed-p (OPTION loop-option) (EMBED audio)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION loop-option) (EMBED video)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION autoplay-option) (EMBED audio)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION autoplay-option) (EMBED video)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION caption-option) (EMBED embed)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION label-option) (EMBED embed)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION float-option) (EMBED embed)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION height-option) (EMBED embed)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION width-option) (EMBED embed)
Source

directive.lisp (file)

Method: embed-option-allowed-p (OPTION embed-option) (EMBED embed)
Source

directive.lisp (file)

Generic Function: embed-type CONDITION

Returns the embed-type that caused the error.

See OPTION-DISALLOWED

Package

cl-markless

Methods
Method: embed-type (CONDITION option-disallowed)
Source

conditions.lisp (file)

Method: embed-type (CONDITION unknown-embed-type)
Source

conditions.lisp (file)

Generic Function: enable PARSER TEST

Enables all directives in the parser that pass the test function.

See PARSER
See DIRECTIVE
See ENABLED-P

Package

cl-markless

Methods
Method: enable (PARSER parser) (TEST function)
Source

parser.lisp (file)

Generic Function: enabled-p OBJECT

Accesses whether the directive is currently enabled or not.

Some directives may not be disabled, in which case an error of type DEACTIVATION-DISALLOWED is signalled if an attempt is made to disable it.

See DIRECTIVE
See DEACTIVATION-DISALLOWED

Package

cl-markless

Writer

(setf enabled-p) (generic function)

Methods
Method: enabled-p (DIRECTIVE directive)

automatically generated reader method

Source

directive.lisp (file)

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

cl-markless

Reader

enabled-p (generic function)

Methods
Method: (setf enabled-p) NEW-VALUE (DIRECTIVE directive)

automatically generated writer method

Source

directive.lisp (file)

Method: (setf enabled-p) (VALUE null) (_ paragraph)
Source

directive.lisp (file)

Method: (setf enabled-p) (VALUE null) (_ root-directive)
Source

directive.lisp (file)

Generic Function: end DIRECTIVE COMPONENT PARSER

Function called when a directive is popped off the stack due to an unsuccessful match.

A method can be added to this to allow the directive to perform some
undoing. This is typically necessary for inline directives as they
might have consumed a prefix that is now invalid due to the incomplete
match.

See PROCESS-STACK
See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: end (_ compound) COMPONENT PARSER after
Method: end (_ subtext) COMPONENT PARSER after
Method: end (_ supertext) COMPONENT PARSER after
Method: end (_ code) COMPONENT PARSER after
Method: end (_ strikethrough) COMPONENT PARSER after
Method: end (_ underline) COMPONENT PARSER after
Method: end (_ italic) COMPONENT PARSER after
Method: end (_ bold) COMPONENT PARSER after
Method: end (_ header) COMPONENT PARSER after
Method: end (_ noop) COMPONENT PARSER
Method: end (_ inline-directive) COMPONENT PARSER
Method: end (_ block-directive) COMPONENT PARSER
Method: end (_ root-directive) COMPONENT PARSER
Generic Function: evaluate-instruction INSTRUCTION PARSER

Evaluates the given instruction, carrying out the changes in parser state.

See INSTRUCTION
See CL-MARKLESS-COMPONENTS:INSTRUCTION
See PARSER

Package

cl-markless

Methods
Method: evaluate-instruction (INSTRUCTION label) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION enable) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION disable) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION include) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION error) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION warning) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION info) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction (INSTRUCTION set) (PARSER parser)
Source

parser.lisp (file)

Method: evaluate-instruction INSTRUCTION (PARSER parser)
Source

parser.lisp (file)

Generic Function: file OBJECT

Accesses the file pathname of the file to be included.

See INCLUDE

Package

cl-markless-components

Writer

(setf file) (generic function)

Methods
Method: file (INCLUDE include)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf file) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

file (generic function)

Methods
Method: (setf file) NEW-VALUE (INCLUDE include)

automatically generated writer method

Source

component.lisp (file)

Generic Function: font-family OBJECT

Accesses the font family name of the font option.

See FONT-OPTION

Package

cl-markless-components

Writer

(setf font-family) (generic function)

Methods
Method: font-family (FONT-OPTION font-option)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf font-family) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

font-family (generic function)

Methods
Method: (setf font-family) NEW-VALUE (FONT-OPTION font-option)

automatically generated writer method

Source

component.lisp (file)

Generic Function: green OBJECT

Accesses the green component of the color-option.

The value must be an integer in [0,255].

See COLOR-OPTION

Package

cl-markless-components

Writer

(setf green) (generic function)

Methods
Method: green (COLOR-OPTION color-option)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf green) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

green (generic function)

Methods
Method: (setf green) NEW-VALUE (COLOR-OPTION color-option)

automatically generated writer method

Source

component.lisp (file)

Generic Function: indentation OBJECT

Accesses the indentation of the paragraph.

This is retained purely for parsing purposes and has no bearing on the visual representation in the resulting document.

See PARAGRAPH

Package

cl-markless-components

Writer

(setf indentation) (generic function)

Methods
Method: indentation (PARAGRAPH paragraph)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf indentation) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

indentation (generic function)

Methods
Method: (setf indentation) NEW-VALUE (PARAGRAPH paragraph)

automatically generated writer method

Source

component.lisp (file)

Generic Function: inline-dispatch-table OBJECT

Accesses the dispatch table for inline directives.

It is NOT safe to modify or set this table after the parser has been constructed.

See PARSER
See DISPATCH

Package

cl-markless

Writer

(setf inline-dispatch-table) (generic function)

Methods
Method: inline-dispatch-table (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf inline-dispatch-table) NEW-VALUE OBJECT
Package

cl-markless

Reader

inline-dispatch-table (generic function)

Methods
Method: (setf inline-dispatch-table) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: input OBJECT

Accesses the current input stream from which lines are parsed.

See PARSER

Package

cl-markless

Writer

(setf input) (generic function)

Methods
Method: input (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf input) NEW-VALUE OBJECT
Package

cl-markless

Reader

input (generic function)

Methods
Method: (setf input) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: instruction CONDITION

Returns the problematic instruction.

See INSTRUCTION-EVALUATION-UNDEFINED See UNKNOWN-INSTRUCTION

Package

cl-markless

Methods
Method: instruction (CONDITION unknown-instruction)
Source

conditions.lisp (file)

Method: instruction (CONDITION instruction-evaluation-undefined)
Source

conditions.lisp (file)

Generic Function: invoke DIRECTIVE COMPONENT PARSER LINE CURSOR

Function called to invoke parsing of a directive after a successful match.

Every directive must provide a method for this function.

Invoke is called to cause the directive to process its content. It should return the new cursor position. Invoke will be repeatedly called on the current directive until the end of the line is reached.

See PROCESS-STACK
See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: invoke (_ compound) COMPONENT PARSER LINE CURSOR
Method: invoke (_ subtext) COMPONENT PARSER LINE CURSOR
Method: invoke (_ supertext) COMPONENT PARSER LINE CURSOR
Method: invoke (_ code) COMPONENT PARSER LINE CURSOR
Method: invoke (_ strikethrough) COMPONENT PARSER LINE CURSOR
Method: invoke (_ instruction) COMPONENT PARSER LINE CURSOR
Method: invoke (_ code-block) COMPONENT PARSER LINE CURSOR
Method: invoke (_ horizontal-rule) COMPONENT PARSER LINE CURSOR
Method: invoke (_ paragraph) COMPONENT PARSER LINE CURSOR
Method: invoke (_ noop) COMPONENT PARSER LINE CURSOR
Method: invoke (_ inline-directive) COMPONENT PARSER LINE CURSOR
Method: invoke (_ singular-line-directive) COMPONENT PARSER LINE CURSOR
Method: invoke (_ block-directive) COMPONENT PARSER LINE CURSOR
Method: invoke (_ root-directive) COMPONENT PARSER LINE CURSOR
Generic Function: label LABEL ROOT

Accesses a specific label in the label table of the document.

See LABELS
See ROOT-COMPONENT

Package

cl-markless-components

Writer

(setf label) (generic function)

Methods
Method: label (LABEL string) (ROOT root-component)
Source

component.lisp (file)

Generic Function: (setf label) VALUE LABEL ROOT
Package

cl-markless-components

Reader

label (generic function)

Generic Function: labels OBJECT

Accesses the label table of the document.

This should return a hash table with EQUALP test. Each key should be the name of a label, and each value a component with which this label was associated. This can be used to resolve cross-references, but only once the document has been fully parsed.

See LABEL
See ROOT-COMPONENT

Package

cl-markless-components

Writer

(setf labels) (generic function)

Methods
Method: labels (ROOT-COMPONENT root-component)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf labels) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

labels (generic function)

Methods
Method: (setf labels) NEW-VALUE (ROOT-COMPONENT root-component)

automatically generated writer method

Source

component.lisp (file)

Generic Function: language OBJECT

Accesses the language.

This can be NIL or a string identifying the language.

See ROOT-COMPONENT
See CODE-BLOCK

Package

cl-markless-components

Writer

(setf language) (generic function)

Methods
Method: language (CODE-BLOCK code-block)

automatically generated reader method

Source

component.lisp (file)

Method: language (ROOT-COMPONENT root-component)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf language) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

language (generic function)

Methods
Method: (setf language) NEW-VALUE (CODE-BLOCK code-block)

automatically generated writer method

Source

component.lisp (file)

Method: (setf language) NEW-VALUE (ROOT-COMPONENT root-component)

automatically generated writer method

Source

component.lisp (file)

Generic Function: line CONDITION

Returns the line number on which the condition occurred.

The lines are counted from 0.

See PARSER-CONDITION

Package

cl-markless

Methods
Method: line (CONDITION parser-condition)
Source

conditions.lisp (file)

Generic Function: line-break-mode OBJECT

Accesses the line break mode currently active in the parser.

The value must be either :SHOW or :HIDE.

See PARSER

Package

cl-markless

Writer

(setf line-break-mode) (generic function)

Methods
Method: line-break-mode (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf line-break-mode) NEW-VALUE OBJECT
Package

cl-markless

Reader

line-break-mode (generic function)

Methods
Method: (setf line-break-mode) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: message OBJECT

Accesses the message string of the instruction.

Typically this message should be displayed to the user somehow.

See MESSAGE-INSTRUCTION

Package

cl-markless-components

Writer

(setf message) (generic function)

Methods
Method: message (MESSAGE-INSTRUCTION message-instruction)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf message) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

message (generic function)

Methods
Method: (setf message) NEW-VALUE (MESSAGE-INSTRUCTION message-instruction)

automatically generated writer method

Source

component.lisp (file)

Generic Function: message CONDITION

Returns the message the user passed in the warn instruction.

See USER-WARNING
See USER-ERROR

Package

cl-markless

Methods
Method: message (CONDITION user-error)
Source

conditions.lisp (file)

Method: message (CONDITION user-warning)
Source

conditions.lisp (file)

Generic Function: number OBJECT

Accesses the number of the list item as an INTEGER.

See ORDERED-LIST-ITEM

Package

cl-markless-components

Writer

(setf number) (generic function)

Methods
Method: number (ORDERED-LIST-ITEM ordered-list-item)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf number) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

number (generic function)

Methods
Method: (setf number) NEW-VALUE (ORDERED-LIST-ITEM ordered-list-item)

automatically generated writer method

Source

component.lisp (file)

Generic Function: option CONDITION

Returns the option string that could not be parsed.

See BAD-OPTION

Package

cl-markless

Methods
Method: option (CONDITION bad-option)
Source

conditions.lisp (file)

Generic Function: options OBJECT

Accesses the list of options associated with the component.

For a CODE-BLOCK this means a list of opaque options to direct the representation of the code. For an EMBED this is a list of EMBED-OPTION instances that dictate visualisation and interaction options. For a COMPOUND it is a list of COMPOUND-OPTION instances that convey the various style changes.

See CODE-BLOCK
See EMBED
See COMPOUND

Package

cl-markless-components

Writer

(setf options) (generic function)

Methods
Method: options (COMPOUND compound)

automatically generated reader method

Source

component.lisp (file)

Method: options (EMBED embed)

automatically generated reader method

Source

component.lisp (file)

Method: options (CODE-BLOCK code-block)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf options) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

options (generic function)

Methods
Method: (setf options) NEW-VALUE (COMPOUND compound)

automatically generated writer method

Source

component.lisp (file)

Method: (setf options) NEW-VALUE (EMBED embed)

automatically generated writer method

Source

component.lisp (file)

Method: (setf options) NEW-VALUE (CODE-BLOCK code-block)

automatically generated writer method

Source

component.lisp (file)

Generic Function: output-component COMPONENT TARGET FORMAT

This function is responsible for formatting the given component to the target in the requested format.

The user should add methods to this function as appropriate, but must
always EQL-specialise on the format argument with a unique symbol to
distinguish their format from others.

Note that the target must not necessarily be a stream unless the
method specialises it to be one.

See OUTPUT

Package

cl-markless

Source

printer.lisp (file)

Methods
Method: output-component (C footnote-reference) (S stream) (_ markless)
Method: output-component (C link-option) (S stream) (_ markless)
Method: output-component (C internal-link-option) (S stream) (_ markless)
Method: output-component (C size-option) (S stream) (_ markless)
Method: output-component (C color-option) (S stream) (_ markless)
Method: output-component (C font-option) (S stream) (_ markless)
Method: output-component (C compound-option) (S stream) (_ markless)
Method: output-component (C compound) (S stream) (_ markless)
Method: output-component (C url) (S stream) (_ markless)
Method: output-component (C supertext) (S stream) (_ markless)
Method: output-component (C subtext) (S stream) (_ markless)
Method: output-component (C code) (S stream) (_ markless)
Method: output-component (C strikethrough) (S stream) (_ markless)
Method: output-component (C underline) (S stream) (_ markless)
Method: output-component (C italic) (S stream) (_ markless)
Method: output-component (C bold) (S stream) (_ markless)
Method: output-component (C footnote) (S stream) (_ markless)
Method: output-component (C caption-option) (S stream) (_ markless)
Method: output-component (C label-option) (S stream) (_ markless)
Method: output-component (C float-option) (S stream) (_ markless)
Method: output-component (C height-option) (S stream) (_ markless)
Method: output-component (C width-option) (S stream) (_ markless)
Method: output-component (C embed-option) (S stream) (_ markless)
Method: output-component (C embed) (S stream) (_ markless)
Method: output-component (C comment) (S stream) (_ markless)
Method: output-component (C label) (S stream) (_ markless)
Method: output-component (C include) (S stream) (_ markless)
Method: output-component (C set) (S stream) (_ markless)
Method: output-component (C directives-instruction) (S stream) (_ markless)
Method: output-component (C message-instruction) (S stream) (_ markless)
Method: output-component (C instruction) (S stream) (_ markless)
Method: output-component (C code-block) (S stream) (_ markless)
Method: output-component (C horizontal-rule) (S stream) (_ markless)
Method: output-component (C header) (S stream) (_ markless)
Method: output-component (C unordered-list-item) (S stream) (_ markless)
Method: output-component (C ordered-list-item) (S stream) (_ markless)
Method: output-component (C blockquote) (S stream) (_ markless)
Method: output-component (C blockquote-header) (S stream) (_ markless)
Method: output-component (C paragraph) (S stream) (_ markless)
Method: output-component (C parent-component) (S stream) (_ markless)
Method: output-component (C unit-component) (S stream) (_ markless)
Method: output-component (C string) (S stream) (_ markless)
Method: output-component (C vector) (S stream) (_ markless)
Method: output-component (C compound) (S stream) (_ debug)
Method: output-component (C footnote-reference) (S stream) (_ debug)
Method: output-component (C footnote) (S stream) (_ debug)
Method: output-component (C embed) (S stream) (_ debug)
Method: output-component (C directives-instruction) (S stream) (_ debug)
Method: output-component (C include) (S stream) (_ debug)
Method: output-component (C set) (S stream) (_ debug)
Method: output-component (C message-instruction) (S stream) (_ debug)
Method: output-component (C code-block) (S stream) (_ debug)
Method: output-component (C header) (S stream) (_ debug)
Method: output-component (C ordered-list-item) (S stream) (_ debug)
Method: output-component (C parent-component) (S stream) (_ debug) after
Method: output-component (C parent-component) (S stream) (_ debug)
Method: output-component (C component) (S stream) (_ debug)
Method: output-component (C string) (S stream) (_ debug)
Method: output-component C (S stream) (_ debug) before
Method: output-component (STRING string) (STREAM stream) FORMAT
Method: output-component (COMPONENT unit-component) TARGET FORMAT
Method: output-component COMPONENT (TARGET pathname) FORMAT
Method: output-component COMPONENT TARGET (FORMAT symbol)
Generic Function: parse THING PARSER

Parses the given input as a Markless document.

If the parser argument is T, a fresh PARSER instance is constructed to perform the parsing.

The THING may be a PATHNAME, STRING, or a STREAM.

Returns a ROOT-COMPONENT on a successful parse.

Note that the parser is not incremental and will consume the stream until EOF is encountered.

See CL-MARKLESS-COMPONENTS:ROOT-COMPONENT
See PARSER

Package

cl-markless

Methods
Method: parse (STREAM stream) (PARSER parser)
Source

parser.lisp (file)

Method: parse (STRING string) PARSER
Source

parser.lisp (file)

Method: parse (PATHNAME pathname) PARSER
Source

parser.lisp (file)

Method: parse THING (PARSER (eql t))
Source

parser.lisp (file)

Generic Function: parse-compound-option-type PROTO OPTION

Parses a compound option to the proper option instance.

This may signal errors if the parsing is unsuccessful.
Each method should be specialised on the class of the compound option to parse and should return a fresh instance of that class on a successful parse. The argument is only a prototype of that class and should not be used for anything except for the type information and dispatch.

By default this function simply returns a fresh instance of the class with no initargs passed.

See COMPOUND

Package

cl-markless

Methods
Method: parse-compound-option-type (PROTO link-option) OPTION
Source

directive.lisp (file)

Method: parse-compound-option-type (PROTO size-option) OPTION
Source

directive.lisp (file)

Method: parse-compound-option-type (PROTO color-option) OPTION
Source

directive.lisp (file)

Method: parse-compound-option-type (PROTO font-option) OPTION
Source

directive.lisp (file)

Method: parse-compound-option-type (PROTO compound-option) OPTION
Source

directive.lisp (file)

Generic Function: parse-embed-option-type TYPE OPTION

Parses an embed option to the proper option instance.

This may signal errors if the parsing is unsuccessful.
Each method should be specialised on the class of the embed option to parse and should return a fresh instance of that class on a successful parse. The argument is only a prototype of that class and should not be used for anything except for the type information and dispatch.

By default this function simply returns a fresh instance of the class with no initargs passed.

See EMBED

Package

cl-markless

Methods
Method: parse-embed-option-type (TYPE height-option) OPTION
Source

directive.lisp (file)

Method: parse-embed-option-type (TYPE width-option) OPTION
Source

directive.lisp (file)

Method: parse-embed-option-type (TYPE caption-option) OPTION
Source

directive.lisp (file)

Method: parse-embed-option-type (TYPE label-option) OPTION
Source

directive.lisp (file)

Method: parse-embed-option-type (TYPE float-option) OPTION
Source

directive.lisp (file)

Method: parse-embed-option-type (TYPE embed-option) OPTION
Source

directive.lisp (file)

Generic Function: parse-instruction PROTO LINE CURSOR

Parses an instruction line to the proper instruction instance.

This may signal errors if the parsing is unsuccessful.
Each method should be specialised on the class of the instruction to parse and should return a fresh instance of that class on a successful parse. The argument is only a prototype of that class and should not be used for anything except for the type information and dispatch.

See INSTRUCTION

Package

cl-markless

Methods
Method: parse-instruction (PROTO directives-instruction) LINE CURSOR
Source

directive.lisp (file)

Method: parse-instruction (PROTO include) LINE CURSOR
Source

directive.lisp (file)

Method: parse-instruction (PROTO message-instruction) LINE CURSOR
Source

directive.lisp (file)

Method: parse-instruction (PROTO set) LINE CURSOR
Source

directive.lisp (file)

Generic Function: prefix DIRECTIVE

Returns the unique prefix of the directive used to identify its start.

Every directive must provide a method for this function.

The prefix is a vector of strings, where each string denotes a set of possible characters that can appear at that position in the prefix.

For instance, the following prefix
#("ab" "c")
Matches the following strings
ac
bc
bca
but not the following
ab
cc
abc

See COMPILE-DISPATCH-TABLE
See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Methods
Method: prefix (_ newline)
Method: prefix (_ dash)
Method: prefix (_ url)
Method: prefix (_ footnote-reference)
Method: prefix (_ compound)
Method: prefix (_ subtext)
Method: prefix (_ supertext)
Method: prefix (_ code)
Method: prefix (_ strikethrough)
Method: prefix (_ underline)
Method: prefix (_ italic)
Method: prefix (_ bold)
Method: prefix (_ footnote)
Method: prefix (_ embed)
Method: prefix (_ comment)
Method: prefix (_ instruction)
Method: prefix (_ code-block)
Method: prefix (_ horizontal-rule)
Method: prefix (_ header)
Method: prefix (_ ordered-list)
Method: prefix (_ unordered-list)
Method: prefix (_ blockquote)
Method: prefix (_ blockquote-header)
Method: prefix (_ paragraph)
Generic Function: red OBJECT

Accesses the red component of the color-option.

The value must be an integer in [0,255].

See COLOR-OPTION

Package

cl-markless-components

Writer

(setf red) (generic function)

Methods
Method: red (COLOR-OPTION color-option)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf red) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

red (generic function)

Methods
Method: (setf red) NEW-VALUE (COLOR-OPTION color-option)

automatically generated writer method

Source

component.lisp (file)

Generic Function: size OBJECT

Accesses the size as a REAL.

This number only makes sense in conjunction with the UNIT.

See SIZED

Package

cl-markless-components

Writer

(setf size) (generic function)

Methods
Method: size (SIZED sized)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf size) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

size (generic function)

Methods
Method: (setf size) NEW-VALUE (SIZED sized)

automatically generated writer method

Source

component.lisp (file)

Generic Function: source OBJECT

Accesses the blockquote-header source associated with the blockquote.

See BLOCKQUOTE-HEADER
See BLOCKQUOTE

Package

cl-markless-components

Writer

(setf source) (generic function)

Methods
Method: source (BLOCKQUOTE blockquote)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf source) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

source (generic function)

Methods
Method: (setf source) NEW-VALUE (BLOCKQUOTE blockquote)

automatically generated writer method

Source

component.lisp (file)

Generic Function: stack OBJECT

Accesses the stack of components and directives of the parser.

It is NOT safe to modify or set this stack after the parser has been constructed. This stack must be a vector with element-type STACK-ENTRY and a fill-pointer.

See PARSER
See STACK-ENTRY
See STACK-PUSH
See STACK-POP
See STACK-TOP
See STACK-BOTTOM

Package

cl-markless

Writer

(setf stack) (generic function)

Methods
Method: stack (PARSER parser)

automatically generated reader method

Source

parser.lisp (file)

Generic Function: (setf stack) NEW-VALUE OBJECT
Package

cl-markless

Reader

stack (generic function)

Methods
Method: (setf stack) NEW-VALUE (PARSER parser)

automatically generated writer method

Source

parser.lisp (file)

Generic Function: target OBJECT

Accesses the target of the given object.

The target is a path to an internal or external resource.

See EMBED
See FOOTNOTE
See URL
See LINK-OPTION
See FOOTNOTE-REFERENCE

Package

cl-markless-components

Writer

(setf target) (generic function)

Methods
Method: target (FOOTNOTE-REFERENCE footnote-reference)

automatically generated reader method

Source

component.lisp (file)

Method: target (LINK-OPTION link-option)

automatically generated reader method

Source

component.lisp (file)

Method: target (URL url)

automatically generated reader method

Source

component.lisp (file)

Method: target (FOOTNOTE footnote)

automatically generated reader method

Source

component.lisp (file)

Method: target (LABEL-OPTION label-option)

automatically generated reader method

Source

component.lisp (file)

Method: target (EMBED embed)

automatically generated reader method

Source

component.lisp (file)

Method: target (LABEL label)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf target) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

target (generic function)

Methods
Method: (setf target) NEW-VALUE (FOOTNOTE-REFERENCE footnote-reference)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (LINK-OPTION link-option)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (URL url)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (FOOTNOTE footnote)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (LABEL-OPTION label-option)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (EMBED embed)

automatically generated writer method

Source

component.lisp (file)

Method: (setf target) NEW-VALUE (LABEL label)

automatically generated writer method

Source

component.lisp (file)

Generic Function: text OBJECT

Accessor for the text string the component visualises.

See TEXT-COMPONENT

Package

cl-markless-components

Writer

(setf text) (generic function)

Methods
Method: text (COMPONENT parent-component)
Source

component.lisp (file)

Method: text (TEXT-COMPONENT text-component)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf text) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

text (generic function)

Methods
Method: (setf text) NEW-VALUE (TEXT-COMPONENT text-component)

automatically generated writer method

Source

component.lisp (file)

Generic Function: unit OBJECT

Accesses the unit of the size as a keyword.

The Markless standard defines the following units:
- :EM Applicable for font sizes expressed in relative width.
- :PT Applicable for font sizes expressed in absolute points.
- :PX Applicable for dimensions expressed in absolute pixels.
- :% Applicable for dimensions expressed in relative percentage to its container.

See SIZED

Package

cl-markless-components

Writer

(setf unit) (generic function)

Methods
Method: unit (SIZED sized)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf unit) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

unit (generic function)

Methods
Method: (setf unit) NEW-VALUE (SIZED sized)

automatically generated writer method

Source

component.lisp (file)

Generic Function: value OBJECT

Accesses the value of the set instruction.

This should be a string representing the new value.

See SET

Package

cl-markless-components

Writer

(setf value) (generic function)

Methods
Method: value (SET set)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf value) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

value (generic function)

Methods
Method: (setf value) NEW-VALUE (SET set)

automatically generated writer method

Source

component.lisp (file)

Generic Function: value CONDITION

Returns the variable value related to the condition.

See BAD-VALUE

Package

cl-markless

Methods
Method: value (CONDITION bad-value)
Source

conditions.lisp (file)

Generic Function: variable OBJECT

Accesses the variable of the set instruction.

This should be a string naming the variable in question.

See SET

Package

cl-markless-components

Writer

(setf variable) (generic function)

Methods
Method: variable (SET set)

automatically generated reader method

Source

component.lisp (file)

Generic Function: (setf variable) NEW-VALUE OBJECT
Package

cl-markless-components

Reader

variable (generic function)

Methods
Method: (setf variable) NEW-VALUE (SET set)

automatically generated writer method

Source

component.lisp (file)

Generic Function: variable-name CONDITION

Returns the name of the variable related to the condition.

See BAD-VARIABLE
See BAD-VALUE

Package

cl-markless

Methods
Method: variable-name (CONDITION bad-value)
Source

conditions.lisp (file)

Method: variable-name (CONDITION bad-variable)
Source

conditions.lisp (file)


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

5.1.5 Conditions

Condition: bad-option ()

Warning signalled if an option is malformed or unknown.

See OPTION
See PARSER-ERROR

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-warning (condition)

Direct subclasses
Direct methods

option (method)

Direct slots
Slot: option
Initargs

:option

Readers

option (generic function)

Condition: bad-unit ()

Warning signalled if the size contains an unknown unit.

See BAD-OPTION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

bad-option (condition)

Condition: bad-value ()

Error signalled if a set instruction contains an malformed or invalid value for a variable.

See VARIABLE-NAME
See VALUE
See PARSER-ERROR

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-error (condition)

Direct methods
Direct slots
Slot: variable
Initargs

:variable

Readers

variable-name (generic function)

Slot: value
Initargs

:value

Readers

value (generic function)

Condition: bad-variable ()

Error signalled if a set instruction refers to an unknown variable.

See VARIABLE-NAME
See PARSER-ERROR

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-error (condition)

Direct methods

variable-name (method)

Direct slots
Slot: variable
Initargs

:variable

Readers

variable-name (generic function)

Condition: deactivation-disallowed ()

Error signalled if an attempt is made to deactivate a directive that cannot be deactivated.

See DIRECTIVE-INSTANCE
See MARKLESS-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses
Direct methods

directive-instance (method)

Direct slots
Slot: directive
Initargs

:directive

Readers

directive-instance (generic function)

Condition: implementation-condition ()

Superclass for all conditions that indicate an error in the parser implementation.

See MARKLESS-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

markless-condition (condition)

Direct subclasses
Condition: instruction-evaluation-undefined ()

Error signalled when an instruction is not fully implemented.

See INSTRUCTION
See IMPLEMENTATION-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses
Direct methods

instruction (method)

Direct slots
Slot: instruction
Initargs

:instruction

Readers

instruction (generic function)

Condition: markless-condition ()

Superclass for all conditions related to markless.

See CL:CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses
Condition: option-disallowed ()

Warning signalled if an option is attempted to be used for an embed that does not allow it.

See EMBED-TYPE
See BAD-OPTION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

bad-option (condition)

Direct methods

embed-type (method)

Direct slots
Slot: embed-type
Initargs

:embed-type

Readers

embed-type (generic function)

Condition: parser-condition ()

Superclass for all conditions that relate to the parsing process.

See LINE
See CURSOR
See MARKLESS-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

markless-condition (condition)

Direct subclasses
Direct methods
Direct slots
Slot: line
Initargs

:line

Readers

line (generic function)

Slot: cursor
Initargs

:cursor

Readers

cursor (generic function)

Direct Default Initargs
InitargValue
:cursor0
:linecl-markless::*current-line-number*
Condition: parser-error ()

Superclass for all conditions that relate to fatal parser errors.

See PARSER-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses
Direct subclasses
Condition: parser-warning ()

Superclass for all conditions that relate to recoverable parser errors.

See PARSER-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses
Direct subclasses
Condition: stack-exhausted ()

Error signalled when the directive stack is under- or overflowed.

See IMPLEMENTATION-CONDITION

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses
Condition: unknown-embed-type ()

Warning signalled if an embed type is encountered that is unknown.

See EMBED-TYPE
See PARSER-WARNING

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-warning (condition)

Direct methods

embed-type (method)

Direct slots
Slot: embed-type
Initargs

:embed-type

Readers

embed-type (generic function)

Condition: unknown-instruction ()

Error signalled if an instruction is encountered that is unknown.

See INSTRUCTION
See PARSER-ERROR

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-error (condition)

Direct methods

instruction (method)

Direct slots
Slot: instruction
Initargs

:instruction

Readers

instruction (generic function)

Condition: user-error ()

Error signalled when an error instruction is encountered.

See MESSAGE
See PARSER-WARNING

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-error (condition)

Direct methods

message (method)

Direct slots
Slot: message
Initargs

:message

Readers

message (generic function)

Condition: user-warning ()

Warning signalled when a warn instruction is encountered.

See MESSAGE
See PARSER-WARNING

Package

cl-markless

Source

conditions.lisp (file)

Direct superclasses

parser-warning (condition)

Direct methods

message (method)

Direct slots
Slot: message
Initargs

:message

Readers

message (generic function)


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

5.1.6 Structures

Structure: stack-entry ()

Representation of an entry on the parse stack.

See STACK-ENTRY-COMPONENT
See STACK-ENTRY-DIRECTIVE
See STACK

Package

cl-markless

Source

parser.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: directive
Readers

stack-entry-directive (function)

Writers

(setf stack-entry-directive) (function)

Slot: component
Readers

stack-entry-component (function)

Writers

(setf stack-entry-component) (function)


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

5.1.7 Classes

Class: audio ()

Representation of the AUDIO embed type.

See EMBED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed (class)

Direct methods
Class: autoplay-option ()

Represents an autoplay option.

Causes the embed to automatically start playback.

See EMBED-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed-option (class)

Direct methods
Class: block-component ()

A component that encompasses a block of text.

See COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

component (class)

Direct subclasses
Class: block-directive ()

Superclass for all block directives.

Provides default methods for END and INVOKE.

See END
See INVOKE
See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

directive (class)

Direct subclasses
Direct methods
Class: blockquote ()

Represents a blockquote.

If the blockquote’s SOURCE is available, it should be displayed alongside the blockquote in the resulting document.

See SOURCE
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: source
Initargs

:source

Readers

source (generic function)

Writers

(setf source) (generic function)

Class: blockquote ()

The directive for a blockquote.

See CL-MARKLESS-COMPONENTS:BLOCKQUOTE See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct methods
Class: blockquote-header ()

Represents the header of a blockquote.

The header should typically not be directly translated into a resulting component, but instead be represented alongside the blockquote with which it is associated.

See SOURCE
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: blockquote-header ()

The directive for the header of a blockquote.

See CL-MARKLESS-COMPONENTS:BLOCKQUOTE-HEADER See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: bold ()

Representation of bold text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: bold ()

The directive for a bold markup.

See CL-MARKLESS-COMPONENTS:BOLD See SURROUNDING-INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

surrounding-inline-directive (class)

Direct methods
Class: bold-option ()

Representation of the bold compound option.

See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Class: caption-option ()
Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Class: code ()

Representation of literal text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: code ()

The directive for a code markup.

See CL-MARKLESS-COMPONENTS:CODE See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: code-block ()

Representation of a block of literal text.

See LANGUAGE
See OPTIONS
See TEXT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: language
Initargs

:language

Readers

language (generic function)

Writers

(setf language) (generic function)

Slot: options
Initargs

:options

Readers

options (generic function)

Writers

(setf options) (generic function)

Slot: depth
Initargs

:depth

Initform

0

Readers

depth (generic function)

Writers

(setf depth) (generic function)

Class: code-block ()

The directive for a code block.

See CL-MARKLESS-COMPONENTS:CODE-BLOCK See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct methods
Class: color-option ()

Representation of the color compound option.

See RED
See GREEN
See BLUE
See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Direct methods
Direct slots
Slot: red
Initargs

:red

Initform

(error "red required")

Readers

red (generic function)

Writers

(setf red) (generic function)

Slot: green
Initargs

:green

Initform

(error "green required")

Readers

green (generic function)

Writers

(setf green) (generic function)

Slot: blue
Initargs

:blue

Initform

(error "blue required")

Readers

blue (generic function)

Writers

(setf blue) (generic function)

Class: comment ()

Represents a comment.

See TEXT-COMPONENT See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: comment ()

The directive for a comment.

See CL-MARKLESS-COMPONENTS:COMMENT See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: component ()

Base class for all components that make up the AST of a parse result.

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: compound ()

Representation of text with a combination of stylistic transforms applied.

See PARENT-COMPONENT
See OPTIONS

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: options
Initargs

:options

Readers

options (generic function)

Writers

(setf options) (generic function)

Class: compound ()

The directive for a compound markup.

The parsing of the compound options is handled by PARSE-COMPOUND-OPTION.

See CL-MARKLESS-COMPONENTS:COMPOUND
See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: compound-option ()

Superclass for all compound options.

Every concrete subclass must have the suffix -OPTION.

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: dash ()

The directive for a dash.

See CL-MARKLESS-COMPONENTS:DASH See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: debug ()

Output format for debugging and AST visualisation.

This prints all AST contents in an easy to read form, useful for debugging.

Package

cl-markless

Source

printer.lisp (file)

Direct superclasses

output-format (class)

Direct methods
Class: directive ()

Superclass for all directives.

All matching for syntax in Markless is performed by what are called directives. They control the parsing and compiling behaviour.

A directive will only match if it is currently enabled.

See ENABLED-P

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • print-object (method)
  • enabled-p (method)
  • enabled-p (method)
Direct slots
Slot: enabled-p
Initargs

:enabled-p

Initform

t

Readers

enabled-p (generic function)

Writers

(setf enabled-p) (generic function)

Class: directives-instruction ()

Superclass for all instructions that carry a list of directives.

See DIRECTIVES
See INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

instruction (class)

Direct subclasses
Direct methods
Direct slots
Slot: directives
Initargs

:directives

Initform

(error "directives required.")

Readers

directives (generic function)

Writers

(setf directives) (generic function)

Class: disable ()

Represents a DISABLE instruction.

See DIRECTIVES-INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

directives-instruction (class)

Direct methods

evaluate-instruction (method)

Class: em-dash ()

Representation of an em-dash.

See UNIT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

unit-component (class)

Class: embed ()

Represents an embed block.

An embed embeds an outside resource into the document. Resolution of the target is left up to the translator to the resulting document.

See TARGET
See OPTIONS
See UNIT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct subclasses
Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Slot: options
Initargs

:options

Readers

options (generic function)

Writers

(setf options) (generic function)

Class: embed ()

The directive for an embed.

The parsing of the embed options is handled by PARSE-EMBED-OPTION. Whether an option is permitted for a given embed type is determined by EMBED-OPTION-ALLOWED-P. If NIL is returned for any one option, an error of type OPTION-DISALLOWED is signalled.

See PARSE-EMBED-OPTION
See EMBED-OPTION-ALLOWED-P
See OPTION-DISALLOWED
See CL-MARKLESS-COMPONENTS:EMBED
See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: embed-option ()

Superclass for all options for an embed component.

Every concrete subclass must have the suffix -OPTION.

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: en-dash ()

Representation of an en-dash.

See UNIT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

unit-component (class)

Class: enable ()

Represents an ENABLE instruction.

See DIRECTIVES-INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

directives-instruction (class)

Direct methods

evaluate-instruction (method)

Class: error ()

Represents an ERROR instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

message-instruction (class)

Direct methods

evaluate-instruction (method)

Class: float-option ()

Represents a float option.

Causes the embed to float within the other blocks.

See DIRECTION
See EMBED-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed-option (class)

Direct methods
Direct slots
Slot: direction
Initargs

:direction

Initform

(error "direction required")

Readers

direction (generic function)

Writers

(setf direction) (generic function)

Class: font-option ()

Representation of the font compound option.

See FONT-FAMILY
See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Direct methods
Direct slots
Slot: font-family
Initargs

:font-family

Initform

(error "font-family required")

Readers

font-family (generic function)

Writers

(setf font-family) (generic function)

Class: footnote ()

Representation of a footnote definition.

Footnotes should typically appear at the end of a page or the full document regardless of their position in the structure.

See TARGET
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: footnote ()

The directive for a footnote.

See CL-MARKLESS-COMPONENTS:FOOTNOTE See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: footnote-reference ()

Representation of a reference to a footnote.

See TARGET
See UNIT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: footnote-reference ()

The directive for a footnote reference.

See CL-MARKLESS-COMPONENTS:FOOTNOTE-REFERENCE See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: header ()

Representation of a section heading.

Each header must have a section depth number.

See DEPTH
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: depth
Initargs

:depth

Initform

0

Readers

depth (generic function)

Writers

(setf depth) (generic function)

Class: header ()

The directive for a section header.

See CL-MARKLESS-COMPONENTS:HEADER See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: height-option ()

Represents a height option.

Causes the embed to restrict its height to the given size.

See EMBED-OPTION
See SIZED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Class: horizontal-rule ()

Representation of a horizontal rule.

See UNIT-COMPONENT
see BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: horizontal-rule ()

The directive for a horizontal rule.

See CL-MARKLESS-COMPONENTS:HORIZONTAL-RULE See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods
Class: image ()

Representation of the IMAGE embed type.

See EMBED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed (class)

Class: include ()

Represents an INCLUDE instruction

See FILE
See INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: file
Initargs

:file

Initform

(error "file required")

Readers

file (generic function)

Writers

(setf file) (generic function)

Class: info ()

Represents an INFO instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

message-instruction (class)

Direct methods

evaluate-instruction (method)

Class: inline-component ()

A component that encompasses an inline section of text.

See COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

component (class)

Direct subclasses
Class: inline-directive ()

Superclass for all inline directives.

Provides default methods for CONSUME-PREFIX, END, and INVOKE.

See CONSUME-PREFIX
See END
See INVOKE
See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

directive (class)

Direct subclasses
Direct methods
Class: instruction ()

Superclass for all instructions.

See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

block-component (class)

Direct subclasses
Direct methods

output-component (method)

Class: instruction ()

The directive for an instruction.

The parsing of the actual type of directive is handled by PARSE-INSTRUCTION. The instruction is parsed fully on BEGIN and then evaluated on INVOKE.

See PARSE-INSTRUCTION
See EVALUATE-INSTRUCTION
See CL-MARKLESS-COMPONENTS:INSTRUCTION
See SINGULAR-LINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

singular-line-directive (class)

Direct methods

Representation of an internal link option.

See LINK-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

link-option (class)

Direct methods

output-component (method)

Class: italic ()

Representation of italic text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: italic ()

The directive for an italic markup.

See CL-MARKLESS-COMPONENTS:ITALIC See SURROUNDING-INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

surrounding-inline-directive (class)

Direct methods
Class: italic-option ()

Representation of the italic compound option.

See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Class: label ()

Represents a LABEL instruction

See TARGET
See INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: label-option ()
Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed-option (class)

Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Representation of the link option.

See TARGET
See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Direct subclasses

internal-link-option (class)

Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: list ()

Superclass for all list type components.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

parent-component (class)

Direct subclasses
Class: list-item ()

Superclass for all list item type components.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

parent-component (class)

Direct subclasses
Class: loop-option ()

Represents a loop option.

Causes the embed to loop its content.

See EMBED-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed-option (class)

Direct methods
Class: markless ()

Output format that prints to valid Markless again.

This should allow you to construct arbitrary component ASTs and generate valid Markless documents.

See OUTPUT

Package

cl-markless

Source

printer.lisp (file)

Direct superclasses

output-format (class)

Direct methods
Class: message-instruction ()

Superclass for all instructions that carry a message.

See MESSAGE
See INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

instruction (class)

Direct subclasses
Direct methods
Direct slots
Slot: message
Initargs

:message

Initform

(error "message required")

Readers

message (generic function)

Writers

(setf message) (generic function)

Class: newline ()

Representation of a line break.

See UNIT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

unit-component (class)

Class: newline ()

The directive for an explicit newline.

See CL-MARKLESS-COMPONENTS:NEWLINE See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: ordered-list ()

Representation of an ordered list.

The child array should only contain ORDERED-LIST-ITEMs.

See LIST
See BLOCK-COMPONENT
See ORDERED-LIST-ITEM

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Class: ordered-list ()

The directive for an ordered list and its items.

See CL-MARKLESS-COMPONENTS:ORDERED-LIST
See CL-MARKLESS-COMPONENTS:ORDERED-LIST-ITEM See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct methods
Class: ordered-list-item ()

Representation of an item in an ordered list.

Each item has an associated order number.

See NUMBER
See LIST-ITEM
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: number
Initargs

:number

Initform

0

Readers

number (generic function)

Writers

(setf number) (generic function)

Class: output-format ()

Superclass for all output formats.

If you define a new format, you should define a new subclass to this and specialise on your new class in your OUTPUT-COMPONENT methods.

See OUTPUT-COMPONENT

Package

cl-markless

Source

printer.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Class: paragraph ()

Represents a textual paragraph.

See INDENTATION
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: indentation
Initargs

:indentation

Initform

0

Readers

indentation (generic function)

Writers

(setf indentation) (generic function)

Class: paragraph ()

The directive for a paragraph.

This is a very important directive as it acts as the fallback in pretty much every situation and has the most complex parser logic associated with it.

See CL-MARKLESS-COMPONENTS:PARAGRAPH
See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct methods
Class: parent-component ()

A component that contains text and subcomponents.

See CHILDREN
See COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

component (class)

Direct subclasses
Direct methods
Direct slots
Slot: children
Initargs

:children

Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

children (generic function)

Writers

(setf children) (generic function)

Class: parser ()

Representation of the parsing state necessary to parse a Markless document.

A parser instance is required in order to parse a document. While it is permitted to re-use a parser instance for subsequent parsing, it is /NOT/ allowed to use the same parser concurrently. Concurrent parsing or access of the parser will lead to undefined consequences.

When constructing the parser you may pass a list of directives the parser should support via the :DIRECTIVES argument. You can also by-default disable some of those directives by putting their names into the :DISABLED-DIRECTIVES argument. Note that disabling a directive is not the same as leaving it out of the :DIRECTIVES list completely. If it is only disabled it can be enabled via the ENABLE instruction during parsing. The :STACK-SIZE-LIMIT argument sets the maximal nesting permitted when parsing. If directives are nested more deeply than this, parsing of the document will fail. The default is set to 64.

Note that even though subsequent re-use of the parser is permitted, changes carried out by an INSTRUCTION during a parse will not be reset on a subsequent parse, so instructions can poison subsequent parses. If the INSTRUCTION directive is excluded, subsequent parses should be clean however.

See LINE-BREAK-MODE
See DIRECTIVES
See DIRECTIVE
See ENABLE
See DISABLE
See EVALUATE-INSTRUCTION
See BLOCK-DISPATCH-TABLE
See INLINE-DISPATCH-TABLE
See INPUT
See STACK
See PARSE
See COMMIT
See ROOT

Package

cl-markless

Source

parser.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: line-break-mode
Initargs

:line-break-mode

Initform

:show

Readers

line-break-mode (generic function)

Writers

(setf line-break-mode) (generic function)

Slot: directives
Readers

directives (generic function)

Writers

(setf directives) (generic function)

Slot: block-dispatch-table
Readers

block-dispatch-table (generic function)

Writers

(setf block-dispatch-table) (generic function)

Slot: inline-dispatch-table
Readers

inline-dispatch-table (generic function)

Writers

(setf inline-dispatch-table) (generic function)

Slot: input
Readers

input (generic function)

Writers

(setf input) (generic function)

Slot: stack
Readers

stack (generic function)

Writers

(setf stack) (generic function)

Class: root-component ()

The base component that makes up a parsed document’s AST.

This component also stores cross references and document metadata.

See PARENT-COMPONENT
See LABELS
See AUTHOR
See LANGUAGE
See COPYRIGHT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

parent-component (class)

Direct methods
  • label (method)
  • label (method)
  • label (method)
  • print-object (method)
  • language (method)
  • language (method)
  • copyright (method)
  • copyright (method)
  • author (method)
  • author (method)
  • labels (method)
  • labels (method)
Direct slots
Slot: labels
Initform

(make-hash-table :test (quote equalp))

Readers

labels (generic function)

Writers

(setf labels) (generic function)

Slot: author
Readers

author (generic function)

Writers

(setf author) (generic function)

Readers

copyright (generic function)

Writers

(setf copyright) (generic function)

Slot: language
Readers

language (generic function)

Writers

(setf language) (generic function)

Class: root-directive ()

Represents the root parser entry.

The root directive is always at the bottom of the stack. It is responsible for matching and invoking the block directives at the top level of the document.

The root directive cannot be disabled.

See DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

directive (class)

Direct methods
Class: set ()

Representation of a SET instruction.

This instruction changes a state variable.

See VARIABLE
See VALUE
See INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: variable
Initargs

:variable

Initform

(error "variable required")

Readers

variable (generic function)

Writers

(setf variable) (generic function)

Slot: value
Initargs

:value

Initform

(error "value required")

Readers

value (generic function)

Writers

(setf value) (generic function)

Class: singular-line-directive ()

Superclass for all single-line block directives.

Provides default methods for CONSUME-PREFIX and INVOKE.

See END
See INVOKE
See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct subclasses
Direct methods
Class: size-option ()

Representation of the size compound option.

See COMPOUND-OPTION
See SIZED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Class: sized ()

Superclass for classes that represent a size in a particular unit.

See UNIT
See SIZE

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
  • print-object (method)
  • size (method)
  • size (method)
  • unit (method)
  • unit (method)
Direct slots
Slot: unit
Initargs

:unit

Initform

(error "unit required")

Readers

unit (generic function)

Writers

(setf unit) (generic function)

Slot: size
Initargs

:size

Initform

(error "size required")

Readers

size (generic function)

Writers

(setf size) (generic function)

Class: spoiler-option ()

Representation of the spoiler compound option.

See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Class: strikethrough ()

Representation of struck-through text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: strikethrough ()

The directive for a strikethrough markup.

See CL-MARKLESS-COMPONENTS:STRIKETHROUGH See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: strikethrough-option ()

Representation of the strikethrough compound option.

See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Class: subtext ()

Representation of text sunk below normal text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: subtext ()

The directive for a subtext markup.

See CL-MARKLESS-COMPONENTS:SUBTEXT See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: supertext ()

Representation of text raised above normal text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: supertext ()

The directive for a supertext markup.

See CL-MARKLESS-COMPONENTS:SUPERTEXT See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: surrounding-inline-directive ()

Superclass for select surrounding inline directives.

Provides a method for BEGIN that automatically pops the stack and advances the cursor if the current directive at the top of the stack is the same as this directive. This is useful for surrounding inline directives whose postfix is the same as their prefix.

See BEGIN
See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct subclasses
Direct methods

begin (method)

Class: text-component ()

A component with a text field

See TEXT
See COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

component (class)

Direct subclasses
Direct methods
  • text (method)
  • text (method)
Direct slots
Slot: text
Initargs

:text

Initform

(error "text required")

Readers

text (generic function)

Writers

(setf text) (generic function)

Class: underline ()

Representation of underlined text.

See PARENT-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: underline ()

The directive for an underline markup.

See CL-MARKLESS-COMPONENTS:UNDERLINE See SURROUNDING-INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

surrounding-inline-directive (class)

Direct methods
Class: underline-option ()

Representation of the underline compound option.

See COMPOUND-OPTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

compound-option (class)

Class: unit-component ()

A component without children that represents a visual part of the document.

See COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

component (class)

Direct subclasses
Direct methods
Class: unordered-list ()

Representation of an unordered list.

The child array should only contain UNORDERED-LIST-ITEMs.

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Class: unordered-list ()

The directive for an unordered list and its items.

See CL-MARKLESS-COMPONENTS:UNORDERED-LIST
See CL-MARKLESS-COMPONENTS:UNORDERED-LIST-ITEM See BLOCK-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

block-directive (class)

Direct methods
Class: unordered-list-item ()

Representation of an item in an unordered list.

See LIST-ITEM
See BLOCK-COMPONENT

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

output-component (method)

Class: url ()

Representation of a literal URL.

See UNIT-COMPONENT
See TARGET

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: target
Initargs

:target

Initform

(error "target required")

Readers

target (generic function)

Writers

(setf target) (generic function)

Class: url ()

The directive for an inline URL.

The handling of the URL directive is a bit special due to the lack of a dedicated prefix that can be uniquely matched to initiate the scan of an URL. Thus, special handling code in READ-INLINE is present to make this case at least somewhat efficient.

This directive will, unlike all others, return the same cursor on BEGIN if the complete URL does not match.

See CL-MARKLESS-COMPONENTS:URL
See INLINE-DIRECTIVE

Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

inline-directive (class)

Direct methods
Class: video ()

Representation of the VIDEO embed type.

See EMBED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

embed (class)

Direct methods
Class: warning ()

Represents a WARNING instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses

message-instruction (class)

Direct methods

evaluate-instruction (method)

Class: width-option ()

Represents a width option.

Causes the embed to restrict its width to the given size.

See EMBED-OPTION
See SIZED

Package

cl-markless-components

Source

component.lisp (file)

Direct superclasses
Direct methods

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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *current-line-number*
Package

cl-markless

Source

conditions.lisp (file)

Special Variable: *level*
Package

cl-markless

Source

printer.lisp (file)

Special Variable: *prefixes*
Package

cl-markless

Source

printer.lisp (file)


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

5.2.2 Macros

Macro: define-printer CLASS FORMAT &rest ARGS
Package

cl-markless-components

Source

component.lisp (file)


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

5.2.3 Functions

Function: class-prototype CLASS
Package

cl-markless

Source

toolkit.lisp (file)

Function: copy-stack-entry INSTANCE
Package

cl-markless

Source

parser.lisp (file)

Function: decompose-rgb HEX

Decomposes the 24-bit hexadecimal number into three 8-bit numbers.

Returns the RGB channels as a list.

Package

cl-markless

Source

toolkit.lisp (file)

Function: delegate-paragraph PARSER LINE CURSOR
Package

cl-markless

Source

toolkit.lisp (file)

Function: find-subclass SUBCLASSISH CLASS
Package

cl-markless

Source

toolkit.lisp (file)

Function: make-color-table ENTRIES
Package

cl-markless

Source

color-table.lisp (file)

Function: make-size-table ENTRIES
Package

cl-markless

Source

size-table.lisp (file)

Function: make-stack-entry &key (DIRECTIVE DIRECTIVE) (COMPONENT COMPONENT)
Package

cl-markless

Source

parser.lisp (file)

Function: next-option LINE CURSOR END
Package

cl-markless

Source

toolkit.lisp (file)

Function: parse-unit STRING &key START

Parses the given string as a number with a unit at the end.

The following unit types are supported:
- em
- pt
- px
- %
Any other unit, or a missing unit, will signal a warning of type BAD-UNIT and returns NIL as the unit.

Returns the size and its unit as multiple values.

Package

cl-markless

Source

toolkit.lisp (file)

Function: pop-newline STACK
Package

cl-markless

Source

parser.lisp (file)

Function: process-stack PARSER STACK LINE
Package

cl-markless

Source

parser.lisp (file)

Function: remf* PLIST &rest EXCLUDED-KEYS
Package

cl-markless

Source

toolkit.lisp (file)

Function: split-options LINE CURSOR END

Splits the given options string into a list of options.

Options are separated via commas. Returns a list of the matched options and the new cursor position as multiple values.

This does properly handle backslash escaping.

Package

cl-markless

Source

toolkit.lisp (file)

Function: stack-entry-p OBJECT
Package

cl-markless

Source

parser.lisp (file)

Function: subclasses CLASS
Package

cl-markless

Source

toolkit.lisp (file)

Function: vector-push-front ELEMENT VECTOR
Package

cl-markless

Source

toolkit.lisp (file)


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

5.2.4 Classes

Class: noop ()
Package

cl-markless

Source

directive.lisp (file)

Direct superclasses

directive (class)

Direct methods

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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cl-markless.asd: The cl-markless<dot>asd file
cl-markless/color-table.lisp: The cl-markless/color-table<dot>lisp file
cl-markless/component.lisp: The cl-markless/component<dot>lisp file
cl-markless/conditions.lisp: The cl-markless/conditions<dot>lisp file
cl-markless/directive.lisp: The cl-markless/directive<dot>lisp file
cl-markless/documentation.lisp: The cl-markless/documentation<dot>lisp file
cl-markless/package.lisp: The cl-markless/package<dot>lisp file
cl-markless/parser.lisp: The cl-markless/parser<dot>lisp file
cl-markless/printer.lisp: The cl-markless/printer<dot>lisp file
cl-markless/size-table.lisp: The cl-markless/size-table<dot>lisp file
cl-markless/toolkit.lisp: The cl-markless/toolkit<dot>lisp file

F
File, Lisp, cl-markless.asd: The cl-markless<dot>asd file
File, Lisp, cl-markless/color-table.lisp: The cl-markless/color-table<dot>lisp file
File, Lisp, cl-markless/component.lisp: The cl-markless/component<dot>lisp file
File, Lisp, cl-markless/conditions.lisp: The cl-markless/conditions<dot>lisp file
File, Lisp, cl-markless/directive.lisp: The cl-markless/directive<dot>lisp file
File, Lisp, cl-markless/documentation.lisp: The cl-markless/documentation<dot>lisp file
File, Lisp, cl-markless/package.lisp: The cl-markless/package<dot>lisp file
File, Lisp, cl-markless/parser.lisp: The cl-markless/parser<dot>lisp file
File, Lisp, cl-markless/printer.lisp: The cl-markless/printer<dot>lisp file
File, Lisp, cl-markless/size-table.lisp: The cl-markless/size-table<dot>lisp file
File, Lisp, cl-markless/toolkit.lisp: The cl-markless/toolkit<dot>lisp file

L
Lisp File, cl-markless.asd: The cl-markless<dot>asd file
Lisp File, cl-markless/color-table.lisp: The cl-markless/color-table<dot>lisp file
Lisp File, cl-markless/component.lisp: The cl-markless/component<dot>lisp file
Lisp File, cl-markless/conditions.lisp: The cl-markless/conditions<dot>lisp file
Lisp File, cl-markless/directive.lisp: The cl-markless/directive<dot>lisp file
Lisp File, cl-markless/documentation.lisp: The cl-markless/documentation<dot>lisp file
Lisp File, cl-markless/package.lisp: The cl-markless/package<dot>lisp file
Lisp File, cl-markless/parser.lisp: The cl-markless/parser<dot>lisp file
Lisp File, cl-markless/printer.lisp: The cl-markless/printer<dot>lisp file
Lisp File, cl-markless/size-table.lisp: The cl-markless/size-table<dot>lisp file
Lisp File, cl-markless/toolkit.lisp: The cl-markless/toolkit<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   I   L   M   N   O   P   R   S   T   U   V  
Index Entry  Section

(
(setf author): Exported generic functions
(setf author): Exported generic functions
(setf block-dispatch-table): Exported generic functions
(setf block-dispatch-table): Exported generic functions
(setf blue): Exported generic functions
(setf blue): Exported generic functions
(setf children): Exported generic functions
(setf children): Exported generic functions
(setf copyright): Exported generic functions
(setf copyright): Exported generic functions
(setf depth): Exported generic functions
(setf depth): Exported generic functions
(setf depth): Exported generic functions
(setf direction): Exported generic functions
(setf direction): Exported generic functions
(setf directives): Exported generic functions
(setf directives): Exported generic functions
(setf directives): Exported generic functions
(setf directives): Exported generic functions
(setf enabled-p): Exported generic functions
(setf enabled-p): Exported generic functions
(setf enabled-p): Exported generic functions
(setf enabled-p): Exported generic functions
(setf file): Exported generic functions
(setf file): Exported generic functions
(setf font-family): Exported generic functions
(setf font-family): Exported generic functions
(setf green): Exported generic functions
(setf green): Exported generic functions
(setf indentation): Exported generic functions
(setf indentation): Exported generic functions
(setf inline-dispatch-table): Exported generic functions
(setf inline-dispatch-table): Exported generic functions
(setf input): Exported generic functions
(setf input): Exported generic functions
(setf label): Exported generic functions
(setf labels): Exported generic functions
(setf labels): Exported generic functions
(setf language): Exported generic functions
(setf language): Exported generic functions
(setf language): Exported generic functions
(setf line-break-mode): Exported generic functions
(setf line-break-mode): Exported generic functions
(setf message): Exported generic functions
(setf message): Exported generic functions
(setf number): Exported generic functions
(setf number): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf red): Exported generic functions
(setf red): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf source): Exported generic functions
(setf source): Exported generic functions
(setf stack): Exported generic functions
(setf stack): Exported generic functions
(setf stack-entry-component): Exported functions
(setf stack-entry-directive): Exported functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf target): Exported generic functions
(setf text): Exported generic functions
(setf text): Exported generic functions
(setf unit): Exported generic functions
(setf unit): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf variable): Exported generic functions
(setf variable): Exported generic functions

A
author: Exported generic functions
author: Exported generic functions

B
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
begin: Exported generic functions
block-dispatch-table: Exported generic functions
block-dispatch-table: Exported generic functions
blue: Exported generic functions
blue: Exported generic functions

C
children: Exported generic functions
children: Exported generic functions
class-prototype: Internal functions
commit: Exported functions
compile-dispatch-table: Exported functions
condense-children: Exported functions
condense-component-tree: Exported functions
consume-end: Exported generic functions
consume-end: Exported generic functions
consume-end: Exported generic functions
consume-end: Exported generic functions
consume-end: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
consume-prefix: Exported generic functions
copy-stack-entry: Internal functions
copyright: Exported generic functions
copyright: Exported generic functions
cursor: Exported generic functions
cursor: Exported generic functions

D
decompose-rgb: Internal functions
define-output: Exported macros
define-printer: Internal macros
delegate-paragraph: Internal functions
depth: Exported generic functions
depth: Exported generic functions
depth: Exported generic functions
direction: Exported generic functions
direction: Exported generic functions
directive: Exported generic functions
directive: Exported generic functions
directive: Exported generic functions
directive-instance: Exported generic functions
directive-instance: Exported generic functions
directives: Exported generic functions
directives: Exported generic functions
directives: Exported generic functions
directives: Exported generic functions
directives-of: Exported generic functions
directives-of: Exported generic functions
disable: Exported generic functions
disable: Exported generic functions
dispatch: Exported functions

E
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-option-allowed-p: Exported generic functions
embed-type: Exported generic functions
embed-type: Exported generic functions
embed-type: Exported generic functions
enable: Exported generic functions
enable: Exported generic functions
enabled-p: Exported generic functions
enabled-p: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
ends-with: Exported functions
ensure-directive: Exported functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions
evaluate-instruction: Exported generic functions

F
file: Exported generic functions
file: Exported generic functions
find-subclass: Internal functions
font-family: Exported generic functions
font-family: Exported generic functions
Function, (setf stack-entry-component): Exported functions
Function, (setf stack-entry-directive): Exported functions
Function, class-prototype: Internal functions
Function, commit: Exported functions
Function, compile-dispatch-table: Exported functions
Function, condense-children: Exported functions
Function, condense-component-tree: Exported functions
Function, copy-stack-entry: Internal functions
Function, decompose-rgb: Internal functions
Function, delegate-paragraph: Internal functions
Function, dispatch: Exported functions
Function, ends-with: Exported functions
Function, ensure-directive: Exported functions
Function, find-subclass: Internal functions
Function, list-output-formats: Exported functions
Function, make-color-table: Internal functions
Function, make-size-table: Internal functions
Function, make-stack-entry: Internal functions
Function, next-option: Internal functions
Function, output: Exported functions
Function, parse-compound-option: Exported functions
Function, parse-embed-option: Exported functions
Function, parse-float: Exported functions
Function, parse-unit: Internal functions
Function, pop-newline: Internal functions
Function, process-stack: Internal functions
Function, read-block: Exported functions
Function, read-delimited: Exported functions
Function, read-full-line: Exported functions
Function, read-inline: Exported functions
Function, read-url: Exported functions
Function, remf*: Internal functions
Function, root: Exported functions
Function, split-options: Internal functions
Function, split-string: Exported functions
Function, stack-bottom: Exported functions
Function, stack-entry-component: Exported functions
Function, stack-entry-directive: Exported functions
Function, stack-entry-p: Internal functions
Function, stack-pop: Exported functions
Function, stack-push: Exported functions
Function, stack-top: Exported functions
Function, stack-unwind: Exported functions
Function, starts-with: Exported functions
Function, subclasses: Internal functions
Function, to-readtable-case: Exported functions
Function, vector-push-front: Internal functions

G
Generic Function, (setf author): Exported generic functions
Generic Function, (setf block-dispatch-table): Exported generic functions
Generic Function, (setf blue): Exported generic functions
Generic Function, (setf children): Exported generic functions
Generic Function, (setf copyright): Exported generic functions
Generic Function, (setf depth): Exported generic functions
Generic Function, (setf direction): Exported generic functions
Generic Function, (setf directives): Exported generic functions
Generic Function, (setf directives): Exported generic functions
Generic Function, (setf enabled-p): Exported generic functions
Generic Function, (setf file): Exported generic functions
Generic Function, (setf font-family): Exported generic functions
Generic Function, (setf green): Exported generic functions
Generic Function, (setf indentation): Exported generic functions
Generic Function, (setf inline-dispatch-table): Exported generic functions
Generic Function, (setf input): Exported generic functions
Generic Function, (setf label): Exported generic functions
Generic Function, (setf labels): Exported generic functions
Generic Function, (setf language): Exported generic functions
Generic Function, (setf line-break-mode): Exported generic functions
Generic Function, (setf message): Exported generic functions
Generic Function, (setf number): Exported generic functions
Generic Function, (setf options): Exported generic functions
Generic Function, (setf red): Exported generic functions
Generic Function, (setf size): Exported generic functions
Generic Function, (setf source): Exported generic functions
Generic Function, (setf stack): Exported generic functions
Generic Function, (setf target): Exported generic functions
Generic Function, (setf text): Exported generic functions
Generic Function, (setf unit): Exported generic functions
Generic Function, (setf value): Exported generic functions
Generic Function, (setf variable): Exported generic functions
Generic Function, author: Exported generic functions
Generic Function, begin: Exported generic functions
Generic Function, block-dispatch-table: Exported generic functions
Generic Function, blue: Exported generic functions
Generic Function, children: Exported generic functions
Generic Function, consume-end: Exported generic functions
Generic Function, consume-prefix: Exported generic functions
Generic Function, copyright: Exported generic functions
Generic Function, cursor: Exported generic functions
Generic Function, depth: Exported generic functions
Generic Function, direction: Exported generic functions
Generic Function, directive: Exported generic functions
Generic Function, directive-instance: Exported generic functions
Generic Function, directives: Exported generic functions
Generic Function, directives: Exported generic functions
Generic Function, directives-of: Exported generic functions
Generic Function, disable: Exported generic functions
Generic Function, embed-option-allowed-p: Exported generic functions
Generic Function, embed-type: Exported generic functions
Generic Function, enable: Exported generic functions
Generic Function, enabled-p: Exported generic functions
Generic Function, end: Exported generic functions
Generic Function, evaluate-instruction: Exported generic functions
Generic Function, file: Exported generic functions
Generic Function, font-family: Exported generic functions
Generic Function, green: Exported generic functions
Generic Function, indentation: Exported generic functions
Generic Function, inline-dispatch-table: Exported generic functions
Generic Function, input: Exported generic functions
Generic Function, instruction: Exported generic functions
Generic Function, invoke: Exported generic functions
Generic Function, label: Exported generic functions
Generic Function, labels: Exported generic functions
Generic Function, language: Exported generic functions
Generic Function, line: Exported generic functions
Generic Function, line-break-mode: Exported generic functions
Generic Function, message: Exported generic functions
Generic Function, message: Exported generic functions
Generic Function, number: Exported generic functions
Generic Function, option: Exported generic functions
Generic Function, options: Exported generic functions
Generic Function, output-component: Exported generic functions
Generic Function, parse: Exported generic functions
Generic Function, parse-compound-option-type: Exported generic functions
Generic Function, parse-embed-option-type: Exported generic functions
Generic Function, parse-instruction: Exported generic functions
Generic Function, prefix: Exported generic functions
Generic Function, red: Exported generic functions
Generic Function, size: Exported generic functions
Generic Function, source: Exported generic functions
Generic Function, stack: Exported generic functions
Generic Function, target: Exported generic functions
Generic Function, text: Exported generic functions
Generic Function, unit: Exported generic functions
Generic Function, value: Exported generic functions
Generic Function, value: Exported generic functions
Generic Function, variable: Exported generic functions
Generic Function, variable-name: Exported generic functions
green: Exported generic functions
green: Exported generic functions

I
indentation: Exported generic functions
indentation: Exported generic functions
inline-dispatch-table: Exported generic functions
inline-dispatch-table: Exported generic functions
input: Exported generic functions
input: Exported generic functions
instruction: Exported generic functions
instruction: Exported generic functions
instruction: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions
invoke: Exported generic functions

L
label: Exported generic functions
label: Exported generic functions
labels: Exported generic functions
labels: Exported generic functions
language: Exported generic functions
language: Exported generic functions
language: Exported generic functions
line: Exported generic functions
line: Exported generic functions
line-break-mode: Exported generic functions
line-break-mode: Exported generic functions
list-output-formats: Exported functions

M
Macro, define-output: Exported macros
Macro, define-printer: Internal macros
Macro, match!: Exported macros
make-color-table: Internal functions
make-size-table: Internal functions
make-stack-entry: Internal functions
match!: Exported macros
message: Exported generic functions
message: Exported generic functions
message: Exported generic functions
message: Exported generic functions
message: Exported generic functions
Method, (setf author): Exported generic functions
Method, (setf block-dispatch-table): Exported generic functions
Method, (setf blue): Exported generic functions
Method, (setf children): Exported generic functions
Method, (setf copyright): Exported generic functions
Method, (setf depth): Exported generic functions
Method, (setf depth): Exported generic functions
Method, (setf direction): Exported generic functions
Method, (setf directives): Exported generic functions
Method, (setf directives): Exported generic functions
Method, (setf enabled-p): Exported generic functions
Method, (setf enabled-p): Exported generic functions
Method, (setf enabled-p): Exported generic functions
Method, (setf file): Exported generic functions
Method, (setf font-family): Exported generic functions
Method, (setf green): Exported generic functions
Method, (setf indentation): Exported generic functions
Method, (setf inline-dispatch-table): Exported generic functions
Method, (setf input): Exported generic functions
Method, (setf labels): Exported generic functions
Method, (setf language): Exported generic functions
Method, (setf language): Exported generic functions
Method, (setf line-break-mode): Exported generic functions
Method, (setf message): Exported generic functions
Method, (setf number): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf red): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf source): Exported generic functions
Method, (setf stack): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf target): Exported generic functions
Method, (setf text): Exported generic functions
Method, (setf unit): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf variable): Exported generic functions
Method, author: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, begin: Exported generic functions
Method, block-dispatch-table: Exported generic functions
Method, blue: Exported generic functions
Method, children: Exported generic functions
Method, consume-end: Exported generic functions
Method, consume-end: Exported generic functions
Method, consume-end: Exported generic functions
Method, consume-end: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, consume-prefix: Exported generic functions
Method, copyright: Exported generic functions
Method, cursor: Exported generic functions
Method, depth: Exported generic functions
Method, depth: Exported generic functions
Method, direction: Exported generic functions
Method, directive: Exported generic functions
Method, directive: Exported generic functions
Method, directive-instance: Exported generic functions
Method, directives: Exported generic functions
Method, directives: Exported generic functions
Method, directives-of: Exported generic functions
Method, disable: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-option-allowed-p: Exported generic functions
Method, embed-type: Exported generic functions
Method, embed-type: Exported generic functions
Method, enable: Exported generic functions
Method, enabled-p: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, evaluate-instruction: Exported generic functions
Method, file: Exported generic functions
Method, font-family: Exported generic functions
Method, green: Exported generic functions
Method, indentation: Exported generic functions
Method, inline-dispatch-table: Exported generic functions
Method, input: Exported generic functions
Method, instruction: Exported generic functions
Method, instruction: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, invoke: Exported generic functions
Method, label: Exported generic functions
Method, labels: Exported generic functions
Method, language: Exported generic functions
Method, language: Exported generic functions
Method, line: Exported generic functions
Method, line-break-mode: Exported generic functions
Method, message: Exported generic functions
Method, message: Exported generic functions
Method, message: Exported generic functions
Method, number: Exported generic functions
Method, option: Exported generic functions
Method, options: Exported generic functions
Method, options: Exported generic functions
Method, options: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, output-component: Exported generic functions
Method, parse: Exported generic functions
Method, parse: Exported generic functions
Method, parse: Exported generic functions
Method, parse: Exported generic functions
Method, parse-compound-option-type: Exported generic functions
Method, parse-compound-option-type: Exported generic functions
Method, parse-compound-option-type: Exported generic functions
Method, parse-compound-option-type: Exported generic functions
Method, parse-compound-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-embed-option-type: Exported generic functions
Method, parse-instruction: Exported generic functions
Method, parse-instruction: Exported generic functions
Method, parse-instruction: Exported generic functions
Method, parse-instruction: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, prefix: Exported generic functions
Method, red: Exported generic functions
Method, size: Exported generic functions
Method, source: Exported generic functions
Method, stack: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, target: Exported generic functions
Method, text: Exported generic functions
Method, text: Exported generic functions
Method, unit: Exported generic functions
Method, value: Exported generic functions
Method, value: Exported generic functions
Method, variable: Exported generic functions
Method, variable-name: Exported generic functions
Method, variable-name: Exported generic functions

N
next-option: Internal functions
number: Exported generic functions
number: Exported generic functions

O
option: Exported generic functions
option: Exported generic functions
options: Exported generic functions
options: Exported generic functions
options: Exported generic functions
options: Exported generic functions
output: Exported functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions
output-component: Exported generic functions

P
parse: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
parse-compound-option: Exported functions
parse-compound-option-type: Exported generic functions
parse-compound-option-type: Exported generic functions
parse-compound-option-type: Exported generic functions
parse-compound-option-type: Exported generic functions
parse-compound-option-type: Exported generic functions
parse-compound-option-type: Exported generic functions
parse-embed-option: Exported functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-embed-option-type: Exported generic functions
parse-float: Exported functions
parse-instruction: Exported generic functions
parse-instruction: Exported generic functions
parse-instruction: Exported generic functions
parse-instruction: Exported generic functions
parse-instruction: Exported generic functions
parse-unit: Internal functions
pop-newline: Internal functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
prefix: Exported generic functions
process-stack: Internal functions

R
read-block: Exported functions
read-delimited: Exported functions
read-full-line: Exported functions
read-inline: Exported functions
read-url: Exported functions
red: Exported generic functions
red: Exported generic functions
remf*: Internal functions
root: Exported functions

S
size: Exported generic functions
size: Exported generic functions
source: Exported generic functions
source: Exported generic functions
split-options: Internal functions
split-string: Exported functions
stack: Exported generic functions
stack: Exported generic functions
stack-bottom: Exported functions
stack-entry-component: Exported functions
stack-entry-directive: Exported functions
stack-entry-p: Internal functions
stack-pop: Exported functions
stack-push: Exported functions
stack-top: Exported functions
stack-unwind: Exported functions
starts-with: Exported functions
subclasses: Internal functions

T
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
target: Exported generic functions
<