The staple Reference Manual

This is the staple Reference Manual, version 2.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Feb 15 07:32:24 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 staple

A tool to generate documentation about Lisp projects through an HTML template.

Maintainer

Yukari Hafner <>

Author

Yukari Hafner <>

Home Page

https://Shinmera.github.io/staple/

Source Control

(GIT https://github.com/Shinmera/staple.git)

Bug Tracker

https://github.com/Shinmera/staple/issues

License

zlib

Version

2.0.0

Dependencies
  • staple-package-recording (system).
  • staple-code-parser (system).
  • babel (system).
  • clip (system).
  • cl-ppcre (system).
  • definitions (system).
  • pathname-utils (system).
  • language-codes (system).
  • documentation-utils (system).
Source

staple.asd.

Child Components

2.2 staple-package-recording

Collects information about packages being defined with an ASDF system.

Maintainer

Yukari Hafner <>

Author

Yukari Hafner <>

Home Page

https://Shinmera.github.io/staple/

Source Control

(GIT https://github.com/Shinmera/staple.git)

Bug Tracker

https://github.com/Shinmera/staple/issues

License

zlib

Version

1.0.1

Source

staple-package-recording.asd.

Child Component

recording.lisp (file).


2.3 staple-code-parser

A code parser tool for documentation markup

Maintainer

Yukari Hafner <>

Author

Yukari Hafner <>

Home Page

https://Shinmera.github.io/staple/

Source Control

(GIT https://github.com/Shinmera/staple.git)

Bug Tracker

https://github.com/Shinmera/staple/issues

License

zlib

Version

1.0.0

Dependencies
  • alexandria (system).
  • definitions (system).
  • concrete-syntax-tree (system).
  • concrete-syntax-tree-lambda-list (system).
  • concrete-syntax-tree-destructuring (system).
  • eclector (system).
  • eclector-concrete-syntax-tree (system).
  • documentation-utils (system).
Source

staple-code-parser.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 staple/staple.asd

Source

staple.asd.

Parent Component

staple (system).

ASDF Systems

staple.


3.1.2 staple-package-recording/staple-package-recording.asd

Source

staple-package-recording.asd.

Parent Component

staple-package-recording (system).

ASDF Systems

staple-package-recording.


3.1.3 staple-code-parser/staple-code-parser.asd

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

ASDF Systems

staple-code-parser.


3.1.4 staple/package.lisp

Source

staple.asd.

Parent Component

staple (system).

Packages

staple.


3.1.5 staple/toolkit.lisp

Dependency

package.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

3.1.6 staple/xref.lisp

Dependency

toolkit.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

3.1.7 staple/transform.lisp

Dependency

xref.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

*pathname-type-type-map* (special variable).


3.1.8 staple/code-format.lisp

Dependency

transform.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

make-xref-link (function).


3.1.9 staple/clip.lisp

Dependency

code-format.lisp (file).

Source

staple.asd.

Parent Component

staple (system).


3.1.10 staple/page.lisp

Dependency

clip.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

3.1.11 staple/project.lisp

Dependency

page.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface
Internals

3.1.12 staple/inference.lisp

Dependency

project.lisp (file).

Source

staple.asd.

Parent Component

staple (system).

Public Interface

3.1.13 staple/documentation.lisp

Dependency

inference.lisp (file).

Source

staple.asd.

Parent Component

staple (system).


3.1.14 staple-package-recording/recording.lisp

Source

staple-package-recording.asd.

Parent Component

staple-package-recording (system).

Packages

staple-package-recording.

Public Interface
Internals

3.1.15 staple-code-parser/package.lisp

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Packages

staple-code-parser.


3.1.16 staple-code-parser/environment.lisp

Dependency

package.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Public Interface
Internals

3.1.17 staple-code-parser/walker.lisp

Dependency

environment.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Public Interface
Internals

client (class).


3.1.18 staple-code-parser/special-forms.lisp

Dependency

walker.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Public Interface

3.1.19 staple-code-parser/standard-forms.lisp

Dependency

special-forms.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Public Interface
Internals

3.1.20 staple-code-parser/to-definitions.lisp

Dependency

standard-forms.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).

Public Interface

3.1.21 staple-code-parser/documentation.lisp

Dependency

to-definitions.lisp (file).

Source

staple-code-parser.asd.

Parent Component

staple-code-parser (system).


4 Packages

Packages are listed by definition order.


4.1 staple-code-parser

Source

package.lisp.

Nickname

org.shirakumo.staple.code-parser

Use List
  • alexandria.
  • common-lisp.
Public Interface
Internals

4.2 staple

Source

package.lisp.

Nickname

org.shirakumo.staple

Use List
Public Interface
Internals

4.3 staple-package-recording

Source

recording.lisp.

Nickname

org.shirakumo.staple.recording

Use List

common-lisp.

Used By List

staple.

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: *default-template*

Pathname to the default Clip template used for simple pages.

See SIMPLE-PAGE

Package

staple.

Source

inference.lisp.

Special Variable: *document-patterns*

A list of regular expression patterns that recognise document files.

An expression in this list should match the filename of a file that denotes a documentation body file.

Package

staple.

Source

inference.lisp.

Special Variable: *image-patterns*

A list of regular expression patterns that recognise image files.

An expression in this list should match the filename of a file that denotes an image file.

Package

staple.

Source

inference.lisp.

Special Variable: *load-prohibited-systems*

A list of ASDF:SYSTEM instances that should not be loaded for extensions.

This is a curated list of special systems that cause problems when being loaded as part of the LOAD-EXTENSION mechanism.

See LOAD-EXTENSION

Package

staple.

Source

project.lisp.

Special Variable: *page*

Variable bound to the current page during generation.

See PAGE
See GENERATE

Package

staple.

Source

page.lisp.


5.1.2 Macros

Macro: define-definition-resolver (type (source &rest args) &body body)

Shorthand to define a find-definitions method and destructure the arguments of the parse result.

See FIND-DEFINITIONS

Package

staple-code-parser.

Source

to-definitions.lisp.

Macro: define-source-compiler ((type &rest pathname-types) (input) &body body)

Defines a new source compiler variant.

This is a shorthand that sets the PATHNAME-TYPE->TYPE association and defines a new method on COMPILE-SOURCE to handle the conversion. Thus, the TYPE should be a keyword identifying the source type, and PATHNAME-TYPES should be an enumeration of known file types that are used for this kind of conversion. You may also leave this empty if you are defining a source type conversion that is not usually backed by explicit files.

See PATHNAME-TYPE->TYPE
See COMPILE-SOURCE

Package

staple.

Source

transform.lisp.

Macro: define-sub-results (type args &body body)

Shorthand to define a sub-results method and destructure the arguments of the parse result.

See SUB-RESULTS

Package

staple-code-parser.

Source

to-definitions.lisp.

Macro: define-walk-compound-form (operator (cst-var &optional environment-var) &body body)

Shorthand to define a WALK-FORM method.

Adds local functions for WALK and WALK-IMPLICIT-PROGN that automatically pass the environment along so you don’t need to repeat it.

See WALK-FORM

Package

staple-code-parser.

Source

walker.lisp.

Macro: define-walker-form (form (cst-var &optional environment-var source) &body body)

Shorthand to define simple walker forms.

The FORM should be a destructuring description of the kind of form to walk. The return value of the BODY should be the list of additional arguments for the parse result. The type and source of the parse result are automatically added for you.

If you need control over the type or source, look at DEFINE-WALK-COMPOUND-FORM instead.

See DEFINE-WALK-COMPOUND-FORM

Package

staple-code-parser.

Source

walker.lisp.

Macro: define-xref-resolver (name args &body body)

Defines a new cross-reference resolver function.

The lambda-list should accept one required argument, the definition instance to find a cross-reference for.
The name can be either a name for the resolver, or a list of name and priority number.

See XREF-RESOLVER
See REMOVE-XREF-RESOLVER
See RESOLVE-XREF

Package

staple.

Source

xref.lisp.

Macro: with-stream ((stream designator &rest args) &body body)

Handles stream opening and closing, returning a useful value.

Essentially this calls ENSURE-STREAM on the designator and the args. Upon unwinding, CLOSE is called on the stream. On successful exit of the body, STREAM-VALUE is returned.

See ENSURE-STREAM
See STREAM-VALUE

Package

staple.

Source

toolkit.lisp.


5.1.3 Ordinary functions

Function: absolute-source-location (source-location)

Translates the given Definitions source-location into an absolute one.

This will read the source file to determine the absolute row/line and col/char pointed at by the source-location. It returns another plist of the following keys:

:FILE — The same as in the input.
:OFFSET — The absolute file-position offset.
:ROW — The row/line of the offset.
:COL — The col/char of the offset.

Returns NIL if the file cannot be found, the source-location is NIL, or the file cannot be parsed.

See SKIP-TO-SOURCE-FORM

Package

staple.

Source

toolkit.lisp.

Function: augment-environment! (environment names values)

Augments the given environment with the new values for the given names.

Returns the modified environment.

See LOOKUP
See ENVIRONMENT

Package

staple-code-parser.

Source

environment.lisp.

Function: augmented-environment (parent names values &key class)

Returns a new environment with the changed values in place.

The old environment is a parent to the new one.

See AUGMENT-ENVIRONMENT!
See ENVIRONMENT

Package

staple-code-parser.

Source

environment.lisp.

Function: ensure-package (package)

Turns the given thing into a CL:PACKAGE.

If the thing cannot be coerced, an error is signalled.

Package

staple.

Source

toolkit.lisp.

Function: ensure-package-definition (package)

Turns the given thing into a DEFINITIONS:PACKAGE.

If the thing cannot be coerced, an error is signalled.

Package

staple.

Source

toolkit.lisp.

Function: extract-language (string)

Attempts to find a valid two or three-letter language code in the string.

If a code can be found, two values are returned: the code itself and the list of names for the language the code points to.

See LANGUAGE-CODES:NAMES

Package

staple.

Source

toolkit.lisp.

Function: find-definitions-for-identifier (name &key package type)

Attempts to find all definitions for the given symbol identifier.

The symbol is given in two parts – as its name, and package. The list of returned definitions may optionally be filtered by the given type argument.

If no package is given, the definitions are attempted to be found in the packages stored in *PAGE*, or the CL package.

See *PAGE*
See PACKAGES
See DEFINITIONS:FIND-DEFINITIONS

Package

staple.

Source

xref.lisp.

Function: find-files (directory patterns &key max-depth exclude)

Find all files in the directory tree that match one of the patterns.

The patterns should be regular expressions suitable for CL-PPCRE. They are matched against the file-namestrings of the files in the directory tree.

See DO-DIRECTORY-TREE

Package

staple.

Source

toolkit.lisp.

Function: load-extension (system)

Loads the extension file of the system.

This ensures that all Staple extensions and customisations that the system might need are present and loaded when the documentation is generated.

It proceeds as follows:
1. The argument is coerced to an ASDF:SYSTEM
2. If the system was already involved in a LOAD-EXTENSION call within this call tree, NIL is returned immediately.
3. Otherwise the system is loaded via ASDF:LOAD-SYSTEM, with warnings and standard-output muffled.
4. For each dependency registered for the system, LOAD-EXTENSION is called again to ensure dependant extensions are loaded first. 5. The EXTENSION-FILE, if present, is LOADed.
6. The system is returned.

See ASDF:LOAD-SYSTEM
See CL:LOAD

Package

staple.

Source

project.lisp.

Function: load-system-quietly (system)

Loads the given ASDF:SYSTEM quietly.

This muffles warnings and suppresses *standard-output*.

See ASDF:LOAD-SYSTEM

Package

staple.

Source

toolkit.lisp.

Function: markup-code-block (node)

Transforms the node’s content treating it as a code block.

Only the textual contents of the node are inspected, any other kinds of tag that may be a child to the block will be removed by this.

All definitions that are recognised in this that have a result for XREF will be marked up by an <a> tag with the class "xref".

Note that the value of *PACKAGE* matters for the parsing of the code blocks, as a full READ and walk is performed on it to find symbols and their usage in the code snippet.

Note also that if invalid code or non-lisp code is encountered an error may be signalled by the reader.

See XREF
See STAPLE-CODE-PARSER:PARSE
See STAPLE-CODE-PARSER:PARSE-RESULT->DEFINITION-LIST

Package

staple.

Source

code-format.lisp.

Function: markup-code-reference (node)

Transforms the node’s content treating it as a definition reference.

Only the textual contents of the node are inspected, any other kinds of tag that may be a child to the block will be removed by this.

This simply uses XREF on the textual content and if a result is returned, inserts an <a> tag with the class "xref" to provide the link.

See XREF

Package

staple.

Source

code-format.lisp.

Function: markup-code-snippets (html)

Attempts to mark up the code snippets in the given HTML text.

This looks for <code> tags within the given HTML and will try to automatically insert xref links. It performs transformations as follows: Each <code> tag that is direct child to a <pre> tag is transformed using MARKUP-CODE-BLOCK, with the intention that the <code> element contains full code snippets. <code> tags without a <pre> parent will be transformed using MARKUP-CODE-REFERENCE, with the idea that these will only contain single symbol names that represent direct references to definitions.

If an error occurs during the markup of a tag, a SKIP-TAG restart will be available to allow skipping that particular tag.

The return value of this function is a PLUMP:NODE if the argument is also a PLUMP:NODE, and a STRING if the argument is either a STRING or a PATHNAME.

See MARKUP-CODE-BLOCK
See MARKUP-CODE-REFERENCE

Package

staple.

Source

code-format.lisp.

Function: markup-code-snippets-ignoring-errors (html)

Marks up the code snippets ignoring parts that fail during markup.

See MARKUP-CODE-SNIPPETS

Package

staple.

Source

code-format.lisp.

Function: maybe-lang-docstring (definition language)

Attempts to find a docstring for the given definition in the given language.

If the multilang-documentation system is loaded, then this consults MULTILANG-DOCUMENTATION:DOCUMENTATION using the DEFINITIONS:OBJECT
and T as arguments, and alternatively the DEFINITIONS:DESIGNATOR and DEFINITIONS:TYPE. If either the system is not loaded, or it fails to return anything for both queries, it falls back to just returning the DEFINITIONS:DOCUMENTATION.

See MULTILANG-DOCUMENTATION:DOCUMENTATION
See DEFINITIONS:DOCUMENTATION

Package

staple.

Source

toolkit.lisp.

Function: parse-result->definition-list (result)

Turn the parse-result into a list of definitions and source locations.

For instance:
((:CALL (0 . 10) (:VARIABLE (1 . 5) NULL) (:LITERAL (6 . 9) NIL))) => ((#<DEFINITIONS:FUNCTION NULL> (1 . 5)))

This uses FIND-DEFINITIONS to find suitable definitions for a parse result, as well as SUB-RESULTS to traverse the parse result tree.

See FIND-DEFINITIONS
See SUB-RESULTS

Package

staple-code-parser.

Source

to-definitions.lisp.

Function: pathname-type->type (type &optional errorp)

Returns a keyword for the given pathname-type, if it is known.

If ERRORP is non-NIL and no type can be found, an error is signalled.

When used as a setf-place, the value should be a list of pathname-type strings that should be associated with the given type. Note that this is overriding, meaning that previous associations to the given type are removed.

See COMPILE-SOURCE
See DEFINE-SOURCE-COMPILER

Package

staple.

Source

transform.lisp.

Function: (setf pathname-type->type) (type)
Package

staple.

Source

transform.lisp.

Function: preferred-definition (definitions)

Returns the list sorted such that the most important, or preferred definitions, come first.

See DEFINITION-IMPORTANCE

Package

staple.

Source

toolkit.lisp.

Function: purify-arglist (arglist)

Purifies the given arguments list / lambda-list.

This function is useful for presenting the user-interface part of a lambda-list. Thus it trims all extraneous information that the user of a function or macro does not need to know about.

Specifically this does the following, depending on the current lambda-list-keyword in the arglist:

REQUIRED — The argument is purified recursively if it is a list, and retained verbatim otherwise. &OPTIONAL — Only the variable name is retained.
&KEY — Only the variable’s keyword-name is retained. &WHOLE — The argument is removed.
&ENVIRONMENT — The argument is removed.
&AUX — The argument is removed.

Package

staple.

Source

toolkit.lisp.

Function: read-file (path)

Reads the given file to a string and returns it.

Package

staple.

Source

toolkit.lisp.

Function: remove-xref-resolver (name)

Removes the cross-reference resolver of the given name.

See XREF-RESOLVER

Package

staple.

Source

xref.lisp.

Function: resolve-xref (definition)

Calls each cross-reference resolver with the definition until one returns a valid reference.

See XREF-RESOLVER
See DEFINE-XREF-RESOLVER

Package

staple.

Source

xref.lisp.

Function: sort-definitions (definitions)

Sorts the list of definitions into a natural order.

Definitions of different type are sorted by DEFINITION-ORDER. Definitions of the same type are sorted by STRING< using DEFINITIONS:NAME as the key.

The sort is performed stably.

See DEFINITION-ORDER

Package

staple.

Source

toolkit.lisp.

Function: tie-to-source (source defs)

Turns each def into a list of source and def.

Package

staple-code-parser.

Source

to-definitions.lisp.

Function: url-encode (thing &optional external-format)

Performs percent, or url-encoding of the string.

Package

staple.

Source

toolkit.lisp.

Function: walk-bindings (bindings environment)

Walk the set of LET bindings in the environment.

Returns a list of cons cells where the CAR is the variable definition of the binding and the cdr is the parse result of the value.

See WALK

Package

staple-code-parser.

Source

walker.lisp.

Function: walk-body (cst environment)

Same as WALK-IMPLICIT-PROGN, but filters out declarations from the cst.

See WALK-IMPLICIT-PROGN

Package

staple-code-parser.

Source

walker.lisp.

Function: walk-implicit-progn (cst environment)

Walks the CST as a list of forms and returns the list of parse-results for each form.

See WALK

Package

staple-code-parser.

Source

walker.lisp.

Function: walk-lambda-like (cst environment &optional lambda-list-parser)

Walk a lambda-like structure.

Parses the lambda-list and body forms appropriately and returns a parse-result for a lambda. The given parser is used to process the lambda-list.

See WALK-IMPLICIT-PROGN

Package

staple-code-parser.

Source

walker.lisp.

Function: xref-resolver (name)

Accessor to the cross-reference resolver of the given name.

The resolver should be a function of one argument, a definition instance. It should return either NIL, or a URL string.

Default xref-resolvers for the current page that’s being generated, and the common-lisp package, are defined.

It is useful to define addition resolvers if you have some kind of source of documentation that you would like to be able to link to.

Resolvers allow an optional priority number to control in which order they’re invoked. When reading the resolver, the priority is returned as the second value.

See REMOVE-XREF-RESOLVER
See DEFINE-XREF-RESOLVER
See RESOLVE-XREF

Package

staple.

Source

xref.lisp.

Function: (setf xref-resolver) (name &optional priority)
Package

staple.

Source

xref.lisp.


5.1.4 Generic functions

Generic Function: compile-source (source type)

Compiles the source to a usable format, interpreting it as the given type.

The following argument combinations have specifically defined behaviour:

Source: Type: Explanation: ——————————————————————– PATHNAME (EQL T) — COMPILE-SOURCE is called again using the pathname’s pathname-type as type argument. PATHNAME T — COMPILE-SOURCE is called again using the contents of the file in string form as source argument.
T STRING — COMPILE-SOURCE is called again using the type returned by PATHNAME-TYPE->TYPE as the type argument.

You should add methods to this function specialising on a particular source type to handle the translation appropriately.

See PATHNAME-TYPE->TYPE
See DEFINE-SOURCE-COMPILER

Package

staple.

Source

transform.lisp.

Methods
Method: compile-source ((document pathname) (page simple-page))
Source

inference.lisp.

Method: compile-source ((input string) (type (eql :text)))
Method: compile-source ((input string) (type (eql :html)))
Method: compile-source ((source pathname) (type (eql t)))
Method: compile-source ((source pathname) type)
Method: compile-source (source (type string))
Generic Function: current-commit (system)
Package

staple.

Methods
Method: current-commit ((system system))
Source

page.lisp.

Generic Function: definition-id (definition)

Returns a string representing a unique ID for the given definition.

This is useful for creating links and anchors for definitions in a document.

Package

staple.

Source

toolkit.lisp.

Methods
Method: definition-id ((definition global-definition))
Method: definition-id ((definition package))
Generic Function: definition-importance (definition)

Returns a number for the given definition, used to determine if one definition should receive precedence over another.

By default, the following sorting is applied:

DEFINITIONS:CALLABLE 30
DEFINITIONS:TYPE 20
DEFINITIONS:VARIABLE 10
DEFINITIONS:DEFINITION 0
DEFINITIONS:METHOD -10

See PREFERRED-DEFINITION

Package

staple.

Source

toolkit.lisp.

Methods
Method: definition-importance ((_ callable))
Method: definition-importance ((_ type))
Method: definition-importance ((_ variable))
Method: definition-importance ((_ definition))
Method: definition-importance ((_ method))
Generic Function: definition-order (definition)

Returns a number for the given definition, used for sorting.

The higher the number, the earlier the definition should appear in the sorting.

By default, the following sorting is applied:

DEFINITIONS:PACKAGE 200
DEFINITIONS:CONSTANT 190
DEFINITIONS:SYMBOL-MACRO 180
DEFINITIONS:SPECIAL-VARIABLE 170
DEFINITIONS:VARIABLE 160
DEFINITIONS:CLASS 150
DEFINITIONS:CONDITION 140
DEFINITIONS:STRUCTURE 130
DEFINITIONS:TYPE-DEFINITION 120
DEFINITIONS:TYPE 110
DEFINITIONS:ACCESSOR 100
DEFINITIONS:FUNCTION 90
DEFINITIONS:GENERIC-FUNCTION 80
DEFINITIONS:METHOD 70
DEFINITIONS:COMPILER-MACRO 60
DEFINITIONS:MACRO 50
DEFINITIONS:SETF-EXPANDER 40
DEFINITIONS:CALLABLE 30 DEFINITIONS:METHOD-COMBINATION 20
DEFINITIONS:GLOBAL-DEFINITION 10
DEFINITIONS:DEFINITION 0

See SORT-DEFINITIONS

Package

staple.

Source

toolkit.lisp.

Methods
Method: definition-order ((_ package))
Method: definition-order ((_ constant))
Method: definition-order ((_ symbol-macro))
Method: definition-order ((_ special-variable))
Method: definition-order ((_ variable))
Method: definition-order ((_ class))
Method: definition-order ((_ condition))
Method: definition-order ((_ structure))
Method: definition-order ((_ type-definition))
Method: definition-order ((_ type))
Method: definition-order ((_ function))
Method: definition-order ((_ generic-function))
Method: definition-order ((_ method))
Method: definition-order ((_ compiler-macro))
Method: definition-order ((_ macro))
Method: definition-order ((_ setf-expander))
Method: definition-order ((_ callable))
Method: definition-order ((_ method-combination))
Method: definition-order ((_ global-definition))
Method: definition-order ((_ definition))
Generic Function: definition-wanted-p (definition page)

This function should return T if the definition should be included in the page’s definitions index.

See DEFINITIONS-INDEX-PAGE

Package

staple.

Source

page.lisp.

Methods
Method: definition-wanted-p ((definition declaration) (project simple-page))
Source

inference.lisp.

Method: definition-wanted-p ((definition compiler-macro) (project simple-page))
Source

inference.lisp.

Method: definition-wanted-p ((definition package) (project simple-page))
Source

inference.lisp.

Method: definition-wanted-p ((definition method) (project simple-page))
Source

inference.lisp.

Method: definition-wanted-p ((definition definition) (project simple-page))
Source

inference.lisp.

Method: definition-wanted-p ((definition definition) (page definitions-index-page))
Generic Function: definitions (page package)

This function should return a list of applicable definitions for the given page and package.

By default this will simply compute /all/ definitions in the package
and only keeping wanted ones by DEFINITION-WANTED-P.

The returned list of definitions is always sorted in the natural order
as described by SORT-DEFINITIONS.

See DEFINITION-WANTED-P
See SORT-DEFINITIONS

Package

staple.

Source

page.lisp.

Methods
Method: definitions :around (page package)
Method: definitions ((page definitions-index-page) package)
Generic Reader: document (object)

Accessor for the document the simple-page will include in its body.

This should be a pathname to a file that can be parsed by COMPILE-SOURCE.

See SIMPLE-PAGE
See COMPILE-SOURCE

Package

staple.

Methods
Reader Method: document ((simple-page simple-page))

automatically generated reader method

Source

inference.lisp.

Target Slot

document.

Generic Writer: (setf document) (object)
Package

staple.

Methods
Writer Method: (setf document) ((simple-page simple-page))

automatically generated writer method

Source

inference.lisp.

Target Slot

document.

Generic Reader: document-package (object)
Package

staple.

Methods
Reader Method: document-package ((simple-page simple-page))

automatically generated reader method

Source

inference.lisp.

Target Slot

document-package.

Generic Writer: (setf document-package) (object)
Package

staple.

Methods
Writer Method: (setf document-package) ((simple-page simple-page))

automatically generated writer method

Source

inference.lisp.

Target Slot

document-package.

Generic Function: documents (system)

Returns a list of pathnames to documents relevant for the given system.

By default this will attempt a heuristic by searching for files that can be parsed by PATHNAME-TYPE->TYPE, and match one of the *DOCUMENT-PATTERNS* within the system’s source directory.

You may add a method specialising on a particular system to change which documents are used for an inferred project.

See PATHNAME-TYPE->TYPE
See *DOCUMENT-PATTERNS*
See INFER-PROJECT

Package

staple.

Methods
Method: documents ((system system))
Source

inference.lisp.

Generic Function: extension-file (system)

Returns the Staple extension source file for the ASDF:SYSTEM.

By default this is a file called "staple.ext.lisp" within the system’s source directory.

This function may return NIL to indicate that the system has no extension file.

See ASDF:SYSTEM-SOURCE-DIRECTORY

Package

staple.

Source

project.lisp.

Methods
Method: extension-file (system)
Generic Function: filename (page)

Returns a suitable pathname making up the filename of the page.

By default for simple-pages this is the name "index" followed by the language code of the page, if the language is not :en or :eng, and the type "html".

See SIMPLE-PAGE

Package

staple.

Methods
Method: filename ((page simple-page))
Source

inference.lisp.

Generic Function: find-definitions (type source args)

Returns any matching definitions for the given parse result.

All parse results have the structure of (TYPE SOURCE . ARGS). Thus you can simply destructure it and pass the arguments to this function to retrieve its definitions.

See DEFINE-DEFINITION-RESOLVER

Package

staple-code-parser.

Methods
Method: find-definitions ((type1 (eql function)) source args0)
Source

to-definitions.lisp.

Method: find-definitions ((type1 (eql :type)) source args0)
Source

to-definitions.lisp.

Method: find-definitions ((type1 (eql :variable)) source args0)
Source

to-definitions.lisp.

Method: find-definitions ((type1 (eql :macro)) source args0)
Source

to-definitions.lisp.

Method: find-definitions ((type1 (eql :call)) source args0)
Source

to-definitions.lisp.

Method: find-definitions (type source args)
Source

to-definitions.lisp.

Generic Function: find-project (project &key &allow-other-keys)

Find and return the project for the given project designator.

Typically the project designator will be an ASDF:SYSTEM.

If you want to define a custom project for your system, you should add a method specialising on your system instance to this function and have it return the appropriately filled out project instance.

By default this will first call LOAD-EXTENSION on the system, and will then call itself again if it can now find new methods specialising either on the system’s instance or its name as a keyword. Otherwise it simply returns NIL.

See LOAD-EXTENSION

Package

staple.

Source

project.lisp.

Methods
Method: find-project ((system system) &rest args)
Method: find-project (name &rest args)
Generic Function: format-documentation (definition page)

Formats the definition according to the page’s preferences.

This function should be called to retrieve fully formatted HTML to use as the documentation for a given definition on a page.

By default this will call MAYBE-LANG-DOCSTRING on the definition and the page’s language to retrieve the raw docstring, and then call FORMAT-DOCUMENTATION again with the docstring and the page.

If a string is passed, it will by default parse it in the "See" style wherein each Line beginning with "See" is treated as a line indicating a source cross-reference. The rest of the line is interpreted as a designator for another definition and is turned into an xref link if possible.

If you would prefer other documentation styles, you should add a method specialising on a custom page type, then use that page type in your project.

See DEFINITIONS-INDEX-PAGE
See MAYBE-LANG-DOCSTRING
See XREF

Package

staple.

Source

page.lisp.

Methods
Method: format-documentation ((docstring string) (page definitions-index-page))
Method: format-documentation ((null null) (page definitions-index-page))
Method: format-documentation ((definition definition) (page definitions-index-page))
Generic Function: generate (page &key if-exists compact &allow-other-keys)

Generate the outputs of the given object.

The value returned by this function should be some kind of identifier of the outputs that were generated by the call to this function. In the case of a page, this will be the output file or result produced by the page. In the case of a project, this will typically be the project itself, and a list of the results from the pages it generated.

If this function is called with something that isn’t a project or page then the argument is treated as a potential ASDF:SYSTEM and is coerced to one by ASDF:FIND-SYSTEM. It will then try to find a project for the system by first consulting FIND-PROJECT, and then INFER-PROJECT. If both FIND-PROJECT and INFER-PROJECT fail, an error is signalled. Otherwise, GENERATE is called on the newly retrieved project.

See PAGE
See PROJECT
See *PAGE*
See FIND-PROJECT
See INFER-PROJECT

Package

staple.

Source

page.lisp.

Methods
Method: generate (project &rest args)
Source

project.lisp.

Method: generate ((project project) &rest args)
Source

project.lisp.

Method: generate ((page templated-page) &key if-exists compact)
Method: generate ((page compiled-page) &key if-exists compact)
Method: generate ((page static-page) &key if-exists)
Method: generate :before ((page input-page) &key)
Method: generate :before ((page page) &key)
Method: generate :around ((page page) &key)
Generic Function: images (object)

Returns a list of pathnames to images relevant for the given system.

By default this will attempt a heuristic by searching for files that match one of the *IMAGE-PATTERNS* within the system’s source directory.

You may add a method specialising on a particular system to change which images are used for an inferred project.

See *IMAGE-PATTERNS*
See INFER-PROJECT

Package

staple.

Methods
Method: images ((system system))
Source

inference.lisp.

Reader Method: images ((simple-page simple-page))

automatically generated reader method

Source

inference.lisp.

Target Slot

images.

Generic Writer: (setf images) (object)
Package

staple.

Methods
Writer Method: (setf images) ((simple-page simple-page))

automatically generated writer method

Source

inference.lisp.

Target Slot

images.

Generic Function: infer-project (project &key output-directory images documents page-type template packages subsystems &allow-other-keys)

Attempts to infer a project suitable for the given ASDF:SYSTEM.

By default this consults a variety of functions and attempts to build a suitable SIMPLE-PROJECT instance that should document the system. If you want to control how the documentation is generated, you may either specialise the functions INFER-PROJECT uses, or construct your own project entirely by specialising on FIND-PROJECT instead.

INFER-PROJECT proceeds as follows:
1. If no :OUTPUT-DIRECTORY is given, it is found via OUTPUT-DIRECTORY. 2. If no :DOCUMENTS are given, they are found via DOCUMENTS.
3. If no :IMAGES are given, they are found via IMAGES.
4. If no :PAGE-TYPE is given, it is found via PAGE-TYPE.
5. If no :TEMPLATE is given, it is found via TEMPLATE.
6. If no :PACKAGES are given, they are found via PACKAGES.
7. If no :SUBSYSTEMS are given, they are found via SUBSYSTEMS.
8. If no output directory is known, a recoverable error of type NO-KNOWN-OUTPUT-DIRECTORY is signalled. You may use the USE-VALUE restart to provide a new output directory.
9. Each entry in the subsystems list may either be an ASDF system, or a list of an ASDF system and the same keyword arguments as above. The properties are inferred as follows:
9.1 If no :OUTPUT-DIRECTORY is given, a subdirectory by the name of the subsystem within the primary system’s output directory is used. 9.2 If no :DOCUMENTS are given, they are found via DOCUMENTS.
9.3 If no :IMAGES are given, they are found via IMAGES, or the primary system’s images are used.
9.4 If no :PAGE-TYPE is given, it is found via PAGE-TYPE, or the primary system’s page-type is used.
9.5 If no :TEMPLATE is given, it is found via TEMPLATE, or the primary system’s template is used.
9.6 If no :PACKAGES are given, they are found via PACKAGES.
9.7 If the subsystem’s source directory is the same as the primary system’s, and the list of documents are the same, the subsystem’s document list is emptied to avoid the subsystem using documents intended for the primary system.
9.8 All documents for the subsystem are removed from the documents list for the primary system.
9.9 For each document for the subsystem, a page of page-type is constructed, passing the template as :INPUT, the output directory as :OUTPUT, the system as :SYSTEM, the document as :DOCUMENT, the list of images as :IMAGES, and the list of packages as :PACKAGES. 9.10. If the documents list is empty, a single page of page-type is constructed with the same arguments as before, except the :DOCUMENT being NIL.
9.11. For each pathname in the images list a page of type STATIC-PAGE is constructed that will copy the image file into the OUTPUT-DIRECTORY while preserving pathname name and type.
10. For each pathname in the documents list a page of page-type is constructed, passing the template as :INPUT, the output directory as :OUTPUT, the system as :SYSTEM, the document’s pathname as :DOCUMENT, the list of images as :IMAGES, and the list of packages as :PACKAGES.
11. If the documents list is empty, a single page of page-type is constructed with the same arguments as before, except the :DOCUMENT being NIL.
12. For each pathname in the images list a page of type STATIC-PAGE is constructed that will copy the image file into the OUTPUT-DIRECTORY while preserving pathname name and type.
13. A SIMPLE-PROJECT instance is constructed and returned with those pages as the :PAGES argument.

See OUTPUT-DIRECTORY
See DOCUMENTS
See IMAGES
See PACKAGES
See PAGE-TYPE
See TEMPLATE
See SUBSYSTEMS
See *DEFAULT-TEMPLATE*
See NO-KNOWN-OUTPUT-DIRECTORY
See CL:USE-VALUE
See STATIC-PAGE
See SIMPLE-PROJECT

Package

staple.

Source

project.lisp.

Methods
Method: infer-project ((system system) &key output-directory images documents page-type template packages subsystems)
Source

inference.lisp.

Method: infer-project (name &rest args)
Generic Reader: input (object)

Accessor to the input of the page.

The input should be a STREAM-DESIGNATOR, meaning that it can be resolved to a stream via ENSURE-STREAM. Typically it will be a pathname pointing to the file from which the page’s input should be ready.

See INPUT-PAGE

Package

staple.

Methods
Reader Method: input ((input-page input-page))

automatically generated reader method

Source

page.lisp.

Target Slot

input.

Generic Writer: (setf input) (object)
Package

staple.

Methods
Writer Method: (setf input) ((input-page input-page))

automatically generated writer method

Source

page.lisp.

Target Slot

input.

Generic Reader: language (object)

Accessor to the language of a page.

The language should be a two or three-letter short-code that uniquely identifies the language as a keyword. See the ISO-639 language codes for all available options.

See PAGE

Package

staple.

Methods
Reader Method: language ((page page))

automatically generated reader method

Source

page.lisp.

Target Slot

language.

Generic Writer: (setf language) (object)
Package

staple.

Methods
Writer Method: (setf language) ((page page))

automatically generated writer method

Source

page.lisp.

Target Slot

language.

Generic Function: lookup (name namespace environment)

Looks up the name in the namespace of the environment.

This will traverse the environment chain upwards until no parent can be found anymore in case the current environment’s namespace does not contain the value.

When used as a setf place the value is always stored in the given environment’s namespace.

See NAMESPACE
See ENVIRONMENT

Package

staple-code-parser.

Methods
Method: lookup (name namespace (environment environment))
Source

environment.lisp.

Generic Function: (setf lookup) (name namespace environment)
Package

staple-code-parser.

Methods
Method: (setf lookup) (name namespace (environment environment))
Source

environment.lisp.

Generic Reader: output (object)

Accessor to the output of a page.

The output should be a STREAM-DESIGNATOR, meaning that it can be resolved to a stream via ENSURE-STREAM. Typically it will be a pathname pointing to the file into which the page’s contents should be stored.

See PAGE

Package

staple.

Methods
Reader Method: output ((project project))

automatically generated reader method

Source

project.lisp.

Target Slot

output.

Reader Method: output ((page page))

automatically generated reader method

Source

page.lisp.

Target Slot

output.

Generic Writer: (setf output) (object)
Package

staple.

Methods
Writer Method: (setf output) ((project project))

automatically generated writer method

Source

project.lisp.

Target Slot

output.

Writer Method: (setf output) ((page page))

automatically generated writer method

Source

page.lisp.

Target Slot

output.

Generic Function: output-directory (system)

Returns the output directory to which documentation for the given system should be output.

By default this returns the "doc/" subdirectory within the system’s
source directory.

You may add a method specialising on a particular system to change
where the resulting content is stored for an inferred project.

See ASDF:SYSTEM-SOURCE-DIRECTORY
See INFER-PROJECT

Package

staple.

Methods
Method: output-directory ((system system))
Source

inference.lisp.

Generic Function: package-system (package)

Returns the system associated with the package.

This is typically the system that defines the package, if the package was recorded through Staple’s package recording mechanism. If this automated detection is not smart enough, you may supply methods on this function to specify the correct system for a package.

See CL:PACKAGE

Package

staple-package-recording.

Methods
Method: package-system (thing)
Source

recording.lisp.

Method: package-system ((package package))
Source

recording.lisp.

Generic Function: packages (system)

Accessor to the list of packages associated with the instance.

This will always return a list of PACKAGE instances, not package designators. If passed an ASDF:SYSTEM instance, it will return the list of packages that were either recorded explicitly for the system during loading, or were either inferred or explicitly set for the system. If passed a DEFINITIONS-INDEX-PAGE instance, it will return the list of packages that should be put into the index. For anything else it will try to coerce the argument to an ASDF:SYSTEM via ASDF:FIND-SYSTEM.

See ASDF:SYSTEM
See DEFINITIONS-INDEX-PAGE

Package

staple-package-recording.

Methods
Reader Method: packages ((definitions-index-page definitions-index-page))

automatically generated reader method

Source

page.lisp.

Target Slot

packages.

Method: packages ((system symbol))
Source

recording.lisp.

Method: packages ((system system))
Source

recording.lisp.

Generic Function: (setf packages) (system)
Package

staple-package-recording.

Methods
Writer Method: (setf packages) :around ((page definitions-index-page))
Source

page.lisp.

Target Slot

packages.

Method: (setf packages) ((definitions-index-page definitions-index-page))

automatically generated writer method

Source

page.lisp.

Method: (setf packages) (system-ish)
Source

recording.lisp.

Method: (setf packages) ((system system))
Source

recording.lisp.

Generic Function: page-siblings (page)
Package

staple.

Source

page.lisp.

Methods
Method: page-siblings ((page page))
Generic Function: page-type (system)

Returns the type of the page that should be used for the given system’s inferred project.

By default this returns ’SIMPLE-PAGE

You may add a method specialising on a particular system to change
which page-type is used for an inferred project.

See SIMPLE-PAGE
See INFER-PROJECT

Package

staple.

Methods
Method: page-type ((system system))
Source

inference.lisp.

Generic Function: page-variants (page)
Package

staple.

Source

page.lisp.

Methods
Method: page-variants ((page page))
Generic Reader: pages (project)

Returns the list of pages that the project generates.

See PAGE
See PROJECT

Package

staple.

Source

project.lisp.

Methods
Reader Method: pages ((simple-project simple-project))

automatically generated reader method

Target Slot

pages.

Generic Writer: (setf pages) (object)
Package

staple.

Methods
Writer Method: (setf pages) ((simple-project simple-project))

automatically generated writer method

Source

project.lisp.

Target Slot

pages.

Generic Function: parse (input)

Parses the input and returns a list of parse results, each for one toplevel.

First uses READ-TOPLEVEL to read all toplevel forms, then uses WALK
for each of the read CSTs to turn them into parse results.

See READ-TOPLEVEL
See WALK

Package

staple-code-parser.

Methods
Method: parse (input)
Source

walker.lisp.

Generic Reader: placeholder-intern (object)

Returns whether the symbol being read is an internal or external symbol.

See PLACEHOLDER

Package

staple-code-parser.

Methods
Reader Method: placeholder-intern ((placeholder placeholder))

automatically generated reader method

Source

walker.lisp.

Target Slot

intern.

Generic Reader: placeholder-name (object)

Returns the symbol-name of the symbol this is a placeholder for.

See PLACEHOLDER

Package

staple-code-parser.

Methods
Reader Method: placeholder-name ((placeholder placeholder))

automatically generated reader method

Source

walker.lisp.

Target Slot

name.

Generic Reader: placeholder-package (object)

Returns the symbol-package name of the symbol this is a placeholder for.

See PLACEHOLDER

Package

staple-code-parser.

Methods
Reader Method: placeholder-package ((placeholder placeholder))

automatically generated reader method

Source

walker.lisp.

Target Slot

package.

Generic Reader: project (object)

Accessor to the page’s project.

See PAGE

Package

staple.

Methods
Reader Method: project ((page page))

automatically generated reader method

Source

page.lisp.

Target Slot

project.

Generic Writer: (setf project) (object)
Package

staple.

Methods
Writer Method: (setf project) ((page page))

automatically generated writer method

Source

page.lisp.

Target Slot

project.

Generic Function: read-toplevel (input)

Reads the toplevel of an input.

The INPUT may be a string, pathname, or a stream (by default). Returns a list of CSTs representing all toplevel forms that were read.

Package

staple-code-parser.

Methods
Method: read-toplevel ((input stream))
Source

walker.lisp.

Method: read-toplevel ((input pathname))
Source

walker.lisp.

Method: read-toplevel ((input string))
Source

walker.lisp.

Generic Function: relative-path (to from)

Return the relative path from the second argument to the first.

By default the following cases are handled:

To: From: Explanation: ——————————————————————– PATHNAME PATHNAME — Computes the relative pathname.
PAGE T — Delegates using OUTPUT.
T PAGE — Delegates using OUTPUT.
PROJECT T — Delegates using OUTPUT.
T PROJECT — Delegates using OUTPUT.
PAGE (EQL T) — Delegates using PROJECT.

See PATHNAME-UTILS:RELATIVE-PATH
See OUTPUT
See PROJECT
See PAGE

Package

staple.

Source

toolkit.lisp.

Methods
Method: relative-path (to (from project))
Source

project.lisp.

Method: relative-path ((to project) from)
Source

project.lisp.

Method: relative-path (to (from page))
Source

page.lisp.

Method: relative-path ((to page) from)
Source

page.lisp.

Method: relative-path ((to page) (project (eql t)))
Source

page.lisp.

Method: relative-path ((to pathname) (from pathname))

Resolve the link to a source file to a URI.

The source should be either a definition or a source spec. In case of a definition, the function is called again with the source spec as computed by ABSOLUTE-SOURCE-LOCATION on DEFINITIONS:SOURCE-LOCATION. A source spec should be a plist of the following possible keys:

:FILE — An absolute pathname to the source file. Required. :ROW — An optional row/line to which to point within the file. :COL — An optional col/char to which to point within the line.

By default this will try a "best effort" resolution, meaning relative links if the file’s path is a subpath of the page’s output. Otherwise it will fall back to a "file://" link.

See DEFINITIONS:SOURCE-LOCATION
See ABSOLUTE-SOURCE-LOCATION

Package

staple.

Source

page.lisp.

Methods
Generic Function: sub-results (type args)

Returns all parse results that are sub-results of this parse result.

All parse results have the structure of (TYPE SOURCE . ARGS). Thus you can simply destructure it and pass the arguments to this function to retrieve its definitions.

See DEFINE-SUB-RESULTS

Package

staple-code-parser.

Methods
Method: sub-results ((type1 (eql :call)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql :macro)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql unwind-protect)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql throw)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql the)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql tagbody)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql symbol-macrolet)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql setq)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql return-from)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql progv)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql progn)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql multiple-value-prog1)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql multiple-value-call)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql macrolet)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql locally)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql load-time-value)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql let*)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql let)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql labels)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql if)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql go)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql sb-int:named-lambda)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql lambda)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql flet)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql eval-when)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql catch)) args0)
Source

to-definitions.lisp.

Method: sub-results ((type1 (eql block)) args0)
Source

to-definitions.lisp.

Method: sub-results (type args)
Source

to-definitions.lisp.

Generic Function: subsystems (system)

Returns a list of systems that are related to the given system.

By default this will find all ASDF systems whose name contains the given system’s name as a prefix.

You may add a method specialising on a particular system to change which subsystems are used for an inferred project.

See INFER-PROJECT

Package

staple.

Methods
Method: subsystems ((system system))
Source

inference.lisp.

Generic Reader: system (object)

Accessor to the system the object is associated with.

See SYSTEM-PAGE
See NO-KNOWN-OUTPUT-DIRECTORY

Package

staple.

Methods
Reader Method: system ((condition no-known-output-directory))
Source

inference.lisp.

Target Slot

system.

Reader Method: system ((system-page system-page))

automatically generated reader method

Source

page.lisp.

Target Slot

system.

Generic Function: (setf system) (object)
Package

staple.

Methods
Writer Method: (setf system) :around ((page system-page))
Source

page.lisp.

Target Slot

system.

Method: (setf system) ((system-page system-page))

automatically generated writer method

Source

page.lisp.

Generic Function: template (system)

Returns the pathname to a Clip template suitable for the given system.

You may add a method specialising on a particular system to change which template is used for an inferred project.

See INFER-PROJECT

Package

staple.

Methods
Method: template ((system system))
Source

inference.lisp.

Generic Function: template-data (page)

Returns the arguments to CLIP:PROCESS that should be used for the page.

This should be a plistt containing the necessary data to compile the template. Note that this generic function uses the APPEND method- combination, meaning that you may add new keys by simply adding a new method to this function. The method combination uses :MOST-SPECIFIC-FIRST, and since plists short-circuit, you may also use a method to override keys that less-specific methods may have set.

See TEMPLATED-PAGE

Package

staple.

Source

page.lisp.

Method Combination

append.

Options

:most-specific-first

Methods
Method: template-data append ((page simple-page))
Source

inference.lisp.

Method: template-data append ((page system-page))
Method: template-data append ((page definitions-index-page))
Method: template-data append ((page templated-page))
Generic Reader: title (object)

Accessor to the title of a page.

The title should be a very short, unique identifier for the page within the project. Pages that represent the same content but in different languages should have the same titles. The title of a page may be used as the name for a link to that page.

See PAGE

Package

staple.

Methods
Reader Method: title ((page page))

automatically generated reader method

Source

page.lisp.

Target Slot

title.

Generic Writer: (setf title) (object)
Package

staple.

Methods
Writer Method: (setf title) ((page page))

automatically generated writer method

Source

page.lisp.

Target Slot

title.

Generic Function: walk (cst environment)

Walks the given CST in the environment.

Should return a parse result structure.
Parse results are lists of the following form:

PARSE-RESULT ::= (TYPE SOURCE . ARGS)
TYPE — The type of the form we’ve walked. Typically this is a symbol of the form itself, like LAMBDA, or a keyword if a generic variant is encountered like for :CALLs and :MACROs.
SOURCE ::= (START . END)
ARGS — Additional arguments for the parse result, including additional parse-results.

Generally see the overall concrete-syntax-tree system for explanations on how to use this.

Note that you probably want to define a method on WALK-FORM instead, as that is called automatically as appropriate for each CST:CONST-CST, and WALK-ATOM is called for each CST:ATOM-CST.

See ENVIRONMENT

Package

staple-code-parser.

Methods
Method: walk ((cst cons-cst) environment)
Source

walker.lisp.

Method: walk ((cst atom-cst) environment)
Source

walker.lisp.

Method: walk ((cst specialized-required-parameter) environment)
Source

walker.lisp.

Method: walk ((cst ordinary-key-parameter) environment)
Source

walker.lisp.

Method: walk ((cst ordinary-optional-parameter) environment)
Source

walker.lisp.

Method: walk ((cst simple-variable) environment)
Source

walker.lisp.

Method: walk ((cst specialized-lambda-list) environment)
Source

walker.lisp.

Method: walk ((cst macro-lambda-list) environment)
Source

walker.lisp.

Method: walk ((cst ordinary-lambda-list) environment)
Source

walker.lisp.

Generic Function: walk-atom (atom environment)

Walks an atom.

If the atom is a symbol, it returns a parse result of a literal for keywords and booleans, or a variable for symbols. For everything else it returns a parse result for a literal.

Package

staple-code-parser.

Methods
Method: walk-atom (atom environment)
Source

walker.lisp.

Method: walk-atom ((atom symbol) environment)
Source

walker.lisp.

Generic Function: walk-form (operator-var2 cst environment)

Walks a form.

The form is identified by the car of the cons. The entirety of the form as a CST, including the operator, are passed along as well.

Package

staple-code-parser.

Methods
Method: walk-form ((operator-var14 (eql apply)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var8 (eql funcall)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var0 (eql loop)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var0 (eql setf)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var0 (eql defmethod)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var0 (eql defclass)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var0 (eql make-instance)) (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form (operator-var0 (cst cons-cst) environment)
Source

standard-forms.lisp.

Method: walk-form ((operator-var3 (eql unwind-protect)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql throw)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql the)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql tagbody)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql symbol-macrolet)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql setq)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql return-from)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var1 (eql quote)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql progv)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var1 (eql progn)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql multiple-value-prog1)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql multiple-value-call)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql macrolet)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql locally)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql load-time-value)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql let*)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql let)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql labels)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql if)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql go)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql sb-int:named-lambda)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var0 (eql lambda)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var0 (eql function)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql flet)) (cst cons-cst) environment)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql eval-when)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var3 (eql catch)) (cst cons-cst) environment0)
Source

special-forms.lisp.

Method: walk-form ((operator-var2 (eql block)) (cst cons-cst) environment)
Source

special-forms.lisp.

Generic Function: xref (thing &optional type)

Attempts to find a cross-reference URL for the given thing.

The following default cases are handled:

DEFINITIONS:DEFINITION — RESOLVE-XREF is called directly. STRING — The string is parsed by PARSE-SYMBOL, and if it represents a valid symbol, matching definitions are attempted to be found via FIND-DEFINITIONS-FOR-IDENTIFIER. The definitions are ranked according to PREFERRED-DEFINITION, and the first one cross-reference via RESOLVE-XREF that can be found is returned.

The optional TYPE argument constrains the cross references to be of the given type of definition.

See RESOLVE-XREF
See PARSE-SYMBOL
See FIND-DEFINITIONS-FOR-IDENTIFIER
See PREFERRED-DEFINITION

Package

staple.

Source

xref.lisp.

Methods
Method: xref ((identifier string) &optional type)
Method: xref ((definition definition) &optional type)

5.1.5 Standalone methods

Method: evaluate-expression ((client client) expression)
Package

eclector.reader.

Source

walker.lisp.

Method: initialize-instance :after ((page page) &key output language)
Source

page.lisp.

Method: initialize-instance :after ((page simple-page) &key document output language)
Source

inference.lisp.

Method: interpret-symbol ((client client) in package symbol intern)
Package

eclector.reader.

Source

walker.lisp.

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

walker.lisp.

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

page.lisp.

Method: shared-initialize :after ((page definitions-index-page) slots &key packages)
Source

page.lisp.

Method: shared-initialize :after ((page system-page) slots &key system title)
Source

page.lisp.


5.1.6 Conditions

Condition: no-known-output-directory

Error signalled when no known output directory is available for a system.

See SYSTEM
See INFER-PROJECT

Package

staple.

Source

inference.lisp.

Direct superclasses

error.

Direct methods

system.

Direct slots
Slot: system
Initargs

:system

Readers

system.

Writers

This slot is read-only.


5.1.7 Classes

Class: compiled-page

A compiled page that is created by translating some input file.

In order to handle the translation, COMPILE-SOURCE is used.
The output of COMPILE-SOURCE may be a PLUMP:NODE, a STRING, or an (unsigned-byte 8) vector. In the case of a PLUMP:NODE, the node is first compressed using COMPACT if the :COMPACT argument to GENERATE is non-NIL (default).

See INPUT-PAGE
See COMPILE-SOURCE

Package

staple.

Source

page.lisp.

Direct superclasses

input-page.

Direct methods

generate.

Class: definitions-index-page

Superclass for pages that include a definitions index.

See PACKAGES
See FORMAT-DOCUMENTATION
See RESOLVE-SOURCE-LINK
See DEFINITION-WANTED-P
See DEFINITIONS

Package

staple.

Source

page.lisp.

Direct superclasses

templated-page.

Direct subclasses

system-page.

Direct methods
Direct slots
Slot: packages
Package

staple-package-recording.

Readers

packages.

Writers

(setf packages).

Class: environment

Container for environment information used during walking.

See PARENT
See NAMESPACES
See LOOKUP
See AUGMENT-ENVIRONMENT!
See AUGMENTED-ENVIRONMENT

Package

staple-code-parser.

Source

environment.lisp.

Direct methods
Direct slots
Slot: parent
Initargs

:parent

Readers

parent.

Writers

This slot is read-only.

Slot: namespaces
Initform

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

Readers

namespaces.

Writers

This slot is read-only.

Class: input-page

Superclass for pages that are generated using some kind of input.

See PAGE
See INPUT

Package

staple.

Source

page.lisp.

Direct superclasses

page.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:inputnil
Direct slots
Slot: input
Initargs

:input

Readers

input.

Writers

(setf input).

Class: page

Base class for all pages that can be generated as part of a project.

A page represents a single, well, page within the documentation for a particular project. It should only produce a single output, which is typically a file. A page should, if possible, only contain text in a single language. This primary language is indicated by the page’s LANGUAGE slot and defaults to "en" for English.

If the output is a pathname, the behaviour on existing output may be specified through the :IF-EXISTS argument to GENERATE, by default set to :ERROR.

See PROJECT
See TITLE
See LANGUAGE
See OUTPUT
See GENERATE

Package

staple.

Source

page.lisp.

Direct subclasses

input-page.

Direct methods
Direct Default Initargs
InitargValue
:outputnil
:titlenil
:project(error project required.)
Direct slots
Slot: title
Initargs

:title

Readers

title.

Writers

(setf title).

Slot: language
Initform

:en

Initargs

:language

Readers

language.

Writers

(setf language).

Slot: output
Initargs

:output

Readers

output.

Writers

(setf output).

Slot: project
Initargs

:project

Readers

project.

Writers

(setf project).

Class: placeholder

This class represents symbols that are not present in the host.

They are emitted in parsed code snippets in place of symbols that cannot be read properly.

See PLACEHOLDER-NAME
See PLACEHOLDER-PACKAGE
See PLACEHOLDER-INTERN

Package

staple-code-parser.

Source

walker.lisp.

Direct methods
Direct Default Initargs
InitargValue
:name(error name required)
:packagenil
:internnil
Direct slots
Slot: name
Initargs

:name

Readers

placeholder-name.

Writers

This slot is read-only.

Slot: package
Package

common-lisp.

Initargs

:package

Readers

placeholder-package.

Writers

This slot is read-only.

Slot: intern
Package

common-lisp.

Initargs

:intern

Readers

placeholder-intern.

Writers

This slot is read-only.

Class: project

Superclass for a documentation project.

A project encapsulates all documentation for a library or program. Typically this is expressed by a number of PAGEs that will create the expected documentation files when the project is GENERATEd.

The OUTPUT of a project represents the root directory of all output data. It is used to figure out relative paths between pages and resources.

See OUTPUT
See PAGE
See PAGES
See GENERATE

Package

staple.

Source

project.lisp.

Direct subclasses

simple-project.

Direct methods
Direct slots
Slot: output
Initargs

:output

Readers

output.

Writers

(setf output).

Class: simple-page

A simple page to base documentation on.

Simple-pages are the preferred pages to use for inferred systems. They provide a convenient all-in-one package for a definitions index and a documentation body.

A single "document" makes up the main body of the page and should provide the primary documentation of the system or project. The document is transformed by COMPILE-SOURCE, which by default will automatically parse it from file and mark up code snippets within it.

If the OUTPUT pathname passed as initarg to this class is missing the name and type, then the pathname is augmented using FILENAME of the page.

See *DEFAULT-TEMPLATE*
See DOCUMENT
See IMAGES
See FILENAME
See SYSTEM-PAGE
See COMPILE-SOURCE

Package

staple.

Source

inference.lisp.

Direct superclasses

system-page.

Direct methods
Direct Default Initargs
InitargValue
:documentnil
:imagesnil
:document-packagenil
:input*default-template*
Direct slots
Slot: document-package
Initargs

:document-package

Readers

document-package.

Writers

(setf document-package).

Slot: document
Initargs

:document

Readers

document.

Writers

(setf document).

Slot: images
Initargs

:images

Readers

images.

Writers

(setf images).

Class: simple-project

A simple project.

This class simply stores a list of page instances and generates them when GENERATE is called on the project instance.

See PROJECT
See PAGES

Package

staple.

Source

project.lisp.

Direct superclasses

project.

Direct methods
Direct Default Initargs
InitargValue
:pagesnil
Direct slots
Slot: pages
Initargs

:pages

Readers

pages.

Writers

(setf pages).

Class: static-page

A static page that simply copies its input to its output.

This is useful for static files such as images and other resources.

See INPUT-PAGE

Package

staple.

Source

page.lisp.

Direct superclasses

input-page.

Direct methods

generate.

Class: system-page

Superclass for pages that represent and ASDF system.

This system will compute several properties automatically by using the ASDF metadata: if the :PACKAGES are not given, they are computed from calling PACKAGES on the system object. When a source link is resolved
and the project’s homepage resides on GitHub or GitLab, it will try to guess a link to the GitHub/GitLab repository’s viewer of the source file.

See SYSTEM
See DEFINITIONS-INDEX-PAGE

Package

staple.

Source

page.lisp.

Direct superclasses

definitions-index-page.

Direct subclasses

simple-page.

Direct methods
Direct slots
Slot: system
Initargs

nil

Readers

system.

Writers

(setf system).

Class: templated-page

Superclass for pages that are templated using Clip.

The template that Clip is run on is the INPUT of the page. The template arguments are computed using the TEMPLATE-DATA generic function.

The output of the page is compressed using COMPACT if the :COMPACT argument to GENERATE is non-NIL (default).

See INPUT-PAGE
See TEMPLATE-DATA

Package

staple.

Source

page.lisp.

Direct superclasses

input-page.

Direct subclasses

definitions-index-page.

Direct methods

5.1.8 Types

Type: stream-designator ()

A type representing all possible values to be used with ENSURE-STREAM.

See ENSURE-STREAM

Package

staple.

Source

toolkit.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *before-load-packages*
Package

staple-package-recording.

Source

recording.lisp.

Special Variable: *current-commit-cache*
Package

staple.

Source

page.lisp.

Special Variable: *loaded-extensions*
Package

staple.

Source

project.lisp.

Special Variable: *pathname-type-type-map*
Package

staple.

Source

transform.lisp.

Special Variable: *system-packages*
Package

staple-package-recording.

Source

recording.lisp.

Special Variable: *xref-resolvers*
Package

staple.

Source

xref.lisp.


5.2.2 Macros

Macro: case* (test value &body clauses)

Like CL:CASE, but takes a test function.

TEST must be a function designator or a lambda expression.

See CL:CASE

Package

staple.

Source

toolkit.lisp.

Macro: do-directory-tree ((file directory &optional result &rest args) &body body)

Executes body for each file in the directory tree.

Evaluates RESULT last and returns its value.

See MAP-DIRECTORY-TREE

Package

staple.

Source

toolkit.lisp.

Macro: with-value-restart (place &body body)

Ensures PLACE has a valid value.

This establishes a STORE-VALUE restart around BODY. If the restart is called, the PLACE is set to the value the restart was called with and the BODY is executed again.

Typically the BODY will be some kind of check to ensure the validity of the value stored in PLACE. In combination with this macro, that will ensure that the code only ever continues with a valid value in PLACE.

Package

staple.

Source

toolkit.lisp.


5.2.3 Ordinary functions

Function: compact (node)

Compacts the given PLUMP:NODE by removing extraneous whitespace.

This will take care not to trim whitespace from <pre> tags, but will replace any duplicate whitespace with a single space anywhere else. Note that this will leave a single space between nodes, as it cannot determine whether the effects of the whitespace in that case are intended or not.

Package

staple.

Source

toolkit.lisp.

Function: efind-package (name)
Package

staple-package-recording.

Source

recording.lisp.

Function: ensure-namespace (namespace environment)

Makes sure the namespace of the given name exists in the environment.

See ENVIRONMENT
See NAMESPACES

Package

staple-code-parser.

Source

environment.lisp.

Function: ensure-stream (designator &key direction if-exists element-type)

Attempts to coerce the given designator to a stream object.

The following are handled:

STREAM — The designator is returned verbatim. STRING/PATHNAME — OPEN is called on the designator using the given keyword arguments as appropriate. NULL — A string-output-stream is returned.
T — *STANDARD-OUTPUT* is returned.

See WITH-STREAM
See STREAM-DESIGNATOR

Package

staple.

Source

toolkit.lisp.

Function: ensure-system (system-ish)

Ensures to return an ASDF:SYSTEM.

If the argument is not already an ASDF:SYSTEM, it is passed to ASDF:FIND-SYSTEM, and errors if no system can be found.

See ASDF:SYSTEM
See ASDF:FIND-SYSTEM

Package

staple.

Source

toolkit.lisp.

Function: extract-author-email (author)
Package

staple.

Source

toolkit.lisp.

Function: extract-author-name (author)
Package

staple.

Source

toolkit.lisp.

Function: github-project-root (github-url)
Package

staple.

Source

page.lisp.

Function: gitlab-project-root (gitlab-url)
Package

staple.

Source

page.lisp.

Function: make-extension-load-table ()
Package

staple.

Source

project.lisp.

Package

staple.

Source

code-format.lisp.

Function: map-directory-tree (function directory &key max-depth exclude)

Calls the given function for all files in the directory tree.

If MAX-DEPTH is given, it denotes the maximum number of directories into which it recurses. Specifically, if MAX-DEPTH is 0, only the files in the given directory are mapped to the function. Otherwise each directory is visited recursively with MAX-DEPTH reduced by one.

Package

staple.

Source

toolkit.lisp.

Function: maybe-unquote (thing)
Package

staple-code-parser.

Source

standard-forms.lisp.

Function: merge-plists (plist default)
Package

staple.

Source

toolkit.lisp.

Function: namespace (namespace environment)

Accesses the namespace of the given name from the environment.

See NAMESPACES
See ENVIRONMENT
See LOOKUP

Package

staple-code-parser.

Source

environment.lisp.

Function: parse-lisp-token (string)

Parses a lisp symbol token, meaning it will read from string by properly interpreting backslashes and vertical bar escapes.

Package

staple.

Source

xref.lisp.

Function: parse-symbol (identifier)

Parses a symbol from the given string identifier.

Explicit packages, keywords, and package-less symbols are handled.

Returns two values, the symbol’s name and its package as strings. If the symbol is a gensym, the returned package name is :GENSYM, rather than an actual package name string.

Package

staple.

Source

xref.lisp.

Function: perform-and-record-macro-expansion (expander cst)
Package

staple-code-parser.

Source

standard-forms.lisp.

Function: prefix-p (prefix string)

Returns T if PREFIX is a whole prefix of STRING.

Package

staple.

Source

toolkit.lisp.

Function: read-value ()

Reads a value from *query-io*.

To be used with interactive restarts.

Package

staple.

Source

toolkit.lisp.

Function: skip-to-source-form (stream)

Continues reading from the stream until a valid lisp source form is encountered.

This skips both whitespace and comments.

Package

staple.

Source

toolkit.lisp.

Function: split (split string)

Splits the given string by the given splitting character.

Returns the list of non-empty substrings. The split strings are not shared with the original string.

Package

staple.

Source

toolkit.lisp.

Function: stream-value (stream)
Package

staple.

Source

toolkit.lisp.

Function: system-field (field system)
Package

staple.

Source

toolkit.lisp.

Function: titleize (thing)

Attempts to turn the given string into one more suitable as a title.

Package

staple.

Source

toolkit.lisp.

Function: unlist (listish)
Package

staple.

Source

toolkit.lisp.


5.2.4 Generic functions

Generic Reader: namespaces (object)

Returns the hash-table of namespaces in the environment.

See ENVIRONMENT
See NAMESPACE

Package

staple-code-parser.

Methods
Reader Method: namespaces ((environment environment))

automatically generated reader method

Source

environment.lisp.

Target Slot

namespaces.

Generic Reader: parent (object)

Returns the parent of the environment, if any.

See ENVIRONMENT

Package

staple-code-parser.

Methods
Reader Method: parent ((environment environment))

automatically generated reader method

Source

environment.lisp.

Target Slot

parent.

Generic Function: system-name (system)

Returns a canonical keyword for the name of the ASDF:SYSTEM.

Package

staple.

Methods
Method: system-name (name)
Source

toolkit.lisp.

Method: system-name ((system system))
Source

toolkit.lisp.


5.2.5 Classes

Class: client

Our subclass of the eclector cst-client.

Uses the host lisp’s EVAL.

See ECLECTOR.CONCRETE-SYNTAX-TREE::CST-CLIENT

Package

staple-code-parser.

Source

walker.lisp.

Direct superclasses

cst-client.

Direct methods

Appendix A Indexes


A.1 Concepts


A.2 Functions

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

(
(setf document): Public generic functions
(setf document): Public generic functions
(setf document-package): Public generic functions
(setf document-package): Public generic functions
(setf images): Public generic functions
(setf images): Public generic functions
(setf input): Public generic functions
(setf input): Public generic functions
(setf language): Public generic functions
(setf language): Public generic functions
(setf lookup): Public generic functions
(setf lookup): Public generic functions
(setf output): Public generic functions
(setf output): Public generic functions
(setf output): Public generic functions
(setf packages): Public generic functions
(setf packages): Public generic functions
(setf packages): Public generic functions
(setf packages): Public generic functions
(setf packages): Public generic functions
(setf pages): Public generic functions
(setf pages): Public generic functions
(setf pathname-type->type): Public ordinary functions
(setf project): Public generic functions
(setf project): Public generic functions
(setf system): Public generic functions
(setf system): Public generic functions
(setf system): Public generic functions
(setf title): Public generic functions
(setf title): Public generic functions
(setf xref-resolver): Public ordinary functions

A
absolute-source-location: Public ordinary functions
augment-environment!: Public ordinary functions
augmented-environment: Public ordinary functions

C
case*: Private macros
compact: Private ordinary functions
compile-source: Public generic functions
compile-source: Public generic functions
compile-source: Public generic functions
compile-source: Public generic functions
compile-source: Public generic functions
compile-source: Public generic functions
compile-source: Public generic functions
current-commit: Public generic functions
current-commit: Public generic functions

D
define-definition-resolver: Public macros
define-source-compiler: Public macros
define-sub-results: Public macros
define-walk-compound-form: Public macros
define-walker-form: Public macros
define-xref-resolver: Public macros
definition-id: Public generic functions
definition-id: Public generic functions
definition-id: Public generic functions
definition-importance: Public generic functions
definition-importance: Public generic functions
definition-importance: Public generic functions
definition-importance: Public generic functions
definition-importance: Public generic functions
definition-importance: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-order: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definition-wanted-p: Public generic functions
definitions: Public generic functions
definitions: Public generic functions
definitions: Public generic functions
do-directory-tree: Private macros
document: Public generic functions
document: Public generic functions
document-package: Public generic functions
document-package: Public generic functions
documents: Public generic functions
documents: Public generic functions

E
efind-package: Private ordinary functions
ensure-namespace: Private ordinary functions
ensure-package: Public ordinary functions
ensure-package-definition: Public ordinary functions
ensure-stream: Private ordinary functions
ensure-system: Private ordinary functions
evaluate-expression: Public standalone methods
extension-file: Public generic functions
extension-file: Public generic functions
extract-author-email: Private ordinary functions
extract-author-name: Private ordinary functions
extract-language: Public ordinary functions

F
filename: Public generic functions
filename: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions: Public generic functions
find-definitions-for-identifier: Public ordinary functions
find-files: Public ordinary functions
find-project: Public generic functions
find-project: Public generic functions
find-project: Public generic functions
format-documentation: Public generic functions
format-documentation: Public generic functions
format-documentation: Public generic functions
format-documentation: Public generic functions
Function, (setf pathname-type->type): Public ordinary functions
Function, (setf xref-resolver): Public ordinary functions
Function, absolute-source-location: Public ordinary functions
Function, augment-environment!: Public ordinary functions
Function, augmented-environment: Public ordinary functions
Function, compact: Private ordinary functions
Function, efind-package: Private ordinary functions
Function, ensure-namespace: Private ordinary functions
Function, ensure-package: Public ordinary functions
Function, ensure-package-definition: Public ordinary functions
Function, ensure-stream: Private ordinary functions
Function, ensure-system: Private ordinary functions
Function, extract-author-email: Private ordinary functions
Function, extract-author-name: Private ordinary functions
Function, extract-language: Public ordinary functions
Function, find-definitions-for-identifier: Public ordinary functions
Function, find-files: Public ordinary functions
Function, github-project-root: Private ordinary functions
Function, gitlab-project-root: Private ordinary functions
Function, load-extension: Public ordinary functions
Function, load-system-quietly: Public ordinary functions
Function, make-extension-load-table: Private ordinary functions
Function, make-xref-link: Private ordinary functions
Function, map-directory-tree: Private ordinary functions
Function, markup-code-block: Public ordinary functions
Function, markup-code-reference: Public ordinary functions
Function, markup-code-snippets: Public ordinary functions
Function, markup-code-snippets-ignoring-errors: Public ordinary functions
Function, maybe-lang-docstring: Public ordinary functions
Function, maybe-unquote: Private ordinary functions
Function, merge-plists: Private ordinary functions
Function, namespace: Private ordinary functions
Function, parse-lisp-token: Private ordinary functions
Function, parse-result->definition-list: Public ordinary functions
Function, parse-symbol: Private ordinary functions
Function, pathname-type->type: Public ordinary functions
Function, perform-and-record-macro-expansion: Private ordinary functions
Function, preferred-definition: Public ordinary functions
Function, prefix-p: Private ordinary functions
Function, purify-arglist: Public ordinary functions
Function, read-file: Public ordinary functions
Function, read-value: Private ordinary functions
Function, remove-xref-resolver: Public ordinary functions
Function, resolve-xref: Public ordinary functions
Function, skip-to-source-form: Private ordinary functions
Function, sort-definitions: Public ordinary functions
Function, split: Private ordinary functions
Function, stream-value: Private ordinary functions
Function, system-field: Private ordinary functions
Function, tie-to-source: Public ordinary functions
Function, titleize: Private ordinary functions
Function, unlist: Private ordinary functions
Function, url-encode: Public ordinary functions
Function, walk-bindings: Public ordinary functions
Function, walk-body: Public ordinary functions
Function, walk-implicit-progn: Public ordinary functions
Function, walk-lambda-like: Public ordinary functions
Function, xref-resolver: Public ordinary functions

G
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
generate: Public generic functions
Generic Function, (setf document): Public generic functions
Generic Function, (setf document-package): Public generic functions
Generic Function, (setf images): Public generic functions
Generic Function, (setf input): Public generic functions
Generic Function, (setf language): Public generic functions
Generic Function, (setf lookup): Public generic functions
Generic Function, (setf output): Public generic functions
Generic Function, (setf packages): Public generic functions
Generic Function, (setf pages): Public generic functions
Generic Function, (setf project): Public generic functions
Generic Function, (setf system): Public generic functions
Generic Function, (setf title): Public generic functions
Generic Function, compile-source: Public generic functions
Generic Function, current-commit: Public generic functions
Generic Function, definition-id: Public generic functions
Generic Function, definition-importance: Public generic functions
Generic Function, definition-order: Public generic functions
Generic Function, definition-wanted-p: Public generic functions
Generic Function, definitions: Public generic functions
Generic Function, document: Public generic functions
Generic Function, document-package: Public generic functions
Generic Function, documents: Public generic functions
Generic Function, extension-file: Public generic functions
Generic Function, filename: Public generic functions
Generic Function, find-definitions: Public generic functions
Generic Function, find-project: Public generic functions
Generic Function, format-documentation: Public generic functions
Generic Function, generate: Public generic functions
Generic Function, images: Public generic functions
Generic Function, infer-project: Public generic functions
Generic Function, input: Public generic functions
Generic Function, language: Public generic functions
Generic Function, lookup: Public generic functions
Generic Function, namespaces: Private generic functions
Generic Function, output: Public generic functions
Generic Function, output-directory: Public generic functions
Generic Function, package-system: Public generic functions
Generic Function, packages: Public generic functions
Generic Function, page-siblings: Public generic functions
Generic Function, page-type: Public generic functions
Generic Function, page-variants: Public generic functions
Generic Function, pages: Public generic functions
Generic Function, parent: Private generic functions
Generic Function, parse: Public generic functions
Generic Function, placeholder-intern: Public generic functions
Generic Function, placeholder-name: Public generic functions
Generic Function, placeholder-package: Public generic functions
Generic Function, project: Public generic functions
Generic Function, read-toplevel: Public generic functions
Generic Function, relative-path: Public generic functions
Generic Function, resolve-source-link: Public generic functions
Generic Function, sub-results: Public generic functions
Generic Function, subsystems: Public generic functions
Generic Function, system: Public generic functions
Generic Function, system-name: Private generic functions
Generic Function, template: Public generic functions
Generic Function, template-data: Public generic functions
Generic Function, title: Public generic functions
Generic Function, walk: Public generic functions
Generic Function, walk-atom: Public generic functions
Generic Function, walk-form: Public generic functions
Generic Function, xref: Public generic functions
github-project-root: Private ordinary functions
gitlab-project-root: Private ordinary functions

I
images: Public generic functions
images: Public generic functions
images: Public generic functions
infer-project: Public generic functions
infer-project: Public generic functions
infer-project: Public generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
input: Public generic functions
input: Public generic functions
interpret-symbol: Public standalone methods

L
language: Public generic functions
language: Public generic functions
load-extension: Public ordinary functions
load-system-quietly: Public ordinary functions
lookup: Public generic functions
lookup: Public generic functions

M
Macro, case*: Private macros
Macro, define-definition-resolver: Public macros
Macro, define-source-compiler: Public macros
Macro, define-sub-results: Public macros
Macro, define-walk-compound-form: Public macros
Macro, define-walker-form: Public macros
Macro, define-xref-resolver: Public macros
Macro, do-directory-tree: Private macros
Macro, with-stream: Public macros
Macro, with-value-restart: Private macros
make-extension-load-table: Private ordinary functions
make-xref-link: Private ordinary functions
map-directory-tree: Private ordinary functions
markup-code-block: Public ordinary functions
markup-code-reference: Public ordinary functions
markup-code-snippets: Public ordinary functions
markup-code-snippets-ignoring-errors: Public ordinary functions
maybe-lang-docstring: Public ordinary functions
maybe-unquote: Private ordinary functions
merge-plists: Private ordinary functions
Method, (setf document): Public generic functions
Method, (setf document-package): Public generic functions
Method, (setf images): Public generic functions
Method, (setf input): Public generic functions
Method, (setf language): Public generic functions
Method, (setf lookup): Public generic functions
Method, (setf output): Public generic functions
Method, (setf output): Public generic functions
Method, (setf packages): Public generic functions
Method, (setf packages): Public generic functions
Method, (setf packages): Public generic functions
Method, (setf packages): Public generic functions
Method, (setf pages): Public generic functions
Method, (setf project): Public generic functions
Method, (setf system): Public generic functions
Method, (setf system): Public generic functions
Method, (setf title): Public generic functions
Method, compile-source: Public generic functions
Method, compile-source: Public generic functions
Method, compile-source: Public generic functions
Method, compile-source: Public generic functions
Method, compile-source: Public generic functions
Method, compile-source: Public generic functions
Method, current-commit: Public generic functions
Method, definition-id: Public generic functions
Method, definition-id: Public generic functions
Method, definition-importance: Public generic functions
Method, definition-importance: Public generic functions
Method, definition-importance: Public generic functions
Method, definition-importance: Public generic functions
Method, definition-importance: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-order: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definition-wanted-p: Public generic functions
Method, definitions: Public generic functions
Method, definitions: Public generic functions
Method, document: Public generic functions
Method, document-package: Public generic functions
Method, documents: Public generic functions
Method, evaluate-expression: Public standalone methods
Method, extension-file: Public generic functions
Method, filename: Public generic functions
Method, find-definitions: Public generic functions
Method, find-definitions: Public generic functions
Method, find-definitions: Public generic functions
Method, find-definitions: Public generic functions
Method, find-definitions: Public generic functions
Method, find-definitions: Public generic functions
Method, find-project: Public generic functions
Method, find-project: Public generic functions
Method, format-documentation: Public generic functions
Method, format-documentation: Public generic functions
Method, format-documentation: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, generate: Public generic functions
Method, images: Public generic functions
Method, images: Public generic functions
Method, infer-project: Public generic functions
Method, infer-project: Public generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, input: Public generic functions
Method, interpret-symbol: Public standalone methods
Method, language: Public generic functions
Method, lookup: Public generic functions
Method, namespaces: Private generic functions
Method, output: Public generic functions
Method, output: Public generic functions
Method, output-directory: Public generic functions
Method, package-system: Public generic functions
Method, package-system: Public generic functions
Method, packages: Public generic functions
Method, packages: Public generic functions
Method, packages: Public generic functions
Method, page-siblings: Public generic functions
Method, page-type: Public generic functions
Method, page-variants: Public generic functions
Method, pages: Public generic functions
Method, parent: Private generic functions
Method, parse: Public generic functions
Method, placeholder-intern: Public generic functions
Method, placeholder-name: Public generic functions
Method, placeholder-package: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, project: Public generic functions
Method, read-toplevel: Public generic functions
Method, read-toplevel: Public generic functions
Method, read-toplevel: Public generic functions
Method, relative-path: Public generic functions
Method, relative-path: Public generic functions
Method, relative-path: Public generic functions
Method, relative-path: Public generic functions
Method, relative-path: Public generic functions
Method, relative-path: Public generic functions
Method, resolve-source-link: Public generic functions
Method, resolve-source-link: Public generic functions
Method, resolve-source-link: Public generic functions
Method, shared-initialize: Public standalone methods
Method, shared-initialize: Public standalone methods
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, sub-results: Public generic functions
Method, subsystems: Public generic functions
Method, system: Public generic functions
Method, system: Public generic functions
Method, system-name: Private generic functions
Method, system-name: Private generic functions
Method, template: Public generic functions
Method, template-data: Public generic functions
Method, template-data: Public generic functions
Method, template-data: Public generic functions
Method, template-data: Public generic functions
Method, title: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk: Public generic functions
Method, walk-atom: Public generic functions
Method, walk-atom: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, walk-form: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions

N
namespace: Private ordinary functions
namespaces: Private generic functions
namespaces: Private generic functions

O
output: Public generic functions
output: Public generic functions
output: Public generic functions
output-directory: Public generic functions
output-directory: Public generic functions

P
package-system: Public generic functions
package-system: Public generic functions
package-system: Public generic functions
packages: Public generic functions
packages: Public generic functions
packages: Public generic functions
packages: Public generic functions
page-siblings: Public generic functions
page-siblings: Public generic functions
page-type: Public generic functions
page-type: Public generic functions
page-variants: Public generic functions
page-variants: Public generic functions
pages: Public generic functions
pages: Public generic functions
parent: Private generic functions
parent: Private generic functions
parse: Public generic functions
parse: Public generic functions
parse-lisp-token: Private ordinary functions
parse-result->definition-list: Public ordinary functions
parse-symbol: Private ordinary functions
pathname-type->type: Public ordinary functions
perform-and-record-macro-expansion: Private ordinary functions
placeholder-intern: Public generic functions
placeholder-intern: Public generic functions
placeholder-name: Public generic functions
placeholder-name: Public generic functions
placeholder-package: Public generic functions
placeholder-package: Public generic functions
preferred-definition: Public ordinary functions
prefix-p: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
project: Public generic functions
project: Public generic functions
purify-arglist: Public ordinary functions

R
read-file: Public ordinary functions
read-toplevel: Public generic functions
read-toplevel: Public generic functions
read-toplevel: Public generic functions
read-toplevel: Public generic functions
read-value: Private ordinary functions
relative-path: Public generic functions
relative-path: Public generic functions
relative-path: Public generic functions
relative-path: Public generic functions
relative-path: Public generic functions
relative-path: Public generic functions
relative-path: Public generic functions
remove-xref-resolver: Public ordinary functions
resolve-source-link: Public generic functions
resolve-source-link: Public generic functions
resolve-source-link: Public generic functions
resolve-source-link: Public generic functions
resolve-xref: Public ordinary functions

S
shared-initialize: Public standalone methods
shared-initialize: Public standalone methods
skip-to-source-form: Private ordinary functions
sort-definitions: Public ordinary functions
split: Private ordinary functions
stream-value: Private ordinary functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
sub-results: Public generic functions
subsystems: Public generic functions
subsystems: Public generic functions
system: Public generic functions
system: Public generic functions
system: Public generic functions
system-field: Private ordinary functions
system-name: Private generic functions
system-name: Private generic functions
system-name: Private generic functions

T
template: Public generic functions
template: Public generic functions
template-data: Public generic functions
template-data: Public generic functions
template-data: Public generic functions
template-data: Public generic functions
template-data: Public generic functions
tie-to-source: Public ordinary functions
title: Public generic functions
title: Public generic functions
titleize: Private ordinary functions

U
unlist: Private ordinary functions
url-encode: Public ordinary functions

W
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk: Public generic functions
walk-atom: Public generic functions
walk-atom: Public generic functions
walk-atom: Public generic functions
walk-bindings: Public ordinary functions
walk-body: Public ordinary functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-form: Public generic functions
walk-implicit-progn: Public ordinary functions
walk-lambda-like: Public ordinary functions
with-stream: Public macros
with-value-restart: Private macros

X
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref-resolver: Public ordinary functions


A.3 Variables

Jump to:   *  
D   I   L   N   O   P   S   T  
Index Entry  Section

*
*before-load-packages*: Private special variables
*current-commit-cache*: Private special variables
*default-template*: Public special variables
*document-patterns*: Public special variables
*image-patterns*: Public special variables
*load-prohibited-systems*: Public special variables
*loaded-extensions*: Private special variables
*page*: Public special variables
*pathname-type-type-map*: Private special variables
*system-packages*: Private special variables
*xref-resolvers*: Private special variables

D
document: Public classes
document-package: Public classes

I
images: Public classes
input: Public classes
intern: Public classes

L
language: Public classes

N
name: Public classes
namespaces: Public classes

O
output: Public classes
output: Public classes

P
package: Public classes
packages: Public classes
pages: Public classes
parent: Public classes
project: Public classes

S
Slot, document: Public classes
Slot, document-package: Public classes
Slot, images: Public classes
Slot, input: Public classes
Slot, intern: Public classes
Slot, language: Public classes
Slot, name: Public classes
Slot, namespaces: Public classes
Slot, output: Public classes
Slot, output: Public classes
Slot, package: Public classes
Slot, packages: Public classes
Slot, pages: Public classes
Slot, parent: Public classes
Slot, project: Public classes
Slot, system: Public conditions
Slot, system: Public classes
Slot, title: Public classes
Special Variable, *before-load-packages*: Private special variables
Special Variable, *current-commit-cache*: Private special variables
Special Variable, *default-template*: Public special variables
Special Variable, *document-patterns*: Public special variables
Special Variable, *image-patterns*: Public special variables
Special Variable, *load-prohibited-systems*: Public special variables
Special Variable, *loaded-extensions*: Private special variables
Special Variable, *page*: Public special variables
Special Variable, *pathname-type-type-map*: Private special variables
Special Variable, *system-packages*: Private special variables
Special Variable, *xref-resolvers*: Private special variables
system: Public conditions
system: Public classes

T
title: Public classes


A.4 Data types

Jump to:   C   D   E   F   I   N   P   R   S   T   W   X  
Index Entry  Section

C
Class, client: Private classes
Class, compiled-page: Public classes
Class, definitions-index-page: Public classes
Class, environment: Public classes
Class, input-page: Public classes
Class, page: Public classes
Class, placeholder: Public classes
Class, project: Public classes
Class, simple-page: Public classes
Class, simple-project: Public classes
Class, static-page: Public classes
Class, system-page: Public classes
Class, templated-page: Public classes
client: Private classes
clip.lisp: The staple/clip․lisp file
code-format.lisp: The staple/code-format․lisp file
compiled-page: Public classes
Condition, no-known-output-directory: Public conditions

D
definitions-index-page: Public classes
documentation.lisp: The staple/documentation․lisp file
documentation.lisp: The staple-code-parser/documentation․lisp file

E
environment: Public classes
environment.lisp: The staple-code-parser/environment․lisp file

F
File, clip.lisp: The staple/clip․lisp file
File, code-format.lisp: The staple/code-format․lisp file
File, documentation.lisp: The staple/documentation․lisp file
File, documentation.lisp: The staple-code-parser/documentation․lisp file
File, environment.lisp: The staple-code-parser/environment․lisp file
File, inference.lisp: The staple/inference․lisp file
File, package.lisp: The staple/package․lisp file
File, package.lisp: The staple-code-parser/package․lisp file
File, page.lisp: The staple/page․lisp file
File, project.lisp: The staple/project․lisp file
File, recording.lisp: The staple-package-recording/recording․lisp file
File, special-forms.lisp: The staple-code-parser/special-forms․lisp file
File, standard-forms.lisp: The staple-code-parser/standard-forms․lisp file
File, staple-code-parser.asd: The staple-code-parser/staple-code-parser․asd file
File, staple-package-recording.asd: The staple-package-recording/staple-package-recording․asd file
File, staple.asd: The staple/staple․asd file
File, to-definitions.lisp: The staple-code-parser/to-definitions․lisp file
File, toolkit.lisp: The staple/toolkit․lisp file
File, transform.lisp: The staple/transform․lisp file
File, walker.lisp: The staple-code-parser/walker․lisp file
File, xref.lisp: The staple/xref․lisp file

I
inference.lisp: The staple/inference․lisp file
input-page: Public classes

N
no-known-output-directory: Public conditions

P
Package, staple: The staple package
Package, staple-code-parser: The staple-code-parser package
Package, staple-package-recording: The staple-package-recording package
package.lisp: The staple/package․lisp file
package.lisp: The staple-code-parser/package․lisp file
page: Public classes
page.lisp: The staple/page․lisp file
placeholder: Public classes
project: Public classes
project.lisp: The staple/project․lisp file

R
recording.lisp: The staple-package-recording/recording․lisp file

S
simple-page: Public classes
simple-project: Public classes
special-forms.lisp: The staple-code-parser/special-forms․lisp file
standard-forms.lisp: The staple-code-parser/standard-forms․lisp file
staple: The staple system
staple: The staple package
staple-code-parser: The staple-code-parser system
staple-code-parser: The staple-code-parser package
staple-code-parser.asd: The staple-code-parser/staple-code-parser․asd file
staple-package-recording: The staple-package-recording system
staple-package-recording: The staple-package-recording package
staple-package-recording.asd: The staple-package-recording/staple-package-recording․asd file
staple.asd: The staple/staple․asd file
static-page: Public classes
stream-designator: Public types
System, staple: The staple system
System, staple-code-parser: The staple-code-parser system
System, staple-package-recording: The staple-package-recording system
system-page: Public classes

T
templated-page: Public classes
to-definitions.lisp: The staple-code-parser/to-definitions․lisp file
toolkit.lisp: The staple/toolkit․lisp file
transform.lisp: The staple/transform․lisp file
Type, stream-designator: Public types

W
walker.lisp: The staple-code-parser/walker․lisp file

X
xref.lisp: The staple/xref․lisp file