The erudite Reference Manual

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

The erudite Reference Manual

This is the erudite Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:30:23 2022 GMT+0.

Table of Contents


1 Introduction

ERUDITE

Quicklisp MIT License

Introduction

Erudite is a Literate Programming System for Common Lisp

Features

Quickstart

Write your embedded documentation in lisp comments (;; and #| … |# are supported). Use either erudite, latex or sphinx syntax, and produce output to one of them or markdown.

Example in the built-in erudite syntax:

#|
@title Erudite
@subtitle Literate Programming System for Common Lisp

@author Mariano Montone
@syntax erudite

@section Introduction

@ignore
|#
(in-package #:erudite)

#|
@end ignore

For a full example, see erudite.lisp.

Run make to build erudite command line if you want to run it from there, and then sudo make install to install.

Usage: erudite [-hvd] [+vd] [OPTIONS] FILES...

Erudite is a Literate Programming System for Common Lisp
  -h, --help                  Print this help and exit.
  --version                   Print Erudite version
  -(+)v, --verbose[=yes/no]   Run in verbose mode
                              Fallback: yes
                              Default: no
                              Environment: VERBOSE
  -(+)d, --debug[=on/off]     Turn debugging on or off.
                              Fallback: on
                              Default: off
                              Environment: DEBUG
  -(+)id, --implicit-doc[=yes/no] Treat all comments as documentation
                              Fallback: yes
                              Default: yes
  -(+)ic, --implicit-code[=yes/no] Include all code in documentation
                              Fallback: yes
                              Default: yes
  -o, --output=OUTPUT         The output file. If none is used, result is 
                              printed to stdout
  --output-type=OUTPUT-TYPE   The output type. One of 'latex', 
                              'sphinx','markdown'
                              Default: latex
  --syntax=SYNTAX             The syntax used in source files. One of 'erudite',
                              'latex', 'sphinx', 'markdown'
                              Default: erudite
  --author=AUTHOR             The author to appear in the document
  --title=TITLE               The document title

Or run it from lisp, using the erudite function described below.

To build erudite own documentation, run make under the doc directory:

make pdf
make sphinx-pdf
make sphinx-html
make markdown

Look at the doc directory for output examples.

Functions

erudite

(pathname files &rest args &key (output-type *output-type*)
          (syntax *syntax*) &allow-other-keys)

Processes literate lisp files and creates a document.

References


2 Systems

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


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

2.1 erudite

Literate Programming System for Common Lisp

Author

Mariano Montone <marianomontone@gmail.com>

Home Page

https://github.com/mmontone/erudite

License

MIT

Long Description

# ERUDITE

[![Quicklisp](http://quickdocs.org/badge/erudite.svg)](http://quickdocs.org/erudite/)
[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)

## Introduction

Erudite is a [Literate Programming](http://en.wikipedia.org/wiki/Literate_programming) System for Common Lisp

## Features

* Interactive development. No tangling phase in which code is extracted from documentation. Documentation is written in Common Lisp comments. This allows for incremental development: you can load your code, work from SLIME, etc, directly, as in any other Lisp project.

* Multiple syntaxes. Multiple type of literate syntax are supported. It is possible to choose from the default Erudite syntax, or use plain Latex or Sphinx syntax, and potentially others.

* Multiple outputs. Like Latex, Sphinx, Markdown, HTML, etc.

* Automatic indexing and cross-references.

* A command line interface.

* It is portable. You can compile and use in several CL systems (has been tested on SBCL, CCL, CLISP, ECL, so far)

## Quickstart

Write your embedded documentation in lisp comments (‘;;‘ and ‘#| … |#‘ are supported). Use either
‘erudite‘, ‘latex‘ or ‘sphinx‘ syntax, and produce output to one of
them or ‘markdown‘.

Example in the built-in ‘erudite‘ syntax:

“‘
#|
@title Erudite
@subtitle Literate Programming System for Common Lisp

@author Mariano Montone
@syntax erudite

@section Introduction

@ignore
|#
(in-package #:erudite)

#|
@end ignore
“‘

For a full example, see [erudite.lisp](erudite.lisp).

Run ‘make‘ to build erudite command line if you want to run it from there, and then ‘sudo make install‘ to install.

“‘
Usage: erudite [-hvd] [+vd] [OPTIONS] FILES...

Erudite is a Literate Programming System for Common Lisp
-h, –help Print this help and exit.
–version Print Erudite version
-(+)v, –verbose[=yes/no] Run in verbose mode
Fallback: yes
Default: no
Environment: VERBOSE
-(+)d, –debug[=on/off] Turn debugging on or off.
Fallback: on
Default: off
Environment: DEBUG
-(+)id, –implicit-doc[=yes/no] Treat all comments as documentation
Fallback: yes
Default: yes
-(+)ic, –implicit-code[=yes/no] Include all code in documentation
Fallback: yes
Default: yes
-o, –output=OUTPUT The output file. If none is used, result is
printed to stdout
–output-type=OUTPUT-TYPE The output type. One of ’latex’,
’sphinx’,’markdown’
Default: latex
–syntax=SYNTAX The syntax used in source files. One of ’erudite’,
’latex’, ’sphinx’, ’markdown’
Default: erudite
–author=AUTHOR The author to appear in the document
–title=TITLE The document title
“‘

Or run it from lisp, using the ‘erudite‘ function described below.

To build erudite own documentation, run ‘make‘ under the ‘doc‘ directory:

“‘
make pdf
make sphinx-pdf
make sphinx-html
make markdown
“‘

Look at the ‘doc‘ directory for output examples.

## Functions
### erudite

“‘lisp
(pathname files &rest args &key (output-type *output-type*)
(syntax *syntax*) &allow-other-keys)
“‘

Processes literate lisp files and creates a document.

- **pathname**: Pathname of the file to generate. If ‘nil‘, output to a string. If ‘t‘, print to standard output.
- **files**: Literate lisp files to compile
- **args**: All sort of options passed to the generation functions
- **output-type**: The kind of document to generate.
One of :latex, :sphinx, :markdown
Default: :latex
- **syntax**: The kind of syntax used in the literate source files.
One of: :erudite, :latex, :sphinx, :markdown.
Default: :erudite

## References

* [Literate Programming](http://en.wikipedia.org/wiki/Literate_programming)
* [Literate Programming in the Large](https://youtu.be/Av0PQDVTP4A)
* [Erudite: a tool for Literate Programming in Common Lisp](http://mmontone-programming.blogspot.com.ar/2015/05/literate-programming-in-common-lisp.html)

Dependencies
  • cl-fad (system).
  • cl-ppcre (system).
  • alexandria (system).
  • split-sequence (system).
  • cl-template (system).
  • log4cl (system).
  • swank-client (system).
Source

erudite.asd.

Child Components

3 Modules

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


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

3.1 erudite/syntax

Dependency

commands.lisp (file).

Source

erudite.asd.

Parent Component

erudite (system).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 erudite/erudite.asd

Source

erudite.asd.

Parent Component

erudite (system).

ASDF Systems

erudite.


4.1.2 erudite/package.lisp

Source

erudite.asd.

Parent Component

erudite (system).

Packages

erudite.


4.1.3 erudite/config.lisp

Dependency

package.lisp (file).

Source

erudite.asd.

Parent Component

erudite (system).

Public Interface
Internals

4.1.4 erudite/util.lisp

Dependency

config.lisp (file).

Source

erudite.asd.

Parent Component

erudite (system).

Internals

4.1.5 erudite/commands.lisp

Dependency

util.lisp (file).

Source

erudite.asd.

Parent Component

erudite (system).

Internals

4.1.6 erudite/syntax/erudite.lisp

Source

erudite.asd.

Parent Component

syntax (module).

Internals

4.1.7 erudite/syntax/latex.lisp

Source

erudite.asd.

Parent Component

syntax (module).

Internals

4.1.8 erudite/syntax/sphinx.lisp

Source

erudite.asd.

Parent Component

syntax (module).

Internals

4.1.9 erudite/syntax/markdown.lisp

Source

erudite.asd.

Parent Component

syntax (module).

Internals

4.1.10 erudite/syntax/org.lisp

Source

erudite.asd.

Parent Component

syntax (module).

Internals

4.1.11 erudite/erudite.lisp

Dependency

syntax (module).

Source

erudite.asd.

Parent Component

erudite (system).

Public Interface

erudite (function).

Internals

5 Packages

Packages are listed by definition order.


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

5.1 erudite

Erudite is a Literate Programming System for Common Lisp

Source

package.lisp.

Use List
  • cl-ppcre.
  • common-lisp.
Public Interface
Internals

6 Definitions

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


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

6.1 Public Interface


6.1.1 Special variables

Special Variable: *catch-errors-p*
Package

erudite.

Source

config.lisp.

Special Variable: *code-indexing*
Package

erudite.

Source

config.lisp.

Special Variable: *debug*
Package

erudite.

Source

config.lisp.

Special Variable: *erudite-package*
Package

erudite.

Source

config.lisp.

Special Variable: *implicit-code*
Package

erudite.

Source

config.lisp.

Special Variable: *implicit-doc*
Package

erudite.

Source

config.lisp.

Special Variable: *output-type*
Package

erudite.

Source

config.lisp.

Special Variable: *short-comments-prefix*
Package

erudite.

Source

config.lisp.

Special Variable: *subtitle*
Package

erudite.

Source

config.lisp.

Special Variable: *syntax*
Package

erudite.

Source

config.lisp.

Special Variable: *title*
Package

erudite.

Source

config.lisp.

Special Variable: *verbose*
Package

erudite.

Source

config.lisp.


6.1.2 Ordinary functions

Function: erudite (destination file-or-files &rest args &key output-type syntax debug verbose catch-errors-p code-indexing implicit-doc implicit-code short-comments-prefix &allow-other-keys)

Processes literate lisp files and creates a document.

Args: - destination: If NIL, output is written to a string. If T, output is written to *standard-output*. If a pathname, then a file is created. Otherwise, a stream is expected. - files: Literate lisp files to compile
- args: All sort of options passed to the generation functions
- output-type: The kind of document to generate.
One of :latex, :sphinx
Default: :latex
- syntax: The kind of syntax used in the literate source files.
One of: :erudite, :latex, :org, :markdown, :sphinx.
Default: :erudite

Package

erudite.

Source

erudite.lisp.


6.2 Internals


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

6.2.1 Special variables

Special Variable: *author*
Package

erudite.

Source

config.lisp.

Special Variable: *chunks*
Package

erudite.

Source

config.lisp.

Special Variable: *commands*
Package

erudite.

Source

commands.lisp.

Special Variable: *current-eval*
Package

erudite.

Source

commands.lisp.

Special Variable: *current-extract*
Package

erudite.

Source

commands.lisp.

Special Variable: *current-path*
Package

erudite.

Source

config.lisp.

Special Variable: *erudite-syntax*
Package

erudite.

Source

erudite.lisp.

Special Variable: *extracts*
Package

erudite.

Source

commands.lisp.

Special Variable: *ignore*
Package

erudite.

Source

commands.lisp.

Special Variable: *in-code-section*
Package

erudite.

Source

commands.lisp.

Special Variable: *include-path*
Package

erudite.

Source

erudite.lisp.

Special Variable: *latex-document-class*
Package

erudite.

Source

erudite.lisp.

Special Variable: *latex-highlight-syntax*

Highlight syntax using LaTeX minted package: https://ctan.org/pkg/minted

Package

erudite.

Source

erudite.lisp.

Special Variable: *output-condition*
Package

erudite.

Source

commands.lisp.

Special Variable: *parsing-doc*
Package

erudite.

Source

erudite.lisp.

Special Variable: *sphinx-indent*
Package

erudite.

Source

sphinx.lisp.

Special Variable: *swank-connection*
Package

erudite.

Source

commands.lisp.

Special Variable: *swank-host*
Package

erudite.

Source

commands.lisp.

Special Variable: *swank-port*
Package

erudite.

Source

commands.lisp.


6.2.2 Macros

Macro: define-command (name &body body)
Package

erudite.

Source

commands.lisp.

Macro: define-erudite-syntax (name &body body)
Package

erudite.

Source

erudite.lisp.

Macro: with-destination ((var destination) &body body)
Package

erudite.

Source

erudite.lisp.

Macro: with-error-handling ((&optional catch-errors-p) &body body)
Package

erudite.

Source

erudite.lisp.


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

6.2.3 Ordinary functions

Function: append-source-fragments (fragments)

Append docs and code fragments

Package

erudite.

Source

erudite.lisp.

Function: append-to-end (thing list)
Package

erudite.

Source

util.lisp.

Function: call-with-destination (destination function)
Package

erudite.

Source

erudite.lisp.

Function: call-with-error-handling (catch-errors-p function)
Package

erudite.

Source

erudite.lisp.

Function: escape-latex (str)
Package

erudite.

Source

erudite.lisp.

Function: expand-includes (stream)

Expand include directives

Package

erudite.

Source

erudite.lisp.

Function: extract-chunks (string)

Splits a file source in docs and code

Package

erudite.

Source

erudite.lisp.

Function: extract-indexes (code)
Package

erudite.

Source

erudite.lisp.

Function: file-to-string (pathname)
Package

erudite.

Source

util.lisp.

Function: find-chunk (chunk-name &key error-p)
Package

erudite.

Source

commands.lisp.

Function: find-command (name &optional error-p)
Package

erudite.

Source

commands.lisp.

Function: find-extract (extract-name &key error-p)
Package

erudite.

Source

commands.lisp.

Function: find-matching-command (line)
Package

erudite.

Source

commands.lisp.

Function: find-syntax (name &optional error-p)
Package

erudite.

Source

erudite.lisp.

Function: format-syntax (destination syntax)
Package

erudite.

Source

erudite.lisp.

Function: indent-code (code)

Code in sphinx has to be indented

Package

erudite.

Source

erudite.lisp.

Function: latex-label (str)
Package

erudite.

Source

erudite.lisp.

Function: maybe-invoke-debugger (condition)

This function is called whenever a condition CONDITION is signaled in Erudite.

Package

erudite.

Source

erudite.lisp.

Function: parse-code (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-definition-type (str)
Package

erudite.

Source

erudite.lisp.

Function: parse-line (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-long-comment (line stream)

Parse a comment between #| and |#

Package

erudite.

Source

erudite.lisp.

Function: parse-long-comment-explicit (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-long-comment-implicit (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-short-comment (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-short-comment-explicit (line stream)
Package

erudite.

Source

erudite.lisp.

Function: parse-short-comment-implicit (line stream)
Package

erudite.

Source

erudite.lisp.

Function: post-process-output (str)

Resolve chunk inserts and extract inserts after processing

Package

erudite.

Source

erudite.lisp.

Function: process-fragments (fragments output)
Package

erudite.

Source

erudite.lisp.

Function: process-string (string)
Package

erudite.

Source

erudite.lisp.

Function: split-file-source (str)

Splits a file source in docs and code

Package

erudite.

Source

erudite.lisp.


6.2.4 Generic functions

Generic Function: %format-syntax (output-type selector stream syntax)
Package

erudite.

Methods
Method: %format-syntax ((output-type (eql :org)) (selector (eql :index)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :ref)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :label)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :link)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :italics)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :bold)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :emph)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :list-item)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :end-list)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :begin-list)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :end-code)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :begin-code)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :inline-verbatim)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :end-verbatim)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :begin-verbatim)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :subsubsection)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :subsection)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :org)) (selector (eql :section)) stream syntax)
Source

org.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :index)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :ref)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :label)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :link)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :italics)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :bold)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :emph)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :list-item)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :end-list)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :begin-list)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :end-code)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :begin-code)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :inline-verbatim)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :end-verbatim)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :begin-verbatim)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :subsubsection)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :subsection)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :markdown)) (selector (eql :section)) stream syntax)
Source

markdown.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :index)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :ref)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :label)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :link)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :italics)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :bold)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :emph)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :list-item)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :end-list)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :begin-list)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :end-code)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :begin-code)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :inline-verbatim)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :end-verbatim)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :begin-verbatim)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :subsubsection)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :subsection)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :sphinx)) (selector (eql :section)) stream syntax)
Source

sphinx.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :index)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :ref)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :label)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :link)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :italics)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :bold)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :emph)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :list-item)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :end-list)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :begin-list)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :end-code)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :begin-code)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :inline-verbatim)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :end-verbatim)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :begin-verbatim)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :subsubsection)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :subsection)) stream syntax)
Source

latex.lisp.

Method: %format-syntax ((output-type (eql :latex)) (selector (eql :section)) stream syntax)
Source

latex.lisp.

Generic Function: gen-doc (output-type output files &rest args &key prelude postlude syntax title subtitle author template-pathname document-class highlight-syntax &allow-other-keys)
Package

erudite.

Source

erudite.lisp.

Methods
Method: gen-doc ((output-type (eql :org)) output files &key prelude postlude syntax title subtitle author &allow-other-keys)

Generates Emacs org-mode document.

Args: - output: The output stream.
- files: .lisp files to compile.
- prelude: String (or pathname) to append before the document. - postlude: String (or pathname) to append after the document.

Method: gen-doc ((output-type (eql :markdown)) output files &key prelude postlude syntax &allow-other-keys)

Generates Markdown document.

Args: - output: The output stream.
- files: .lisp files to compile.
- prelude: String (or pathname) to append before the document. - postlude: String (or pathname) to append after the document.

Method: gen-doc ((output-type (eql :sphinx)) output files &key prelude postlude syntax &allow-other-keys)

Generates Sphinx document.

Args: - output: The output stream.
- files: .lisp files to compile.
- prelude: String (or pathname) to append before the Sphinx document. - postlude: String (or pathname) to append after the Sphinx document.

Method: gen-doc ((output-type (eql :latex)) output files &key title subtitle author template-pathname syntax document-class highlight-syntax &allow-other-keys)

Generates a LaTeX document.

Args: - output: The output stream.
- files: The list of .lisp files to compile
- title: Document title.
- subtitle: Document subtitle.
- author: Author of the document
- template-pathname: A custom LaTeX template file. If none is specified, a default template is used.

Generic Function: match-command (command line)
Package

erudite.

Source

commands.lisp.

Methods
Method: match-command ((command (eql erudite::end-eval)) line)
Method: match-command ((command (eql erudite::begin-eval)) line)
Method: match-command ((command (eql erudite::end-code)) line)
Method: match-command ((command (eql erudite::begin-code)) line)
Method: match-command ((command (eql erudite::end-if)) line)
Method: match-command ((command (eql erudite::else)) line)
Method: match-command ((command (eql if)) line)
Method: match-command ((command (eql erudite::end-when)) line)
Method: match-command ((command (eql when)) line)
Method: match-command ((command (eql erudite::end-ignore)) line)
Method: match-command ((command (eql ignore)) line)
Method: match-command ((command (eql erudite::insert)) line)
Method: match-command ((command (eql erudite::end-extract)) line)
Method: match-command ((command (eql erudite::extract)) line)
Method: match-command ((command (eql erudite::insert-chunk)) line)
Method: match-command ((command (eql erudite::short-comments-prefix)) line)
Method: match-command ((command (eql erudite::author)) line)
Method: match-command ((command (eql erudite::subtitle)) line)
Method: match-command ((command (eql erudite::title)) line)
Method: match-command ((command (eql package)) line)
Method: match-command ((command (eql erudite::code-indexing)) line)
Method: match-command ((command (eql erudite::output-type)) line)
Method: match-command ((command (eql erudite::syntax)) line)
Generic Function: match-syntax (command line)
Package

erudite.

Methods
Method: match-syntax ((command (eql erudite::reference)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::index)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::label)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::link)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::inline-verbatim)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::italics)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::bold)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::emphasis)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::list-item)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::end-list)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::begin-list)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::end-code)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::begin-code)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::end-verbatim)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::begin-verbatim)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::subsubsection)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::subsection)) line)
Source

erudite.lisp.

Method: match-syntax ((command (eql erudite::section)) line)
Source

erudite.lisp.

Generic Function: maybe-process-command (line input output cont)
Package

erudite.

Methods
Method: maybe-process-command (line input output cont)

Process a top-level command

Source

erudite.lisp.

Method: maybe-process-command :around (line input output cont)
Source

commands.lisp.

Generic Function: process-command (command line input output cont)
Package

erudite.

Source

commands.lisp.

Methods
Method: process-command ((command (eql erudite::end-eval)) line input output cont)
Method: process-command ((command (eql erudite::begin-eval)) line input output cont)
Method: process-command ((command (eql erudite::end-code)) line input output cont)
Method: process-command ((command (eql erudite::begin-code)) line input output cont)
Method: process-command ((command (eql erudite::end-if)) line input output cont)
Method: process-command ((command (eql erudite::else)) line input output cont)
Method: process-command ((command (eql if)) line input output cont)
Method: process-command ((command (eql erudite::end-when)) line input output cont)
Method: process-command ((command (eql when)) line input output cont)
Method: process-command ((command (eql erudite::end-ignore)) line input output cont)
Method: process-command ((command (eql ignore)) line input output cont)
Method: process-command ((command (eql erudite::insert)) line input output cont)
Method: process-command ((command (eql erudite::end-extract)) line input output cont)
Method: process-command ((command (eql erudite::extract)) line input output cont)
Method: process-command ((command (eql erudite::insert-chunk)) line input output cont)
Method: process-command ((command (eql erudite::short-comments-prefix)) line input output cont)
Method: process-command ((command (eql erudite::author)) line input output cont)
Method: process-command ((command (eql erudite::subtitle)) line input output cont)
Method: process-command ((command (eql erudite::title)) line input output cont)
Method: process-command ((command (eql package)) line input output cont)
Method: process-command ((command (eql erudite::code-indexing)) line input output cont)
Method: process-command ((command (eql erudite::output-type)) line input output cont)
Method: process-command ((command (eql erudite::syntax)) line input output cont)
Method: process-command :before (command line input output cont)
Generic Function: process-doc (syntax output-type line stream cont)
Package

erudite.

Methods
Method: process-doc ((syntax (eql :erudite)) output-type line stream cont)
Source

erudite.lisp.

Method: process-doc ((syntax (eql :markdown)) output-type line stream cont)
Source

erudite.lisp.

Method: process-doc ((syntax (eql :org)) output-type line stream cont)
Source

erudite.lisp.

Method: process-doc ((syntax (eql :sphinx)) output-type line stream cont)
Source

erudite.lisp.

Method: process-doc ((syntax (eql :latex)) output-type line stream cont)
Source

erudite.lisp.

Method: process-doc :around (syntax output-type line stream cont)
Source

commands.lisp.

Generic Function: process-file-to-string (pathname)
Package

erudite.

Methods
Method: process-file-to-string :after (pathname)
Source

erudite.lisp.

Method: process-file-to-string :before (pathname)
Source

erudite.lisp.

Method: process-file-to-string ((files cons))
Source

erudite.lisp.

Method: process-file-to-string ((pathname pathname))
Source

erudite.lisp.

Generic Function: process-fragment (fragment-type fragment output cont)
Package

erudite.

Source

erudite.lisp.

Methods
Method: process-fragment ((type (eql :doc)) fragment output cont)
Method: process-fragment ((type (eql :code)) fragment output cont)
Method: process-fragment :around ((type (eql :code)) fragment output cont)
Source

commands.lisp.

Generic Function: process-syntax (command line output output-type)
Package

erudite.

Methods
Method: process-syntax ((command (eql erudite::reference)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::index)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::label)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::link)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::inline-verbatim)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::italics)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::bold)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::emphasis)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::list-item)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::end-list)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::begin-list)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::end-code)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::begin-code)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::end-verbatim)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::begin-verbatim)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::subsubsection)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::subsection)) line output output-type)
Source

erudite.lisp.

Method: process-syntax ((command (eql erudite::section)) line output output-type)
Source

erudite.lisp.

Generic Function: write-chunk (chunk-name chunk stream)
Package

erudite.

Methods
Method: write-chunk (chunk-name chunk stream)
Source

erudite.lisp.

Generic Function: write-chunk-name (chunk-name stream)
Package

erudite.

Methods
Method: write-chunk-name (chunk-name stream)
Source

erudite.lisp.

Generic Function: write-code (code stream output-type)
Package

erudite.

Methods
Method: write-code (code stream (output-type (eql :org)))
Source

erudite.lisp.

Method: write-code (code stream (output-type (eql :markdown)))
Source

erudite.lisp.

Method: write-code (code stream (output-type (eql :sphinx)))
Source

erudite.lisp.

Method: write-code (code stream (output-type (eql :latex)))
Source

erudite.lisp.

Generic Function: write-doc-line (line output output-type)
Package

erudite.

Methods
Method: write-doc-line (line stream output-type)
Source

erudite.lisp.

Method: write-doc-line :before (line output (output-type (eql :sphinx)))
Source

sphinx.lisp.

Generic Function: write-indexes (indexes output output-type)
Package

erudite.

Source

erudite.lisp.

Methods
Method: write-indexes (indexes output (output-type (eql :org)))
Method: write-indexes (indexes output (output-type (eql :markdown)))
Method: write-indexes (indexes output (output-type (eql :sphinx)))
Method: write-indexes (indexes output (output-type (eql :latex)))

Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   %  
A   C   D   E   F   G   I   L   M   P   S   W  
Index Entry  Section

%
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions
%format-syntax: Private generic functions

A
append-source-fragments: Private ordinary functions
append-to-end: Private ordinary functions

C
call-with-destination: Private ordinary functions
call-with-error-handling: Private ordinary functions

D
define-command: Private macros
define-erudite-syntax: Private macros

E
erudite: Public ordinary functions
escape-latex: Private ordinary functions
expand-includes: Private ordinary functions
extract-chunks: Private ordinary functions
extract-indexes: Private ordinary functions

F
file-to-string: Private ordinary functions
find-chunk: Private ordinary functions
find-command: Private ordinary functions
find-extract: Private ordinary functions
find-matching-command: Private ordinary functions
find-syntax: Private ordinary functions
format-syntax: Private ordinary functions
Function, append-source-fragments: Private ordinary functions
Function, append-to-end: Private ordinary functions
Function, call-with-destination: Private ordinary functions
Function, call-with-error-handling: Private ordinary functions
Function, erudite: Public ordinary functions
Function, escape-latex: Private ordinary functions
Function, expand-includes: Private ordinary functions
Function, extract-chunks: Private ordinary functions
Function, extract-indexes: Private ordinary functions
Function, file-to-string: Private ordinary functions
Function, find-chunk: Private ordinary functions
Function, find-command: Private ordinary functions
Function, find-extract: Private ordinary functions
Function, find-matching-command: Private ordinary functions
Function, find-syntax: Private ordinary functions
Function, format-syntax: Private ordinary functions
Function, indent-code: Private ordinary functions
Function, latex-label: Private ordinary functions
Function, maybe-invoke-debugger: Private ordinary functions
Function, parse-code: Private ordinary functions
Function, parse-definition-type: Private ordinary functions
Function, parse-line: Private ordinary functions
Function, parse-long-comment: Private ordinary functions
Function, parse-long-comment-explicit: Private ordinary functions
Function, parse-long-comment-implicit: Private ordinary functions
Function, parse-short-comment: Private ordinary functions
Function, parse-short-comment-explicit: Private ordinary functions
Function, parse-short-comment-implicit: Private ordinary functions
Function, post-process-output: Private ordinary functions
Function, process-fragments: Private ordinary functions
Function, process-string: Private ordinary functions
Function, split-file-source: Private ordinary functions

G
gen-doc: Private generic functions
gen-doc: Private generic functions
gen-doc: Private generic functions
gen-doc: Private generic functions
gen-doc: Private generic functions
Generic Function, %format-syntax: Private generic functions
Generic Function, gen-doc: Private generic functions
Generic Function, match-command: Private generic functions
Generic Function, match-syntax: Private generic functions
Generic Function, maybe-process-command: Private generic functions
Generic Function, process-command: Private generic functions
Generic Function, process-doc: Private generic functions
Generic Function, process-file-to-string: Private generic functions
Generic Function, process-fragment: Private generic functions
Generic Function, process-syntax: Private generic functions
Generic Function, write-chunk: Private generic functions
Generic Function, write-chunk-name: Private generic functions
Generic Function, write-code: Private generic functions
Generic Function, write-doc-line: Private generic functions
Generic Function, write-indexes: Private generic functions

I
indent-code: Private ordinary functions

L
latex-label: Private ordinary functions

M
Macro, define-command: Private macros
Macro, define-erudite-syntax: Private macros
Macro, with-destination: Private macros
Macro, with-error-handling: Private macros
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-command: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
match-syntax: Private generic functions
maybe-invoke-debugger: Private ordinary functions
maybe-process-command: Private generic functions
maybe-process-command: Private generic functions
maybe-process-command: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, %format-syntax: Private generic functions
Method, gen-doc: Private generic functions
Method, gen-doc: Private generic functions
Method, gen-doc: Private generic functions
Method, gen-doc: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-command: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, match-syntax: Private generic functions
Method, maybe-process-command: Private generic functions
Method, maybe-process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-command: Private generic functions
Method, process-doc: Private generic functions
Method, process-doc: Private generic functions
Method, process-doc: Private generic functions
Method, process-doc: Private generic functions
Method, process-doc: Private generic functions
Method, process-doc: Private generic functions
Method, process-file-to-string: Private generic functions
Method, process-file-to-string: Private generic functions
Method, process-file-to-string: Private generic functions
Method, process-file-to-string: Private generic functions
Method, process-fragment: Private generic functions
Method, process-fragment: Private generic functions
Method, process-fragment: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, process-syntax: Private generic functions
Method, write-chunk: Private generic functions
Method, write-chunk-name: Private generic functions
Method, write-code: Private generic functions
Method, write-code: Private generic functions
Method, write-code: Private generic functions
Method, write-code: Private generic functions
Method, write-doc-line: Private generic functions
Method, write-doc-line: Private generic functions
Method, write-indexes: Private generic functions
Method, write-indexes: Private generic functions
Method, write-indexes: Private generic functions
Method, write-indexes: Private generic functions

P
parse-code: Private ordinary functions
parse-definition-type: Private ordinary functions
parse-line: Private ordinary functions
parse-long-comment: Private ordinary functions
parse-long-comment-explicit: Private ordinary functions
parse-long-comment-implicit: Private ordinary functions
parse-short-comment: Private ordinary functions
parse-short-comment-explicit: Private ordinary functions
parse-short-comment-implicit: Private ordinary functions
post-process-output: Private ordinary functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-command: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-doc: Private generic functions
process-file-to-string: Private generic functions
process-file-to-string: Private generic functions
process-file-to-string: Private generic functions
process-file-to-string: Private generic functions
process-file-to-string: Private generic functions
process-fragment: Private generic functions
process-fragment: Private generic functions
process-fragment: Private generic functions
process-fragment: Private generic functions
process-fragments: Private ordinary functions
process-string: Private ordinary functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions
process-syntax: Private generic functions

S
split-file-source: Private ordinary functions

W
with-destination: Private macros
with-error-handling: Private macros
write-chunk: Private generic functions
write-chunk: Private generic functions
write-chunk-name: Private generic functions
write-chunk-name: Private generic functions
write-code: Private generic functions
write-code: Private generic functions
write-code: Private generic functions
write-code: Private generic functions
write-code: Private generic functions
write-doc-line: Private generic functions
write-doc-line: Private generic functions
write-doc-line: Private generic functions
write-indexes: Private generic functions
write-indexes: Private generic functions
write-indexes: Private generic functions
write-indexes: Private generic functions
write-indexes: Private generic functions

Jump to:   %  
A   C   D   E   F   G   I   L   M   P   S   W  

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

A.3 Variables

Jump to:   *  
S  
Index Entry  Section

*
*author*: Private special variables
*catch-errors-p*: Public special variables
*chunks*: Private special variables
*code-indexing*: Public special variables
*commands*: Private special variables
*current-eval*: Private special variables
*current-extract*: Private special variables
*current-path*: Private special variables
*debug*: Public special variables
*erudite-package*: Public special variables
*erudite-syntax*: Private special variables
*extracts*: Private special variables
*ignore*: Private special variables
*implicit-code*: Public special variables
*implicit-doc*: Public special variables
*in-code-section*: Private special variables
*include-path*: Private special variables
*latex-document-class*: Private special variables
*latex-highlight-syntax*: Private special variables
*output-condition*: Private special variables
*output-type*: Public special variables
*parsing-doc*: Private special variables
*short-comments-prefix*: Public special variables
*sphinx-indent*: Private special variables
*subtitle*: Public special variables
*swank-connection*: Private special variables
*swank-host*: Private special variables
*swank-port*: Private special variables
*syntax*: Public special variables
*title*: Public special variables
*verbose*: Public special variables

S
Special Variable, *author*: Private special variables
Special Variable, *catch-errors-p*: Public special variables
Special Variable, *chunks*: Private special variables
Special Variable, *code-indexing*: Public special variables
Special Variable, *commands*: Private special variables
Special Variable, *current-eval*: Private special variables
Special Variable, *current-extract*: Private special variables
Special Variable, *current-path*: Private special variables
Special Variable, *debug*: Public special variables
Special Variable, *erudite-package*: Public special variables
Special Variable, *erudite-syntax*: Private special variables
Special Variable, *extracts*: Private special variables
Special Variable, *ignore*: Private special variables
Special Variable, *implicit-code*: Public special variables
Special Variable, *implicit-doc*: Public special variables
Special Variable, *in-code-section*: Private special variables
Special Variable, *include-path*: Private special variables
Special Variable, *latex-document-class*: Private special variables
Special Variable, *latex-highlight-syntax*: Private special variables
Special Variable, *output-condition*: Private special variables
Special Variable, *output-type*: Public special variables
Special Variable, *parsing-doc*: Private special variables
Special Variable, *short-comments-prefix*: Public special variables
Special Variable, *sphinx-indent*: Private special variables
Special Variable, *subtitle*: Public special variables
Special Variable, *swank-connection*: Private special variables
Special Variable, *swank-host*: Private special variables
Special Variable, *swank-port*: Private special variables
Special Variable, *syntax*: Public special variables
Special Variable, *title*: Public special variables
Special Variable, *verbose*: Public special variables

Jump to:   *  
S  

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

A.4 Data types

Jump to:   C   E   F   L   M   O   P   S   U  
Index Entry  Section

C
commands.lisp: The erudite/commands․lisp file
config.lisp: The erudite/config․lisp file

E
erudite: The erudite system
erudite: The erudite package
erudite.asd: The erudite/erudite․asd file
erudite.lisp: The erudite/syntax/erudite․lisp file
erudite.lisp: The erudite/erudite․lisp file

F
File, commands.lisp: The erudite/commands․lisp file
File, config.lisp: The erudite/config․lisp file
File, erudite.asd: The erudite/erudite․asd file
File, erudite.lisp: The erudite/syntax/erudite․lisp file
File, erudite.lisp: The erudite/erudite․lisp file
File, latex.lisp: The erudite/syntax/latex․lisp file
File, markdown.lisp: The erudite/syntax/markdown․lisp file
File, org.lisp: The erudite/syntax/org․lisp file
File, package.lisp: The erudite/package․lisp file
File, sphinx.lisp: The erudite/syntax/sphinx․lisp file
File, util.lisp: The erudite/util․lisp file

L
latex.lisp: The erudite/syntax/latex․lisp file

M
markdown.lisp: The erudite/syntax/markdown․lisp file
Module, syntax: The erudite/syntax module

O
org.lisp: The erudite/syntax/org․lisp file

P
Package, erudite: The erudite package
package.lisp: The erudite/package․lisp file

S
sphinx.lisp: The erudite/syntax/sphinx․lisp file
syntax: The erudite/syntax module
System, erudite: The erudite system

U
util.lisp: The erudite/util․lisp file

Jump to:   C   E   F   L   M   O   P   S   U