The cl-markless Reference Manual

This is the cl-markless Reference Manual, version 1.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 04:13:18 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 cl-markless

A parser implementation for Markless

Maintainer

Yukari Hafner <>

Author

Yukari Hafner <>

Home Page

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

License

zlib

Version

1.2.0

Dependencies
  • documentation-utils (system).
  • trivial-indent (system).
Source

cl-markless.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 cl-markless/cl-markless.asd

Source

cl-markless.asd.

Parent Component

cl-markless (system).

ASDF Systems

cl-markless.


3.1.2 cl-markless/package.lisp

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Packages

3.1.3 cl-markless/toolkit.lisp

Dependency

package.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

3.1.4 cl-markless/conditions.lisp

Dependency

toolkit.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

*current-line-number* (special variable).


3.1.5 cl-markless/component.lisp

Dependency

conditions.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

define-printer (macro).


3.1.6 cl-markless/color-table.lisp

Dependency

component.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface

*color-table* (special variable).

Internals

make-color-table (function).


3.1.7 cl-markless/size-table.lisp

Dependency

color-table.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface

*size-table* (special variable).

Internals

make-size-table (function).


3.1.8 cl-markless/printer.lisp

Dependency

size-table.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

3.1.9 cl-markless/parser.lisp

Dependency

printer.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

3.1.10 cl-markless/directive.lisp

Dependency

parser.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface
Internals

3.1.11 cl-markless/misc.lisp

Dependency

directive.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).

Public Interface

3.1.12 cl-markless/documentation.lisp

Dependency

misc.lisp (file).

Source

cl-markless.asd.

Parent Component

cl-markless (system).


4 Packages

Packages are listed by definition order.


4.1 cl-markless-components

Source

package.lisp.

Nickname

org.shirakumo.markless.components

Use List

common-lisp.

Public Interface
Internals

define-printer (macro).


4.2 cl-markless

Source

package.lisp.

Nickname

org.shirakumo.markless

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


5.1 Public Interface


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.

Special Variable: *default-compound-options*

This variable contains the list of by-default available compound options.

This list should only ever contain names of compound-options or their classes.

See PARSER

Package

cl-markless.

Source

parser.lisp.

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.

Special Variable: *default-embed-options*

This variable contains the list of by-default available embed options.

This list should only ever contain names of embed-options or their classes.

See PARSER

Package

cl-markless.

Source

parser.lisp.

Special Variable: *default-embed-types*

This variable contains the list of by-default available embed types.

This list should only ever contain names of embed types or their classes.

See PARSER

Package

cl-markless.

Source

parser.lisp.

Special Variable: *default-instruction-types*

This variable contains the list of by-default available instruction types.

This list should only ever contain names of instruction types or their classes.

See PARSER

Package

cl-markless.

Source

parser.lisp.

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.


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.

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.


5.1.3 Ordinary 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.

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.

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.

Function: condense-component-tree (component)

Condenses the given component destructively and recursively.

See CONDENSE-CHILDREN

Package

cl-markless.

Source

toolkit.lisp.

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.

Function: ends-with (ending string)

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

Package

cl-markless.

Source

toolkit.lisp.

Function: ensure-compound-option (option-ish)
Package

cl-markless.

Source

directive.lisp.

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.

Function: ensure-embed-option (option-ish)
Package

cl-markless.

Source

directive.lisp.

Function: ensure-embed-type (type-ish)
Package

cl-markless.

Source

directive.lisp.

Function: ensure-instruction-type (type-ish)
Package

cl-markless.

Source

directive.lisp.

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.

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.

Function: parse-compound-option (parser 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:

Call FIND-COMPOUND-OPTION-TYPE. If a class is returned, PARSE-COMPOUND-OPTION-TYPE is called with a class prototype. 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.

Function: parse-embed-option (parser cursor option component)

Parses the given option string into an option if possible.

Uses FIND-EMBED-OPTION-TYPE to find a suitable class for the given option. If found, PARSE-EMBED-OPTION-TYPE is called with a class prototype of the name. Otherwise an error of type BAD-OPTION is signalled.

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

Package

cl-markless.

Source

directive.lisp.

Function: parse-float (string &key start end)

Parses the given string as a floating point number.

Package

cl-markless.

Source

toolkit.lisp.

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.

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.

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.

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.

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.

Function: root (parser)

Returns the ROOT-COMPONENT of the current parse operation.

See ROOT
See PARSER

Package

cl-markless.

Source

parser.lisp.

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.

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.

Reader: 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.

Target Slot

component.

Writer: (setf stack-entry-component) (instance)
Package

cl-markless.

Source

parser.lisp.

Target Slot

component.

Reader: 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.

Target Slot

directive.

Writer: (setf stack-entry-directive) (instance)
Package

cl-markless.

Source

parser.lisp.

Target Slot

directive.

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.

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.

Function: stack-top (stack)

Returns the stack entry at the top of the stack.

See STACK-ENTRY

Package

cl-markless.

Source

parser.lisp.

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.

Function: starts-with (beginning string &optional start)

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

Package

cl-markless.

Source

toolkit.lisp.

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.


5.1.4 Generic functions

Generic Reader: alignment (object)
Package

cl-markless-components.

Methods
Reader Method: alignment ((align align))

automatically generated reader method

Source

component.lisp.

Target Slot

alignment.

Generic Writer: (setf alignment) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf alignment) ((align align))

automatically generated writer method

Source

component.lisp.

Target Slot

alignment.

Generic Reader: author (object)

Accesses the author metadata of the document.

See ROOT-COMPONENT

Package

cl-markless-components.

Methods
Reader Method: author ((root-component root-component))

automatically generated reader method

Source

component.lisp.

Target Slot

author.

Generic Writer: (setf author) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf author) ((root-component root-component))

automatically generated writer method

Source

component.lisp.

Target Slot

author.

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.

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 ((_ justify) parser line cursor)
Method: begin ((_ center) parser line cursor)
Method: begin ((_ right-align) parser line cursor)
Method: begin ((_ left-align) 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 :around ((_ surrounding-inline-directive) parser line cursor)
Generic Reader: 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.

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

automatically generated reader method

Source

parser.lisp.

Target Slot

block-dispatch-table.

Generic Writer: (setf block-dispatch-table) (object)
Package

cl-markless.

Methods
Writer Method: (setf block-dispatch-table) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

block-dispatch-table.

Generic Reader: 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.

Methods
Reader Method: blue ((color-option color-option))

automatically generated reader method

Source

component.lisp.

Target Slot

blue.

Generic Writer: (setf blue) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf blue) ((color-option color-option))

automatically generated writer method

Source

component.lisp.

Target Slot

blue.

Generic Reader: 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.

Methods
Reader Method: children ((parent-component parent-component))

automatically generated reader method

Source

component.lisp.

Target Slot

children.

Generic Writer: (setf children) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf children) ((parent-component parent-component))

automatically generated writer method

Source

component.lisp.

Target Slot

children.

Generic Reader: compound-options (object)
Package

cl-markless.

Methods
Reader Method: compound-options ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

compound-options.

Generic Writer: (setf compound-options) (object)
Package

cl-markless.

Methods
Writer Method: (setf compound-options) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

compound-options.

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.

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)
Method: consume-end ((_ blockquote-header) 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.

Methods
Method: consume-prefix ((_ justify) component parser line cursor)
Method: consume-prefix ((_ center) component parser line cursor)
Method: consume-prefix ((_ right-align) component parser line cursor)
Method: consume-prefix ((_ left-align) component parser line cursor)
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.

Methods

automatically generated reader method

Source

component.lisp.

Target Slot

copyright.

Package

cl-markless-components.

Methods

automatically generated writer method

Source

component.lisp.

Target Slot

copyright.

Generic Function: count-words (string &optional method)
Package

cl-markless.

Methods
Method: count-words ((component component) &optional method)
Source

misc.lisp.

Method: count-words ((pathname pathname) &optional method)
Source

misc.lisp.

Method: count-words ((string string) &optional method)
Source

misc.lisp.

Generic Function: count-words-by (method thing)
Package

cl-markless.

Source

misc.lisp.

Method Combination

+.

Options

:most-specific-first

Methods
Method: count-words-by + ((method (eql :character)) (string string))
Method: count-words-by + ((method (eql :whitespace)) (string string))
Method: count-words-by :around (method (component comment))
Method: count-words-by :around (method (component instruction))
Method: count-words-by + (method (component text-component))
Method: count-words-by + (method (component parent-component))
Method: count-words-by + (method (component component))
Generic Reader: 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
Reader Method: cursor ((condition parser-condition))
Source

conditions.lisp.

Target Slot

cursor.

Generic Reader: depth (object)

Accesses the section depth of the header.

This must be a positive integer.

See HEADER

Package

cl-markless-components.

Methods
Reader Method: depth ((code-block code-block))

automatically generated reader method

Source

component.lisp.

Target Slot

depth.

Reader Method: depth ((header header))

automatically generated reader method

Source

component.lisp.

Target Slot

depth.

Generic Writer: (setf depth) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf depth) ((code-block code-block))

automatically generated writer method

Source

component.lisp.

Target Slot

depth.

Writer Method: (setf depth) ((header header))

automatically generated writer method

Source

component.lisp.

Target Slot

depth.

Generic Reader: direction (object)
Package

cl-markless-components.

Methods
Reader Method: direction ((float-option float-option))

automatically generated reader method

Source

component.lisp.

Target Slot

direction.

Generic Writer: (setf direction) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf direction) ((float-option float-option))

automatically generated writer method

Source

component.lisp.

Target Slot

direction.

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.

Method: directive ((name symbol) (parser parser))
Source

parser.lisp.

Generic Reader: directive-instance (condition)

Returns the instance of the directive related to the condition.

See DEACTIVATION-DISALLOWED

Package

cl-markless.

Methods
Reader Method: directive-instance ((condition deactivation-disallowed))
Source

conditions.lisp.

Target Slot

directive.

Generic Reader: 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.

Methods
Reader Method: directives ((directives-instruction directives-instruction))

automatically generated reader method

Source

component.lisp.

Target Slot

directives.

Generic Writer: (setf directives) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf directives) ((directives-instruction directives-instruction))

automatically generated writer method

Source

component.lisp.

Target Slot

directives.

Generic Reader: 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.

Methods
Reader Method: directives ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

directives.

Generic Writer: (setf directives) (object)
Package

cl-markless.

Methods
Writer Method: (setf directives) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

directives.

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.

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.

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 embed-link-option) (embed image))
Source

directive.lisp.

Method: embed-option-allowed-p ((option encoding-option) (embed source))
Source

directive.lisp.

Method: embed-option-allowed-p ((option end-option) (embed source))
Source

directive.lisp.

Method: embed-option-allowed-p ((option start-option) (embed source))
Source

directive.lisp.

Method: embed-option-allowed-p ((option language-option) (embed source))
Source

directive.lisp.

Method: embed-option-allowed-p ((option options-option) (embed source))
Source

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

Generic Reader: embed-options (object)

Accesses the list of embed options the parser supports.

See PARSER
See EMBED-OPTION

Package

cl-markless.

Methods
Reader Method: embed-options ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

embed-options.

Generic Writer: (setf embed-options) (object)
Package

cl-markless.

Methods
Writer Method: (setf embed-options) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

embed-options.

Generic Reader: embed-type (condition)

Returns the embed-type that caused the error.

See OPTION-DISALLOWED

Package

cl-markless.

Methods
Reader Method: embed-type ((condition option-disallowed))
Source

conditions.lisp.

Target Slot

embed-type.

Reader Method: embed-type ((condition unknown-embed-type))
Source

conditions.lisp.

Target Slot

embed-type.

Generic Reader: embed-types (object)

Accesses the list of compound options the parser supports.

See PARSER
See COMPOUND-OPTION

Package

cl-markless.

Methods
Reader Method: embed-types ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

embed-types.

Generic Writer: (setf embed-types) (object)
Package

cl-markless.

Methods
Writer Method: (setf embed-types) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

embed-types.

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.

Generic Reader: 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.

Methods
Reader Method: enabled-p ((directive directive))

automatically generated reader method

Source

directive.lisp.

Target Slot

enabled-p.

Generic Function: (setf enabled-p) (object)
Package

cl-markless.

Methods
Method: (setf enabled-p) ((_ paragraph))
Source

directive.lisp.

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

directive.lisp.

Writer Method: (setf enabled-p) ((directive directive))

automatically generated writer method

Source

directive.lisp.

Target Slot

enabled-p.

Generic Reader: encoding (object)
Package

cl-markless-components.

Methods
Reader Method: encoding ((encoding-option encoding-option))

automatically generated reader method

Source

component.lisp.

Target Slot

encoding.

Generic Writer: (setf encoding) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf encoding) ((encoding-option encoding-option))

automatically generated writer method

Source

component.lisp.

Target Slot

encoding.

Generic Reader: end (object)
Package

cl-markless-components.

Methods
Reader Method: end ((end-option end-option))

automatically generated reader method

Source

component.lisp.

Target Slot

end.

Generic Writer: (setf end) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf end) ((end-option end-option))

automatically generated writer method

Source

component.lisp.

Target Slot

end.

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.

Methods
Method: end :after ((_ compound) component parser)
Method: end :after ((_ subtext) component parser)
Method: end :after ((_ supertext) component parser)
Method: end :after ((_ code) component parser)
Method: end :after ((_ strikethrough) component parser)
Method: end :after ((_ underline) component parser)
Method: end :after ((_ italic) component parser)
Method: end :after ((_ bold) component parser)
Method: end :after ((_ header) component parser)
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 raw) (parser parser))
Source

parser.lisp.

Method: evaluate-instruction ((instruction label) (parser parser))
Source

parser.lisp.

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

parser.lisp.

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

parser.lisp.

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

parser.lisp.

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

parser.lisp.

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

parser.lisp.

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

parser.lisp.

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

parser.lisp.

Method: evaluate-instruction (instruction (parser parser))
Source

parser.lisp.

Generic Reader: file (object)

Accesses the file pathname of the file to be included.

See INCLUDE

Package

cl-markless-components.

Methods
Reader Method: file ((include include))

automatically generated reader method

Source

component.lisp.

Target Slot

file.

Generic Writer: (setf file) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf file) ((include include))

automatically generated writer method

Source

component.lisp.

Target Slot

file.

Generic Function: find-embed-option-type (parser option)

Finds a class that can parse the option of the given type name.

For a default parser this will compare the given option name against the class names of the classes mentioned in the parser’s EMBED-OPTIONS list. If the given name with "-option" added to its end matches any of the class names case-insensitively, that class is returned.

See PARSE-EMBED-OPTION

Package

cl-markless.

Methods
Method: find-embed-option-type ((parser parser) (option string))
Source

directive.lisp.

Generic Function: find-embed-type (parser type)

Finds a class that can parse the embed type of the given name.

For a default parser this will compare the given option name against the class names of the classes mentioned in the parser’s EMBED-OPTIONS list. The names are compared case-insensitively.

See EMBED

Package

cl-markless.

Methods
Method: find-embed-type ((parser parser) (type string))
Source

directive.lisp.

Generic Function: find-instruction-type (parser type)
Package

cl-markless.

Methods
Method: find-instruction-type ((parser parser) (type string))
Source

directive.lisp.

Generic Reader: font-family (object)

Accesses the font family name of the font option.

See FONT-OPTION

Package

cl-markless-components.

Methods
Reader Method: font-family ((font-option font-option))

automatically generated reader method

Source

component.lisp.

Target Slot

font-family.

Generic Writer: (setf font-family) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf font-family) ((font-option font-option))

automatically generated writer method

Source

component.lisp.

Target Slot

font-family.

Generic Reader: 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.

Methods
Reader Method: green ((color-option color-option))

automatically generated reader method

Source

component.lisp.

Target Slot

green.

Generic Writer: (setf green) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf green) ((color-option color-option))

automatically generated writer method

Source

component.lisp.

Target Slot

green.

Generic Reader: 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.

Methods
Reader Method: indentation ((paragraph paragraph))

automatically generated reader method

Source

component.lisp.

Target Slot

indentation.

Generic Writer: (setf indentation) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf indentation) ((paragraph paragraph))

automatically generated writer method

Source

component.lisp.

Target Slot

indentation.

Generic Reader: 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.

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

automatically generated reader method

Source

parser.lisp.

Target Slot

inline-dispatch-table.

Generic Writer: (setf inline-dispatch-table) (object)
Package

cl-markless.

Methods
Writer Method: (setf inline-dispatch-table) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

inline-dispatch-table.

Generic Reader: input (object)

Accesses the current input stream from which lines are parsed.

See PARSER

Package

cl-markless.

Methods
Reader Method: input ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

input.

Generic Writer: (setf input) (object)
Package

cl-markless.

Methods
Writer Method: (setf input) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

input.

Generic Reader: inset (object)
Package

cl-markless-components.

Methods
Reader Method: inset ((code-block code-block))

automatically generated reader method

Source

component.lisp.

Target Slot

inset.

Generic Writer: (setf inset) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf inset) ((code-block code-block))

automatically generated writer method

Source

component.lisp.

Target Slot

inset.

Generic Reader: instruction (condition)

Returns the problematic instruction.

See INSTRUCTION-EVALUATION-UNDEFINED See UNKNOWN-INSTRUCTION

Package

cl-markless.

Methods
Reader Method: instruction ((condition unknown-instruction))
Source

conditions.lisp.

Target Slot

instruction.

Reader Method: instruction ((condition instruction-evaluation-undefined))
Source

conditions.lisp.

Target Slot

instruction.

Generic Reader: instruction-types (object)

Accesses the list of instruction types the parser supports.

See PARSER
See INSTRUCTION

Package

cl-markless.

Methods
Reader Method: instruction-types ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

instruction-types.

Generic Writer: (setf instruction-types) (object)
Package

cl-markless.

Methods
Writer Method: (setf instruction-types) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

instruction-types.

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.

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.

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

component.lisp.

Generic Function: (setf label) (label root)
Package

cl-markless-components.

Methods
Method: (setf label) ((label string) (root root-component))
Source

component.lisp.

Method: (setf label) ((label string) (root root-component))
Source

component.lisp.

Generic Reader: 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.

Methods
Reader Method: labels ((root-component root-component))

automatically generated reader method

Source

component.lisp.

Target Slot

labels.

Generic Writer: (setf labels) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf labels) ((root-component root-component))

automatically generated writer method

Source

component.lisp.

Target Slot

labels.

Generic Reader: 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.

Methods
Reader Method: language ((language-option language-option))

automatically generated reader method

Source

component.lisp.

Target Slot

language.

Reader Method: language ((code-block code-block))

automatically generated reader method

Source

component.lisp.

Target Slot

language.

Reader Method: language ((root-component root-component))

automatically generated reader method

Source

component.lisp.

Target Slot

language.

Generic Writer: (setf language) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf language) ((language-option language-option))

automatically generated writer method

Source

component.lisp.

Target Slot

language.

Writer Method: (setf language) ((code-block code-block))

automatically generated writer method

Source

component.lisp.

Target Slot

language.

Writer Method: (setf language) ((root-component root-component))

automatically generated writer method

Source

component.lisp.

Target Slot

language.

Generic Reader: line (condition)

Returns the line number on which the condition occurred.

The lines are counted from 0.

See PARSER-CONDITION

Package

cl-markless.

Methods
Reader Method: line ((condition parser-condition))
Source

conditions.lisp.

Target Slot

line.

Generic Reader: 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.

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

automatically generated reader method

Source

parser.lisp.

Target Slot

line-break-mode.

Generic Writer: (setf line-break-mode) (object)
Package

cl-markless.

Methods
Writer Method: (setf line-break-mode) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

line-break-mode.

Generic Reader: 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.

Methods
Reader Method: message ((message-instruction message-instruction))

automatically generated reader method

Source

component.lisp.

Target Slot

message.

Generic Writer: (setf message) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf message) ((message-instruction message-instruction))

automatically generated writer method

Source

component.lisp.

Target Slot

message.

Generic Reader: message (condition)

Returns the message the user passed in the warn instruction.

See USER-WARNING
See USER-ERROR

Package

cl-markless.

Methods
Reader Method: message ((condition user-error))
Source

conditions.lisp.

Target Slot

message.

Reader Method: message ((condition user-warning))
Source

conditions.lisp.

Target Slot

message.

Generic Reader: number (object)

Accesses the number of the list item as an INTEGER.

See ORDERED-LIST-ITEM

Package

cl-markless-components.

Methods
Reader Method: number ((ordered-list-item ordered-list-item))

automatically generated reader method

Source

component.lisp.

Target Slot

number.

Generic Writer: (setf number) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf number) ((ordered-list-item ordered-list-item))

automatically generated writer method

Source

component.lisp.

Target Slot

number.

Generic Reader: offset-p (object)
Package

cl-markless-components.

Methods
Reader Method: offset-p ((end-option end-option))

automatically generated reader method

Source

component.lisp.

Target Slot

offset-p.

Generic Writer: (setf offset-p) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf offset-p) ((end-option end-option))

automatically generated writer method

Source

component.lisp.

Target Slot

offset-p.

Generic Reader: option (condition)

Returns the option string that could not be parsed.

See BAD-OPTION

Package

cl-markless.

Methods
Reader Method: option ((condition bad-option))
Source

conditions.lisp.

Target Slot

option.

Generic Reader: 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.

Methods
Reader Method: options ((compound compound))

automatically generated reader method

Source

component.lisp.

Target Slot

options.

Reader Method: options ((options-option options-option))

automatically generated reader method

Source

component.lisp.

Target Slot

options.

Reader Method: options ((embed embed))

automatically generated reader method

Source

component.lisp.

Target Slot

options.

Reader Method: options ((code-block code-block))

automatically generated reader method

Source

component.lisp.

Target Slot

options.

Generic Writer: (setf options) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf options) ((compound compound))

automatically generated writer method

Source

component.lisp.

Target Slot

options.

Writer Method: (setf options) ((options-option options-option))

automatically generated writer method

Source

component.lisp.

Target Slot

options.

Writer Method: (setf options) ((embed embed))

automatically generated writer method

Source

component.lisp.

Target Slot

options.

Writer Method: (setf options) ((code-block code-block))

automatically generated writer method

Source

component.lisp.

Target Slot

options.

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.

Methods
Method: output-component ((c string) (s stream) (_ highlighted))
Method: output-component :around ((c root-component) (s stream) (_ highlighted))
Method: output-component :around ((c component) (s stream) (_ highlighted))
Method: output-component ((c newline) (s stream) (_ markless))
Method: output-component ((c em-dash) (s stream) (_ markless))
Method: output-component ((c en-dash) (s stream) (_ markless))
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 align) (s stream) (_ markless))
Method: output-component ((c footnote) (s stream) (_ markless))
Method: output-component ((c caption-option) (s stream) (_ markless))
Method: output-component ((c spoiler-option) (s stream) (_ markless))
Method: output-component ((c strikethrough-option) (s stream) (_ markless))
Method: output-component ((c underline-option) (s stream) (_ markless))
Method: output-component ((c italic-option) (s stream) (_ markless))
Method: output-component ((c bold-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 raw) (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 :before ((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 newline) (s stream) (_ bbcode))
Method: output-component ((c em-dash) (s stream) (_ bbcode))
Method: output-component ((c en-dash) (s stream) (_ bbcode))
Method: output-component ((c footnote-reference) (s stream) (_ bbcode))
Method: output-component ((c compound) (s stream) (_ bbcode))
Method: output-component ((c url) (s stream) (_ bbcode))
Method: output-component ((c supertext) (s stream) (_ bbcode))
Method: output-component ((c subtext) (s stream) (_ bbcode))
Method: output-component ((c code) (s stream) (_ bbcode))
Method: output-component ((c strikethrough) (s stream) (_ bbcode))
Method: output-component ((c underline) (s stream) (_ bbcode))
Method: output-component ((c italic) (s stream) (_ bbcode))
Method: output-component ((c bold) (s stream) (_ bbcode))
Method: output-component ((c footnote) (s stream) (_ bbcode))
Method: output-component ((c video) (s stream) (_ bbcode))
Method: output-component ((c image) (s stream) (_ bbcode))
Method: output-component ((c raw) (s stream) (_ bbcode))
Method: output-component ((c align) (s stream) (_ bbcode))
Method: output-component ((c embed) (s stream) (_ bbcode))
Method: output-component ((c comment) (s stream) (_ bbcode))
Method: output-component ((c instruction) (s stream) (_ bbcode))
Method: output-component ((c code-block) (s stream) (_ bbcode))
Method: output-component ((c horizontal-rule) (s stream) (_ bbcode))
Method: output-component ((c header) (s stream) (_ bbcode))
Method: output-component ((c list-item) (s stream) (_ bbcode))
Method: output-component ((c unordered-list) (s stream) (_ bbcode))
Method: output-component ((c ordered-list) (s stream) (_ bbcode))
Method: output-component ((c blockquote) (s stream) (_ bbcode))
Method: output-component ((c blockquote-header) (s stream) (_ bbcode))
Method: output-component ((c parent-component) (s stream) (_ bbcode))
Method: output-component ((c string) (s stream) (_ bbcode))
Method: output-component ((c vector) (s stream) (_ bbcode))
Method: output-component ((c unit-component) (s stream) (_ debug))
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 :after ((c parent-component) (s stream) (_ debug))
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 :before (c (s stream) (_ debug))
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.

Method: parse ((string string) parser)
Source

parser.lisp.

Method: parse ((pathname pathname) parser)
Source

parser.lisp.

Method: parse (thing (parser (eql t)))
Source

parser.lisp.

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.

Method: parse-compound-option-type ((proto size-option) option)
Source

directive.lisp.

Method: parse-compound-option-type ((proto color-option) option)
Source

directive.lisp.

Method: parse-compound-option-type ((proto font-option) option)
Source

directive.lisp.

Method: parse-compound-option-type ((proto compound-option) option)
Source

directive.lisp.

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 embed-link-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type encoding-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type end-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type start-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type language-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type options-option) option)
Source

directive.lisp.

Method: parse-embed-option-type ((type height-option) option)
Source

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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

directive.lisp.

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 raw) line cursor)
Source

directive.lisp.

Method: parse-instruction ((proto label) line cursor)
Source

directive.lisp.

Method: parse-instruction ((proto directives-instruction) line cursor)
Source

directive.lisp.

Method: parse-instruction ((proto include) line cursor)
Source

directive.lisp.

Method: parse-instruction ((proto message-instruction) line cursor)
Source

directive.lisp.

Method: parse-instruction ((proto set) line cursor)
Source

directive.lisp.

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.

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 ((_ justify))
Method: prefix ((_ center))
Method: prefix ((_ right-align))
Method: prefix ((_ left-align))
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 Reader: 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.

Methods
Reader Method: red ((color-option color-option))

automatically generated reader method

Source

component.lisp.

Target Slot

red.

Generic Writer: (setf red) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf red) ((color-option color-option))

automatically generated writer method

Source

component.lisp.

Target Slot

red.

Generic Reader: size (object)

Accesses the size as a REAL.

This number only makes sense in conjunction with the UNIT.

See SIZED

Package

cl-markless-components.

Methods
Reader Method: size ((sized sized))

automatically generated reader method

Source

component.lisp.

Target Slot

size.

Generic Writer: (setf size) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf size) ((sized sized))

automatically generated writer method

Source

component.lisp.

Target Slot

size.

Generic Reader: source (object)

Accesses the blockquote-header source associated with the blockquote.

See BLOCKQUOTE-HEADER
See BLOCKQUOTE

Package

cl-markless-components.

Methods
Reader Method: source ((blockquote blockquote))

automatically generated reader method

Source

component.lisp.

Target Slot

source.

Generic Writer: (setf source) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf source) ((blockquote blockquote))

automatically generated writer method

Source

component.lisp.

Target Slot

source.

Generic Reader: 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.

Methods
Reader Method: stack ((parser parser))

automatically generated reader method

Source

parser.lisp.

Target Slot

stack.

Generic Writer: (setf stack) (object)
Package

cl-markless.

Methods
Writer Method: (setf stack) ((parser parser))

automatically generated writer method

Source

parser.lisp.

Target Slot

stack.

Generic Reader: start (object)
Package

cl-markless-components.

Methods
Reader Method: start ((start-option start-option))

automatically generated reader method

Source

component.lisp.

Target Slot

start.

Generic Writer: (setf start) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf start) ((start-option start-option))

automatically generated writer method

Source

component.lisp.

Target Slot

start.

Generic Reader: 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.

Methods
Reader Method: target ((targeted targeted))

automatically generated reader method

Source

component.lisp.

Target Slot

target.

Generic Writer: (setf target) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf target) ((targeted targeted))

automatically generated writer method

Source

component.lisp.

Target Slot

target.

Generic Function: text (object)

Accessor for the text string the component visualises.

See TEXT-COMPONENT

Package

cl-markless-components.

Methods
Reader Method: text ((raw raw))

automatically generated reader method

Source

component.lisp.

Target Slot

text.

Method: text ((component parent-component))
Source

component.lisp.

Reader Method: text ((text-component text-component))

automatically generated reader method

Source

component.lisp.

Target Slot

text.

Generic Writer: (setf text) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf text) ((raw raw))

automatically generated writer method

Source

component.lisp.

Target Slot

text.

Writer Method: (setf text) ((text-component text-component))

automatically generated writer method

Source

component.lisp.

Target Slot

text.

Generic Reader: 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.

Methods
Reader Method: unit ((sized sized))

automatically generated reader method

Source

component.lisp.

Target Slot

unit.

Generic Writer: (setf unit) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf unit) ((sized sized))

automatically generated writer method

Source

component.lisp.

Target Slot

unit.

Generic Reader: value (object)

Accesses the value of the set instruction.

This should be a string representing the new value.

See SET

Package

cl-markless-components.

Methods
Reader Method: value ((set set))

automatically generated reader method

Source

component.lisp.

Target Slot

value.

Generic Writer: (setf value) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf value) ((set set))

automatically generated writer method

Source

component.lisp.

Target Slot

value.

Generic Reader: value (condition)

Returns the variable value related to the condition.

See BAD-VALUE

Package

cl-markless.

Methods
Reader Method: value ((condition bad-value))
Source

conditions.lisp.

Target Slot

value.

Generic Reader: 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.

Methods
Reader Method: variable ((set set))

automatically generated reader method

Source

component.lisp.

Target Slot

variable.

Generic Writer: (setf variable) (object)
Package

cl-markless-components.

Methods
Writer Method: (setf variable) ((set set))

automatically generated writer method

Source

component.lisp.

Target Slot

variable.

Generic Reader: variable-name (condition)

Returns the name of the variable related to the condition.

See BAD-VARIABLE
See BAD-VALUE

Package

cl-markless.

Methods
Reader Method: variable-name ((condition bad-value))
Source

conditions.lisp.

Target Slot

variable.

Reader Method: variable-name ((condition bad-variable))
Source

conditions.lisp.

Target Slot

variable.


5.1.5 Standalone methods

Method: initialize-instance :after ((parser parser) &key directives compound-options embed-types embed-options instruction-types disabled-directives stack-size-limit)
Source

parser.lisp.

Method: print-object ((c sized) s)
Source

component.lisp.

Method: print-object ((c header) s)
Source

component.lisp.

Method: print-object ((c link-option) s)
Source

component.lisp.

Method: print-object ((c set) s)
Source

component.lisp.

Method: print-object ((c embed) s)
Source

component.lisp.

Method: print-object ((c root-component) s)
Source

component.lisp.

Method: print-object ((c code-block) s)
Source

component.lisp.

Method: print-object ((c directives-instruction) s)
Source

component.lisp.

Method: print-object ((c include) s)
Source

component.lisp.

Method: print-object ((c color-option) s)
Source

component.lisp.

Method: print-object ((c ordered-list-item) s)
Source

component.lisp.

Method: print-object ((c font-option) s)
Source

component.lisp.

Method: print-object ((c message-instruction) s)
Source

component.lisp.

Method: print-object ((c footnote-reference) s)
Source

component.lisp.

Method: print-object ((c size-option) s)
Source

component.lisp.

Method: print-object ((c footnote) s)
Source

component.lisp.

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

directive.lisp.


5.1.6 Conditions

Condition: bad-option

Warning signalled if an option is malformed or unknown.

See OPTION
See PARSER-ERROR

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

parser-warning.

Direct subclasses
Direct methods

option.

Direct slots
Slot: option
Initargs

:option

Readers

option.

Writers

This slot is read-only.

Condition: bad-unit

Warning signalled if the size contains an unknown unit.

See BAD-OPTION

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

bad-option.

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.

Direct superclasses

parser-error.

Direct methods
Direct slots
Slot: variable
Package

common-lisp.

Initargs

:variable

Readers

variable-name.

Writers

This slot is read-only.

Slot: value
Initargs

:value

Readers

value.

Writers

This slot is read-only.

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.

Direct superclasses

parser-error.

Direct methods

variable-name.

Direct slots
Slot: variable
Package

common-lisp.

Initargs

:variable

Readers

variable-name.

Writers

This slot is read-only.

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.

Direct superclasses
Direct methods

directive-instance.

Direct slots
Slot: directive
Initargs

:directive

Readers

directive-instance.

Writers

This slot is read-only.

Condition: implementation-condition

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

See MARKLESS-CONDITION

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

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

Direct superclasses
Direct methods

instruction.

Direct slots
Slot: instruction
Initargs

:instruction

Readers

instruction.

Writers

This slot is read-only.

Condition: markless-condition

Superclass for all conditions related to markless.

See CL:CONDITION

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

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.

Direct superclasses

bad-option.

Direct methods

embed-type.

Direct slots
Slot: embed-type
Initargs

:embed-type

Readers

embed-type.

Writers

This slot is read-only.

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.

Direct superclasses

markless-condition.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:cursor0
:line*current-line-number*
Direct slots
Slot: line
Initargs

:line

Readers

line.

Writers

This slot is read-only.

Slot: cursor
Initargs

:cursor

Readers

cursor.

Writers

This slot is read-only.

Condition: parser-error

Superclass for all conditions that relate to fatal parser errors.

See PARSER-CONDITION

Package

cl-markless.

Source

conditions.lisp.

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.

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.

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.

Direct superclasses

parser-warning.

Direct methods

embed-type.

Direct slots
Slot: embed-type
Initargs

:embed-type

Readers

embed-type.

Writers

This slot is read-only.

Condition: unknown-instruction

Error signalled if an instruction is encountered that is unknown.

See INSTRUCTION
See PARSER-ERROR

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

parser-error.

Direct methods

instruction.

Direct slots
Slot: instruction
Initargs

:instruction

Readers

instruction.

Writers

This slot is read-only.

Condition: user-error

Error signalled when an error instruction is encountered.

See MESSAGE
See PARSER-WARNING

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

parser-error.

Direct methods

message.

Direct slots
Slot: message
Initargs

:message

Readers

message.

Writers

This slot is read-only.

Condition: user-warning

Warning signalled when a warn instruction is encountered.

See MESSAGE
See PARSER-WARNING

Package

cl-markless.

Source

conditions.lisp.

Direct superclasses

parser-warning.

Direct methods

message.

Direct slots
Slot: message
Initargs

:message

Readers

message.

Writers

This slot is read-only.


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

Direct superclasses

structure-object.

Direct slots
Slot: directive
Readers

stack-entry-directive.

Writers

(setf stack-entry-directive).

Slot: component
Readers

stack-entry-component.

Writers

(setf stack-entry-component).


5.1.8 Classes

Class: align
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: alignment
Initform

(error "alignment required")

Initargs

:alignment

Readers

alignment.

Writers

(setf alignment).

Class: audio

Representation of the AUDIO embed type.

See EMBED

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed.

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.

Direct superclasses

embed-option.

Direct methods
Class: bbcode
Package

cl-markless.

Source

printer.lisp.

Direct superclasses

output-format.

Direct methods
Direct slots
Slot: supported-tags
Initform

(quote (:quote :list :h :hr :code :img :video :b :i :u :s :fixed :sub :super :url :size :color :spoiler))

Initargs

:supported-tags

Readers

supported-tags.

Writers

(setf supported-tags).

Class: block-component

A component that encompasses a block of text.

See COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

component.

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.

Direct superclasses

directive.

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.

Direct superclasses
Direct methods
Direct slots
Slot: source
Initargs

:source

Readers

source.

Writers

(setf source).

Class: blockquote

The directive for a blockquote.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

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.

Direct superclasses
Direct methods
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.

Direct superclasses

singular-line-directive.

Direct methods
Class: bold

Representation of bold text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: bold

The directive for a bold markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

surrounding-inline-directive.

Direct methods
Class: bold-option

Representation of the bold compound option.

See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods

output-component.

Class: caption-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: center
Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

Direct methods
Class: code

Representation of literal text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: code

The directive for a code markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

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.

Direct superclasses
Direct methods
Direct slots
Slot: language
Initargs

:language

Readers

language.

Writers

(setf language).

Slot: options
Initargs

:options

Readers

options.

Writers

(setf options).

Slot: depth
Initform

0

Initargs

:depth

Readers

depth.

Writers

(setf depth).

Slot: inset
Initform

0

Initargs

:inset

Readers

inset.

Writers

(setf inset).

Class: code-block

The directive for a code block.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

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.

Direct superclasses

compound-option.

Direct methods
Direct slots
Slot: red
Initform

(error "red required")

Initargs

:red

Readers

red.

Writers

(setf red).

Slot: green
Initform

(error "green required")

Initargs

:green

Readers

green.

Writers

(setf green).

Slot: blue
Initform

(error "blue required")

Initargs

:blue

Readers

blue.

Writers

(setf blue).

Class: comment

Represents a comment.

See TEXT-COMPONENT See BLOCK-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: comment

The directive for a comment.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

singular-line-directive.

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.

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.

Direct superclasses
Direct methods
Direct slots
Slot: options
Initargs

:options

Readers

options.

Writers

(setf options).

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.

Direct superclasses

inline-directive.

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.

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.

Direct superclasses

inline-directive.

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.

Direct superclasses

output-format.

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.

Direct subclasses
Direct methods
Direct slots
Slot: enabled-p
Initform

t

Initargs

:enabled-p

Readers

enabled-p.

Writers

(setf enabled-p).

Class: directives-instruction

Superclass for all instructions that carry a list of directives.

See DIRECTIVES
See INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

instruction.

Direct subclasses
Direct methods
Direct slots
Slot: directives
Initform

(error "directives required.")

Initargs

:directives

Readers

directives.

Writers

(setf directives).

Class: disable

Represents a DISABLE instruction.

See DIRECTIVES-INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

directives-instruction.

Direct methods

evaluate-instruction.

Class: em-dash

Representation of an em-dash.

See UNIT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
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.

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

:options

Readers

options.

Writers

(setf options).

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.

Direct superclasses

singular-line-directive.

Direct methods
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
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.

Direct subclasses
Direct methods
Class: en-dash

Representation of an en-dash.

See UNIT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: enable

Represents an ENABLE instruction.

See DIRECTIVES-INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

directives-instruction.

Direct methods

evaluate-instruction.

Class: encoding-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: encoding
Initform

(error "encoding required")

Initargs

:encoding

Readers

encoding.

Writers

(setf encoding).

Class: end-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: end
Initform

(error "end required")

Initargs

:end

Readers

end.

Writers

(setf end).

Slot: offset-p
Initargs

:offset-p

Readers

offset-p.

Writers

(setf offset-p).

Class: error

Represents an ERROR instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

message-instruction.

Direct methods

evaluate-instruction.

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.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: direction
Initform

(error "direction required")

Initargs

:direction

Readers

direction.

Writers

(setf direction).

Class: font-option

Representation of the font compound option.

See FONT-FAMILY
See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods
Direct slots
Slot: font-family
Initform

(error "font-family required")

Initargs

:font-family

Readers

font-family.

Writers

(setf font-family).

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.

Direct superclasses
Direct methods
Class: footnote

The directive for a footnote.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

singular-line-directive.

Direct methods
Class: footnote-reference

Representation of a reference to a footnote.

See TARGET
See UNIT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: footnote-reference

The directive for a footnote reference.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

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.

Direct superclasses
Direct methods
Direct slots
Slot: depth
Initform

0

Initargs

:depth

Readers

depth.

Writers

(setf depth).

Class: header

The directive for a section header.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

singular-line-directive.

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.

Direct superclasses
Direct methods
Class: highlighted
Package

cl-markless.

Source

printer.lisp.

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.

Direct superclasses
Direct methods
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.

Direct superclasses

singular-line-directive.

Direct methods
Class: image

Representation of the IMAGE embed type.

See EMBED

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed.

Direct methods
Class: include

Represents an INCLUDE instruction

See FILE
See INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: file
Initform

(error "file required")

Initargs

:file

Readers

file.

Writers

(setf file).

Class: info

Represents an INFO instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

message-instruction.

Direct methods

evaluate-instruction.

Class: inline-component

A component that encompasses an inline section of text.

See COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

component.

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.

Direct superclasses

directive.

Direct subclasses
Direct methods
Class: instruction

Superclass for all instructions.

See BLOCK-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

block-component.

Direct subclasses
Direct methods
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.

Direct superclasses

singular-line-directive.

Direct methods

Representation of an internal link option.

See LINK-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

link-option.

Direct methods

output-component.

Class: italic

Representation of italic text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: italic

The directive for an italic markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

surrounding-inline-directive.

Direct methods
Class: italic-option

Representation of the italic compound option.

See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods

output-component.

Class: justify
Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

Direct methods
Class: label

Represents a LABEL instruction

See TARGET
See INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: label-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: language-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: language
Initargs

:language

Readers

language.

Writers

(setf language).

Class: left-align
Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

Direct methods

Representation of the link option.

See TARGET
See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct subclasses

internal-link-option.

Direct methods
Class: list

Superclass for all list type components.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

parent-component.

Direct subclasses
Class: list-item

Superclass for all list item type components.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

parent-component.

Direct subclasses
Direct methods

output-component.

Class: loop-option

Represents a loop option.

Causes the embed to loop its content.

See EMBED-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

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.

Direct superclasses

output-format.

Direct subclasses

highlighted.

Direct methods
Class: message-instruction

Superclass for all instructions that carry a message.

See MESSAGE
See INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

instruction.

Direct subclasses
Direct methods
Direct slots
Slot: message
Initform

(error "message required")

Initargs

:message

Readers

message.

Writers

(setf message).

Class: newline

Representation of a line break.

See UNIT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: newline

The directive for an explicit newline.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: options-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: options
Initargs

:options

Readers

options.

Writers

(setf options).

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.

Direct superclasses
Direct methods

output-component.

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.

Direct superclasses

block-directive.

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.

Direct superclasses
Direct methods
Direct slots
Slot: number
Initform

0

Initargs

:number

Readers

number.

Writers

(setf number).

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.

Direct subclasses
Class: paragraph

Represents a textual paragraph.

See INDENTATION
See PARENT-COMPONENT
See BLOCK-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: indentation
Initform

0

Initargs

:indentation

Readers

indentation.

Writers

(setf indentation).

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.

Direct superclasses

block-directive.

Direct methods
Class: parent-component

A component that contains text and subcomponents.

See CHILDREN
See COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

component.

Direct subclasses
Direct methods
Direct slots
Slot: children
Initform

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

Initargs

:children

Readers

children.

Writers

(setf children).

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.

You may also pass a list of accepted compound options, embed types, embed options, and instruction types using the respective initargs.

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 EMBED-TYPES
See EMBED-OPTIONS
See COMPOUND-OPTIONS
See INSTRUCTION-TYPES
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.

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

:show

Initargs

:line-break-mode

Readers

line-break-mode.

Writers

(setf line-break-mode).

Slot: directives
Readers

directives.

Writers

(setf directives).

Slot: embed-types
Readers

embed-types.

Writers

(setf embed-types).

Slot: embed-options
Readers

embed-options.

Writers

(setf embed-options).

Slot: compound-options
Readers

compound-options.

Writers

(setf compound-options).

Slot: instruction-types
Readers

instruction-types.

Writers

(setf instruction-types).

Slot: block-dispatch-table
Readers

block-dispatch-table.

Writers

(setf block-dispatch-table).

Slot: inline-dispatch-table
Readers

inline-dispatch-table.

Writers

(setf inline-dispatch-table).

Slot: input
Readers

input.

Writers

(setf input).

Slot: stack
Readers

stack.

Writers

(setf stack).

Class: raw
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: text
Initform

(error "text required")

Initargs

:text

Readers

text.

Writers

(setf text).

Class: right-align
Package

cl-markless.

Source

directive.lisp.

Direct superclasses

block-directive.

Direct methods
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.

Direct superclasses

parent-component.

Direct methods
Direct slots
Slot: labels
Initform

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

Readers

labels.

Writers

(setf labels).

Slot: author
Readers

author.

Writers

(setf author).

Readers

copyright.

Writers

(setf copyright).

Slot: language
Readers

language.

Writers

(setf language).

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.

Direct superclasses

directive.

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.

Direct superclasses

instruction.

Direct methods
Direct slots
Slot: variable
Initform

(error "variable required")

Initargs

:variable

Readers

variable.

Writers

(setf variable).

Slot: value
Initform

(error "value required")

Initargs

:value

Readers

value.

Writers

(setf value).

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.

Direct superclasses

block-directive.

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.

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.

Direct subclasses
Direct methods
Direct slots
Slot: unit
Initform

(error "unit required")

Initargs

:unit

Readers

unit.

Writers

(setf unit).

Slot: size
Initform

(error "size required")

Initargs

:size

Readers

size.

Writers

(setf size).

Class: source
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed.

Direct methods
Class: spoiler-option

Representation of the spoiler compound option.

See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods

output-component.

Class: start-option
Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed-option.

Direct methods
Direct slots
Slot: start
Initform

(error "start required")

Initargs

:start

Readers

start.

Writers

(setf start).

Class: strikethrough

Representation of struck-through text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: strikethrough

The directive for a strikethrough markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: strikethrough-option

Representation of the strikethrough compound option.

See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods

output-component.

Class: subtext

Representation of text sunk below normal text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: subtext

The directive for a subtext markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

Direct methods
Class: supertext

Representation of text raised above normal text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: supertext

The directive for a supertext markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

inline-directive.

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.

Direct superclasses

inline-directive.

Direct subclasses
Direct methods

begin.

Class: targeted
Package

cl-markless-components.

Source

component.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: target
Initform

(error "target required")

Initargs

:target

Readers

target.

Writers

(setf target).

Class: text-component

A component with a text field

See TEXT
See COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

component.

Direct subclasses
Direct methods
Direct slots
Slot: text
Initform

(error "text required")

Initargs

:text

Readers

text.

Writers

(setf text).

Class: underline

Representation of underlined text.

See PARENT-COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
Class: underline

The directive for an underline markup.

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

Package

cl-markless.

Source

directive.lisp.

Direct superclasses

surrounding-inline-directive.

Direct methods
Class: underline-option

Representation of the underline compound option.

See COMPOUND-OPTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

compound-option.

Direct methods

output-component.

Class: unit-component

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

See COMPONENT

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

component.

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.

Direct superclasses
Direct methods

output-component.

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.

Direct superclasses

block-directive.

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.

Direct superclasses
Direct methods

output-component.

Class: url

Representation of a literal URL.

See UNIT-COMPONENT
See TARGET

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses
Direct methods
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.

Direct superclasses

inline-directive.

Direct methods
Class: video

Representation of the VIDEO embed type.

See EMBED

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

embed.

Direct methods
Class: warning

Represents a WARNING instruction.

See MESSAGE-INSTRUCTION

Package

cl-markless-components.

Source

component.lisp.

Direct superclasses

message-instruction.

Direct methods

evaluate-instruction.

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.

Direct superclasses
Direct methods

5.2 Internals


5.2.1 Special variables

Special Variable: *current-line-number*
Package

cl-markless.

Source

conditions.lisp.

Special Variable: *level*
Package

cl-markless.

Source

printer.lisp.

Special Variable: *prefixes*
Package

cl-markless.

Source

printer.lisp.


5.2.2 Macros

Macro: %op (s thing &rest args)
Package

cl-markless.

Source

printer.lisp.

Macro: define-printer (class format &rest args)
Package

cl-markless-components.

Source

component.lisp.


5.2.3 Ordinary functions

Function: class-prototype (class)
Package

cl-markless.

Source

toolkit.lisp.

Function: copy-stack-entry (instance)
Package

cl-markless.

Source

parser.lisp.

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.

Function: delegate-paragraph (parser line cursor)
Package

cl-markless.

Source

toolkit.lisp.

Function: find-subclass (subclassish class)
Package

cl-markless.

Source

toolkit.lisp.

Function: last-aref (array)
Package

cl-markless.

Source

toolkit.lisp.

Function: make-color-table (entries)
Package

cl-markless.

Source

color-table.lisp.

Function: make-size-table (entries)
Package

cl-markless.

Source

size-table.lisp.

Function: make-stack-entry (&key directive component)
Package

cl-markless.

Source

parser.lisp.

Function: next-option (line cursor end)
Package

cl-markless.

Source

toolkit.lisp.

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.

Function: pop-newline (stack)
Package

cl-markless.

Source

parser.lisp.

Function: process-stack (parser stack line)
Package

cl-markless.

Source

parser.lisp.

Function: remf* (plist &rest excluded-keys)
Package

cl-markless.

Source

toolkit.lisp.

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.

Function: stack-entry-p (object)
Package

cl-markless.

Source

parser.lisp.

Function: subclasses (class)
Package

cl-markless.

Source

toolkit.lisp.

Function: vector-push-front (element vector)
Package

cl-markless.

Source

toolkit.lisp.


5.2.4 Generic functions

Generic Function: find-compound-option-type (parser option)

Finds a class that can parse the option of the given type name.

For a default parser this will compare the given option name against the class names of the classes mentioned in the parser’s COMPOUND-OPTIONS list. If the given name with "-option" added to its end matches any of the class names case-insensitively, that class is returned.

See PARSE-COMPOND-OPTION

Package

cl-markless.

Methods
Method: find-compound-option-type ((parser parser) option)
Source

directive.lisp.

Generic Function: output-operator (string target markless)
Package

cl-markless.

Methods
Method: output-operator (string target (thing highlighted))
Source

printer.lisp.

Method: output-operator (string target (markless markless))
Source

printer.lisp.

Generic Reader: supported-tags (object)
Package

cl-markless.

Methods
Reader Method: supported-tags ((bbcode bbcode))

automatically generated reader method

Source

printer.lisp.

Target Slot

supported-tags.

Generic Writer: (setf supported-tags) (object)
Package

cl-markless.

Methods
Writer Method: (setf supported-tags) ((bbcode bbcode))

automatically generated writer method

Source

printer.lisp.

Target Slot

supported-tags.


5.2.5 Classes

Class: noop
Package

cl-markless.

Source

directive.lisp.

Direct superclasses

directive.

Direct methods

Appendix A Indexes


A.1 Concepts


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

%
%op: Private macros

(
(setf alignment): Public generic functions
(setf alignment): Public generic functions
(setf author): Public generic functions
(setf author): Public generic functions
(setf block-dispatch-table): Public generic functions
(setf block-dispatch-table): Public generic functions
(setf blue): Public generic functions
(setf blue): Public generic functions
(setf children): Public generic functions
(setf children): Public generic functions
(setf compound-options): Public generic functions
(setf compound-options): Public generic functions
(setf copyright): Public generic functions
(setf copyright): Public generic functions
(setf depth): Public generic functions
(setf depth): Public generic functions
(setf depth): Public generic functions
(setf direction): Public generic functions
(setf direction): Public generic functions
(setf directives): Public generic functions
(setf directives): Public generic functions
(setf directives): Public generic functions
(setf directives): Public generic functions
(setf embed-options): Public generic functions
(setf embed-options): Public generic functions
(setf embed-types): Public generic functions
(setf embed-types): Public generic functions
(setf enabled-p): Public generic functions
(setf enabled-p): Public generic functions
(setf enabled-p): Public generic functions
(setf enabled-p): Public generic functions
(setf encoding): Public generic functions
(setf encoding): Public generic functions
(setf end): Public generic functions
(setf end): Public generic functions
(setf file): Public generic functions
(setf file): Public generic functions
(setf font-family): Public generic functions
(setf font-family): Public generic functions
(setf green): Public generic functions
(setf green): Public generic functions
(setf indentation): Public generic functions
(setf indentation): Public generic functions
(setf inline-dispatch-table): Public generic functions
(setf inline-dispatch-table): Public generic functions
(setf input): Public generic functions
(setf input): Public generic functions
(setf inset): Public generic functions
(setf inset): Public generic functions
(setf instruction-types): Public generic functions
(setf instruction-types): Public generic functions
(setf label): Public generic functions
(setf label): Public generic functions
(setf label): Public generic functions
(setf labels): Public generic functions
(setf labels): Public generic functions
(setf language): Public generic functions
(setf language): Public generic functions
(setf language): Public generic functions
(setf language): Public generic functions
(setf line-break-mode): Public generic functions
(setf line-break-mode): Public generic functions
(setf message): Public generic functions
(setf message): Public generic functions
(setf number): Public generic functions
(setf number): Public generic functions
(setf offset-p): Public generic functions
(setf offset-p): Public generic functions
(setf options): Public generic functions
(setf options): Public generic functions
(setf options): Public generic functions
(setf options): Public generic functions
(setf options): Public generic functions
(setf red): Public generic functions
(setf red): Public generic functions
(setf size): Public generic functions
(setf size): Public generic functions
(setf source): Public generic functions
(setf source): Public generic functions
(setf stack): Public generic functions
(setf stack): Public generic functions
(setf stack-entry-component): Public ordinary functions
(setf stack-entry-directive): Public ordinary functions
(setf start): Public generic functions
(setf start): Public generic functions
(setf supported-tags): Private generic functions
(setf supported-tags): Private generic functions
(setf target): Public generic functions
(setf target): Public generic functions
(setf text): Public generic functions
(setf text): Public generic functions
(setf text): Public generic functions
(setf unit): Public generic functions
(setf unit): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf variable): Public generic functions
(setf variable): Public generic functions

A
alignment: Public generic functions
alignment: Public generic functions
author: Public generic functions
author: Public generic functions

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

C
children: Public generic functions
children: Public generic functions
class-prototype: Private ordinary functions
commit: Public ordinary functions
compile-dispatch-table: Public ordinary functions
compound-options: Public generic functions
compound-options: Public generic functions
condense-children: Public ordinary functions
condense-component-tree: Public ordinary functions
consume-end: Public generic functions
consume-end: Public generic functions
consume-end: Public generic functions
consume-end: Public generic functions
consume-end: Public generic functions
consume-end: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
consume-prefix: Public generic functions
copy-stack-entry: Private ordinary functions
copyright: Public generic functions
copyright: Public generic functions
count-words: Public generic functions
count-words: Public generic functions
count-words: Public generic functions
count-words: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
count-words-by: Public generic functions
cursor: Public generic functions
cursor: Public generic functions

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

E
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-option-allowed-p: Public generic functions
embed-options: Public generic functions
embed-options: Public generic functions
embed-type: Public generic functions
embed-type: Public generic functions
embed-type: Public generic functions
embed-types: Public generic functions
embed-types: Public generic functions
enable: Public generic functions
enable: Public generic functions
enabled-p: Public generic functions
enabled-p: Public generic functions
encoding: Public generic functions
encoding: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
end: Public generic functions
ends-with: Public ordinary functions
ensure-compound-option: Public ordinary functions
ensure-directive: Public ordinary functions
ensure-embed-option: Public ordinary functions
ensure-embed-type: Public ordinary functions
ensure-instruction-type: Public ordinary functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions
evaluate-instruction: Public generic functions

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

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

I
indentation: Public generic functions
indentation: Public generic functions
initialize-instance: Public standalone methods
inline-dispatch-table: Public generic functions
inline-dispatch-table: Public generic functions
input: Public generic functions
input: Public generic functions
inset: Public generic functions
inset: Public generic functions
instruction: Public generic functions
instruction: Public generic functions
instruction: Public generic functions
instruction-types: Public generic functions
instruction-types: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions
invoke: Public generic functions

L
label: Public generic functions
label: Public generic functions
labels: Public generic functions
labels: Public generic functions
language: Public generic functions
language: Public generic functions
language: Public generic functions
language: Public generic functions
last-aref: Private ordinary functions
line: Public generic functions
line: Public generic functions
line-break-mode: Public generic functions
line-break-mode: Public generic functions
list-output-formats: Public ordinary functions

M
Macro, %op: Private macros
Macro, define-output: Public macros
Macro, define-printer: Private macros
Macro, match!: Public macros
make-color-table: Private ordinary functions
make-size-table: Private ordinary functions
make-stack-entry: Private ordinary functions
match!: Public macros
message: Public generic functions
message: Public generic functions
message: Public generic functions
message: Public generic functions
message: Public generic functions
Method, (setf alignment): Public generic functions
Method, (setf author): Public generic functions
Method, (setf block-dispatch-table): Public generic functions
Method, (setf blue): Public generic functions
Method, (setf children): Public generic functions
Method, (setf compound-options): Public generic functions
Method, (setf copyright): Public generic functions
Method, (setf depth): Public generic functions
Method, (setf depth): Public generic functions
Method, (setf direction): Public generic functions
Method, (setf directives): Public generic functions
Method, (setf directives): Public generic functions
Method, (setf embed-options): Public generic functions
Method, (setf embed-types): Public generic functions
Method, (setf enabled-p): Public generic functions
Method, (setf enabled-p): Public generic functions
Method, (setf enabled-p): Public generic functions
Method, (setf encoding): Public generic functions
Method, (setf end): Public generic functions
Method, (setf file): Public generic functions
Method, (setf font-family): Public generic functions
Method, (setf green): Public generic functions
Method, (setf indentation): Public generic functions
Method, (setf inline-dispatch-table): Public generic functions
Method, (setf input): Public generic functions
Method, (setf inset): Public generic functions
Method, (setf instruction-types): Public generic functions
Method, (setf label): Public generic functions
Method, (setf label): Public generic functions
Method, (setf labels): Public generic functions
Method, (setf language): Public generic functions
Method, (setf language): Public generic functions
Method, (setf language): Public generic functions
Method, (setf line-break-mode): Public generic functions
Method, (setf message): Public generic functions
Method, (setf number): Public generic functions
Method, (setf offset-p): Public generic functions
Method, (setf options): Public generic functions
Method, (setf options): Public generic functions
Method, (setf options): Public generic functions
Method, (setf options): Public generic functions
Method, (setf red): Public generic functions
Method, (setf size): Public generic functions
Method, (setf source): Public generic functions
Method, (setf stack): Public generic functions
Method, (setf start): Public generic functions
Method, (setf supported-tags): Private generic functions
Method, (setf target): Public generic functions
Method, (setf text): Public generic functions
Method, (setf text): Public generic functions
Method, (setf unit): Public generic functions
Method, (setf value): Public generic functions
Method, (setf variable): Public generic functions
Method, alignment: Public generic functions
Method, author: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, begin: Public generic functions
Method, block-dispatch-table: Public generic functions
Method, blue: Public generic functions
Method, children: Public generic functions
Method, compound-options: Public generic functions
Method, consume-end: Public generic functions
Method, consume-end: Public generic functions
Method, consume-end: Public generic functions
Method, consume-end: Public generic functions
Method, consume-end: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, consume-prefix: Public generic functions
Method, copyright: Public generic functions
Method, count-words: Public generic functions
Method, count-words: Public generic functions
Method, count-words: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, count-words-by: Public generic functions
Method, cursor: Public generic functions
Method, depth: Public generic functions
Method, depth: Public generic functions
Method, direction: Public generic functions
Method, directive: Public generic functions
Method, directive: Public generic functions
Method, directive-instance: Public generic functions
Method, directives: Public generic functions
Method, directives: Public generic functions
Method, directives-of: Public generic functions
Method, disable: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-option-allowed-p: Public generic functions
Method, embed-options: Public generic functions
Method, embed-type: Public generic functions
Method, embed-type: Public generic functions
Method, embed-types: Public generic functions
Method, enable: Public generic functions
Method, enabled-p: Public generic functions
Method, encoding: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, end: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, evaluate-instruction: Public generic functions
Method, file: Public generic functions
Method, find-compound-option-type: Private generic functions
Method, find-embed-option-type: Public generic functions
Method, find-embed-type: Public generic functions
Method, find-instruction-type: Public generic functions
Method, font-family: Public generic functions
Method, green: Public generic functions
Method, indentation: Public generic functions
Method, initialize-instance: Public standalone methods
Method, inline-dispatch-table: Public generic functions
Method, input: Public generic functions
Method, inset: Public generic functions
Method, instruction: Public generic functions
Method, instruction: Public generic functions
Method, instruction-types: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, invoke: Public generic functions
Method, label: Public generic functions
Method, labels: Public generic functions
Method, language: Public generic functions
Method, language: Public generic functions
Method, language: Public generic functions
Method, line: Public generic functions
Method, line-break-mode: Public generic functions
Method, message: Public generic functions
Method, message: Public generic functions
Method, message: Public generic functions
Method, number: Public generic functions
Method, offset-p: Public generic functions
Method, option: Public generic functions
Method, options: Public generic functions
Method, options: Public generic functions
Method, options: Public generic functions
Method, options: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions
Method, output-component: Public generic functions