The scribble Reference Manual

Table of Contents

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

The scribble Reference Manual

This is the scribble Reference Manual, version 1.0.1.2, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:33:15 2018 GMT+0.


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

1 Introduction

Scribble: SCRibe-like reader extension for Common Lisp
Copyright (c) 2002-2012 by Fare Rideau < fare at tunes dot org >
	http://www.cliki.net/Fare%20Rideau

HOME PAGE:
	http://www.cliki.net/Scribble

LICENSE:
	http://tunes.org/legalese/bugroff.html
You may at your leisure use the LLGPL instead:
	http://www.cliki.net/LLGPL

DEPENDENCY:
This package depends on Meta by Jochen Schmidt, version 1.0.0 or later.
	http://www.cliki.net/Meta
Now also: meta fare-utils fare-matcher named-readtables

USAGE:
You can enable Racket-like Scribble behavior for the macro-character #\@ with
	(scribble:enable-scribble-at-syntax)
and disable it with
	(scribble:disable-scribble-at-syntax)
You may also use
	(named-readtables:in-readtable :scribble-racket)
Or
	(named-readtables:in-readtable :scribble-both)
Or
	(named-readtables:in-readtable :scribble)
For details, see:
	http://docs.racket-lang.org/scribble/reader.html

If you additionally pass the keyword argument :skribe t
You will also have Skribe-like syntax.

You can enable only Skribe-like syntax for the macro-character #\[ with
	(scribble:enable-scribble-syntax)
and disable it with
	(scribble:disable-scribble-syntax)
You may also use
	(named-readtables:in-readtable :scribble-skribe)
Or
	(named-readtables:in-readtable :scribble-both)
Or
	(named-readtables:in-readtable :scribble)

Alternatively, you can enable behaviour for the character #\[
under the dispatching macro-character #\# using
	(scribble:enable-sub-scribble-syntax)
	(scribble:disable-sub-scribble-syntax)


AT SYNTAX:
The syntax of text after @ is just like
Racket's Scribble syntax by Eli Barzilay.
His Scribble "at-syntax" is described thus:
	http://barzilay.org/research.html
	http://barzilay.org/misc/scribble-reader.pdf
	http://docs.racket-lang.org/scribble/reader.html


BASIC SYNTAX:
The syntax of text within brackets is Skribe-like:

* Text between brackets will expand to a string containing said text,
 unless there are escape forms in the text,
 which are identified by a comma
 followed by either an opening parenthesis or an opening bracket.

* If there are escape forms in the text,
 then the text will be split into components,
 which will be non-empty strings and escape forms.
 The result of parsing the text will be a (LIST ...) of these components.

* A comma followed by a parenthesis denotes an escape form,
 whereas a SEXP beginning with said parenthesis
 is read and used as a component of the surrounding text.
 For instance, [foo ,(bar baz) quux] will (on first approximation) be read as
	(LIST "foo " (bar baz) " quux")
 Mind the spaces being preserved around the internal form.

EXTENSION TO SCRIBE SYNTAX:
Scribble extends the Scribe syntax in a way that I find very convenient.

* As an extension to Scribe syntax,
 if the first character of text within bracket is an unescaped colon #\:
 then an expression after it is read that is used
 as a "head" for the body of the text resulting from parsing as above.
	[:emph this] is read as (EMPH "this")
	[:(font :size -1) that] is read as (FONT :SIZE -1 "that")

* As another extension to Scribe syntax,
 a comma followed by a bracket will also denote an escape form,
 whereas the bracketed-text using Scribble syntax
 is read and used as a component of the surrounding text.
 This extension is only useful in conjunction with the previous extension.

SYNTACTIC CATCHES:
There are a few possible sources of problems with the Scribe syntax,
and solutions provided by Scribe and Scribble to avoid these problems.

* A closing bracket closes the current text.
 Standard Scribe syntax doesn't provide a mean
 to include a closing bracket in bracketed text.

* Conversely, so as to prevent difficult to track syntax errors
 resulting from typos, Standard Scribe syntax forbids
 to include an opening bracket in the text.

* As an extension to Scribe syntax,
 you can include any character in the text,
 without triggering any special or error-raising behaviour,
 by preceding it with a backslash character #\\ in the text
 (which preceding backslash character won't be included in the result string).
 This is useful to include a character among #\\ #\: #\, #\[ #\] #\(.

* While #\\ will always be able to escape all non-alphanumeric characters,
 including the special characters listed above,
 future extensions may give a special meaning to #\\ followed by a character
 in the regexp range [_a-zA-Z0-9].
 If you feel the need for such an extension, I will accept patches;
 I suppose that the C or Perl syntax is what is needed here.

* In the bracket-colon syntax extension, after reading the "head",
 all spacing characters (space, tab, newline, linefeed, return, page)
 are skipped until the next non-space character.
 To insert a space character immediately after the head,
 just escape it using #\\ as above.

* As a restriction from Scribe syntax, Scribble syntax
 doesn't recognize the use of semi-colon as denoting discardable comments.
 In Scribe, a semi-colon at the beginning of a line or of bracketed text
 or of a string component of bracketed text will denote a comment,
 whereas Scribe will ignore any text to the next end of line.
 Scribble will include any such text in the result string.
 You can emulate the original Scribe behaviour in this regard
 by using the preprocessing customization feature described below.

CUSTOMIZATION:
Scribble can be customized in many ways,
to accomodate the specificities of your markup language backend.

* As an extension to Scribe semantics, all strings resulting from reading
 bracket-delimited text (as opposed to those resulting from "normal"
 double-quote delimited strings that may appear inside escape forms)
 may be preprocessed. There may be compile-time or run-time preprocessing.
 The variable *SCRIBBLE-PREPROCESS* decides what kind of preprocessing is
 done. If it is NIL, then no preprocessing is done (i.e. strings from the
 [...] notation will be read as such). If it is T, then run-time
 preprocessing is done, via the function PP which itself issues a dynamic
 call to the function *SCRIBBLE-PREPROCESSOR* if not NIL (or else behaves
 as identity). If it is a function or non-boolean symbol, then said value
 is funcall'ed at read-time to preprocess the string form by e.g. wrapping
 it into some macro evaluation. Note that when using run-time preprocessing,
 you may either lexically shadow the function PP or dynamically rebind the
 variable *SCRIBBLE-PREPROCESSOR* to locally select a different preprocessor.
 A macro SCRIBBLE:WITH-PREPROCESSOR is defined to do the dynamic rebinding,
 as in (scribble:with-preprocessor #'string-upcase [foo]) which (assuming
 run-time preprocessing is enabled) will evaluate to "FOO".

* Though the default behaviour of Scribble is to return
 a (possibly preprocessed) string if there are no subcomponents,
 and a form (cl:list ...) if there are multiple components,
 you can customize this behaviour by binding the customization variable
 scribble:*scribble-list* to a function that will do the job,
 taking as many arguments as there were components (zero for empty text).
 If you only want to keep the same general behaviour,
 but change the head of the resulting list from cl:list to something else,
 then don't modify scribble:*scribble-list*
 (or bind it back to scribble:default-scribble-list)
 and instead bind scribble:*scribble-default-head* to a symbol
 that at evaluation time will be bound to a function
 that will properly combine the multiple components.
 Note that this scribble:*scribble-list* is processed at read-time,
 whereas the function named by scribble:*scribble-default-head* (if applicable)
 will be processed at evaluation-time.

* You can select a package from which Scribble will read head forms
 of bracket-colon syntax [:head ...] or [:(head args) ...]
 by changing the symbol-value of scribble:*scribble-package*.
 Typical use is
	(setq scribbe:*scribble-package* :keyword)
 which will do wonders with AllegroServe's net.html.generator.
 Note that this feature happens at read-time, and doesn't affect
 the current package used to read escape forms.
 If the *scribble-package* feature prevents reading
 the arguments to structured head form arguments in the right package,
	[:(head form arguments) ...]
 then you can fall back to normal scribe syntax
	,(head form argument [...])
 or qualify the symbols in your head form by their package
	[:(cl:head my-package:form foo:arguments) ...]

* You can modify the way that scribble combines
 the head and body of bracket-colon syntax
 by changing the value of variable scribble:*scribble-cons*
 from the default value scribble:default-scribble-cons.
 The function takes as parameters the head specified by bracket-colon syntax
 and the list of components of the bracketed text, and has to return
 Typically, you might want to special case the behaviour
 according to the type of the head: cons or symbol.
 Note that this happens at read-time.

* Example functions to customize scribble for use with various backends
 are given at the end of this file. Check functions
	scribble:configure-scribble
	scribble:configure-scribble-for-araneida
	scribble:configure-scribble-for-htmlgen
	scribble:configure-scribble-for-lml2
	scribble:configure-scribble-for-tml
	scribble:configure-scribble-for-who
	scribble:configure-scribble-for-yaclml
 Please send me updates that include support for your favorite backend.

EXAMPLE USE:
(load "scribble")
(use-package :scribble)
(enable-scribble-syntax)
'[foo ,[:emph bar] ,[:(baz :size 1) quux ,(tata toto [\:titi])] tutu]
==>
(LIST (PP "foo ") (EMPH (PP "bar")) (PP " ")
 (BAZ :SIZE 1 (LIST (PP "quux ") (TATA TOTO (PP ":titi")))) (PP " tutu"))

(let ((p "/home/fare/fare/www/liberty/white_black_magic.scr")
      (eof '#:eof))
  (with-open-file (s p :direction :input :if-does-not-exist :error)
    (loop for i = (read s nil eof nil)
      until (eq i eof)
      collect i)))

(configure-scribble-for-araneida-html)
(html-stream *stdout* '[:html ...])

TODO:
* Make it work with aserve, who, and other backends.

Share and enjoy!


For historical information, see also Daniel Herring's partial implementation:
http://lists.libcl.com/pipermail/libcl-devel-libcl.com/2010-January/000094.html


NAMING NOTE

Eli Barzilay started using the name "Scribble" in 2006;
I started using it in 2003 or earlier for my Scribe-like syntax, now Skribe-like.


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

2 Systems

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


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

2.1 scribble

Author

Francois-Rene Rideau

License

MIT

Description

Syntax extensions akin to Racket’s Scribble and Bigloo’s Skribe

Long Description

Scribble offers two syntax extensions allowing you to very nicely
mix text markup data and Lisp code. One syntax is a port to CL of Racket’s Scribble syntax, and the other is a port to CL of Bigloo’s Skribe syntax.

Version

1.0.1.2

Dependencies
Source

scribble.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 scribble.asd

Location

scribble.asd

Systems

scribble (system)


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

3.1.2 scribble/package.lisp

Parent

scribble (system)

Location

package.lisp

Packages

scribble


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

3.1.3 scribble/utilities.lisp

Dependency

package.lisp (file)

Parent

scribble (system)

Location

utilities.lisp

Internal Definitions

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

3.1.4 scribble/stream-line-column.lisp

Dependency

package.lisp (file)

Parent

scribble (system)

Location

stream-line-column.lisp

Exported Definitions
Internal Definitions

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

3.1.5 scribble/racket.lisp

Dependency

utilities.lisp (file)

Parent

scribble (system)

Location

racket.lisp

Exported Definitions
Internal Definitions

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

3.1.6 scribble/skribe.lisp

Dependency

utilities.lisp (file)

Parent

scribble (system)

Location

skribe.lisp

Exported Definitions
Internal Definitions

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

3.1.7 scribble/readtables.lisp

Dependencies
Parent

scribble (system)

Location

readtables.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 scribble

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *scribble-cons*

Scribble customization parameter: you can change it so as to define what scribble returns from the head and body of text in bracket-colon syntax

Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-default-head*

Scribble customization parameter: assuming default scribble-list behavior, modify the head of the form returned to combine at runtime the multiple components of the bracketed text being parsed

Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-list*

Scribble customization parameter: you can change it so as to define what scribble returns from the list of components in parsed bracketed text

Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-package*

if not NIL, the package in which Scribble will read the head of text in bracket-colon syntax

Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-preprocess*

set this variable to NIL to disable Scribble wrapping of strings
into preprocessing forms, to T to enable run-time preprocessing, or to a symbol or function to enable compile-time preprocessing

Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-preprocessor*

run-time preprocessor of strings by Scribble. Used when *SCRIBBLE-PREPROCESS* is T.

Package

scribble

Source

skribe.lisp (file)


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

5.1.2 Macros

Macro: with-preprocessor PP &body BODY

Form to define local Scribble preprocessor

Package

scribble

Source

skribe.lisp (file)


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

5.1.3 Functions

Function: combine-column-modifiers UNALIGNED1 ALIGNED1 UNALIGNED2 ALIGNED2
Package

scribble

Source

stream-line-column.lisp (file)

Function: configure-scribble &key PREPROCESS PREPROCESSOR LIST DEFAULT-HEAD PACKAGE CONS
Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-araneida ()

This will make Scribble work with the patched version of araneida’s original html.lisp function that I used in CTO and that handles ’list correctly. Hopefully my patch will be integrated into the main upstream darcs repository.

Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-htmlgen ()

This is meant to make Scribble work with AllegroServe’s HTMLGEN from Franz, Inc. – a least if I read the spec correctly.

Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-lml2 ()

This makes Scribble work with LML2 by kmr, which is based on Franz’s HTMLGEN.

Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-tml ()

tml, previously known as htout, is tfeb’s package. This is a wild guess from reading the docs. Please modify to actually suit the package.

Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-who ()

WHO is an optimized html generation package by Edi Weitz. Its keyword semantics is very Scribe-like.
I wrote this reading the docs, but didn’t test it.

Package

scribble

Source

skribe.lisp (file)

Function: configure-scribble-for-yaclml ()

yaclml is yet another common lisp markup language. The author wrote this support, but didn’t test it.

Package

scribble

Source

skribe.lisp (file)

Function: default-scribble-cons HEAD BODY
Package

scribble

Source

skribe.lisp (file)

Function: default-scribble-list &rest LIST

Default behavior for returning components of bracketed text

Package

scribble

Source

skribe.lisp (file)

Function: disable-scribble-at-syntax ()
Package

scribble

Source

racket.lisp (file)

Function: disable-scribble-syntax ()
Package

scribble

Source

skribe.lisp (file)

Function: disable-sub-scribble-syntax ()
Package

scribble

Source

skribe.lisp (file)

Function: enable-scribble-at-syntax &key TABLE SCRIBE
Package

scribble

Source

racket.lisp (file)

Function: enable-scribble-syntax &optional READTABLE
Package

scribble

Source

skribe.lisp (file)

Function: enable-sub-scribble-syntax &optional READTABLE
Package

scribble

Source

skribe.lisp (file)

Function: pp X

Default preprocessing of Scribble strings: compile-time identity.
Globally, locally or lexically alter the binding of symbol-function scribble:pp in your macros so as to customize the behavior of preprocessing

Package

scribble

Source

skribe.lisp (file)

Function: read-stream-to-pos STREAM ENDPOS
Package

scribble

Source

stream-line-column.lisp (file)

Function: reenable-scribble-at-syntax &key SCRIBE
Package

scribble

Source

racket.lisp (file)

Function: reenable-scribble-syntax ()
Package

scribble

Source

skribe.lisp (file)

Function: reenable-sub-scribble-syntax ()
Package

scribble

Source

skribe.lisp (file)

Function: stream-line-column-harder STREAM
Package

scribble

Source

stream-line-column.lisp (file)

Function: string-column-modifier STRING

Return multiple values describing the effect of the string on column position. 1- whether there was a newline found, if no NIL, if yes its position in the string. 2- if no newline, whether there is a leading tab that further aligns the column. 3- the number of characters after newline and/or tab.

Package

scribble

Source

stream-line-column.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: $columns-per-tab
Package

scribble

Source

stream-line-column.lisp (file)

Special Variable: *lf*
Package

scribble

Source

utilities.lisp (file)

Special Variable: *saved-readtables*
Package

scribble

Source

skribe.lisp (file)

Special Variable: *scribble-at-readtable*
Package

scribble

Source

racket.lisp (file)

Special Variable: *scribble-readtable*
Package

scribble

Source

skribe.lisp (file)

Special Variable: *sub-scribble-readtable*
Package

scribble

Source

skribe.lisp (file)


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

5.2.2 Macros

Macro: within-package PACKAGE &body BODY

do stuff while binding *package* to package if not NIL at runtime

Package

scribble

Source

skribe.lisp (file)

Macro: within-scribble-package &body BODY
Package

scribble

Source

skribe.lisp (file)


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

5.2.3 Functions

Function: adjust-stream-forward-to-char STREAM
Package

scribble

Source

stream-line-column.lisp (file)

Function: ascii-punctuation-char-p X
Package

scribble

Source

utilities.lisp (file)

Function: do-enable-scribble-at-syntax &key TABLE SCRIBE SKRIBE
Package

scribble

Source

racket.lisp (file)

Function: do-enable-scribble-syntax &optional READTABLE
Package

scribble

Source

skribe.lisp (file)

Function: do-scribble-list &rest LIST

Combine components of bracketed text at runtime with *scribble-default-head*

Package

scribble

Source

skribe.lisp (file)

Function: expect-char INPUT &optional EXPECTATION
Package

scribble

Source

utilities.lisp (file)

Function: expect-string I S
Package

scribble

Source

utilities.lisp (file)

Function: expected-char-p C EXPECTATION
Package

scribble

Source

utilities.lisp (file)

Function: forbidden-pipe-macro STREAM CHAR
Package

scribble

Source

racket.lisp (file)

Function: mirror-char X
Package

scribble

Source

utilities.lisp (file)

Function: mirror-string X
Package

scribble

Source

utilities.lisp (file)

Function: n-spaces &rest ARGUMENTS
Package

scribble

Source

/home/quickref/quicklisp/dists/quicklisp/software/fare-memoization-20180430-git/memoization.lisp

Function: parse-at-string X
Package

scribble

Source

racket.lisp (file)

Function: parse-at-syntax INPUT
Package

scribble

Source

racket.lisp (file)

Function: parse-bracket STREAM &aux C S L
Package

scribble

Source

skribe.lisp (file)

Function: pop-readtable ()
Package

scribble

Source

skribe.lisp (file)

Function: push-readtable &optional READTABLE
Package

scribble

Source

skribe.lisp (file)

Function: read-at-syntax STREAM &optional CHAR
Package

scribble

Source

racket.lisp (file)

Function: read-paren-list STREAM OPENING
Package

scribble

Source

utilities.lisp (file)

Function: read-skribe-bracket STREAM CHAR
Package

scribble

Source

skribe.lisp (file)

Function: read-to-char C &optional I
Package

scribble

Source

utilities.lisp (file)

Function: scribble-cons HEAD BODY
Package

scribble

Source

skribe.lisp (file)

Function: scribble-cons-with-list-head HEAD BODY
Package

scribble

Source

skribe.lisp (file)

Function: scribble-list &rest LIST
Package

scribble

Source

skribe.lisp (file)

Function: scribble-preprocess S
Package

scribble

Source

skribe.lisp (file)

Function: simple-parse-error FORMAT &rest ARGUMENTS
Package

scribble

Source

utilities.lisp (file)

Function: skip-whitespace-return-column I &optional COL
Package

scribble

Source

utilities.lisp (file)

Function: to-next-tab POSITION &optional COLUMNS-PER-TAB
Package

scribble

Source

stream-line-column.lisp (file)

Function: trim-ending-spaces S
Package

scribble

Source

utilities.lisp (file)

Function: unbalanced-paren STREAM CHAR
Package

scribble

Source

utilities.lisp (file)

Function: unread-string INPUT STRING
Package

scribble

Source

utilities.lisp (file)


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

5.2.4 Generic functions

Generic Function: flush-buffer INPUT
Package

scribble

Source

utilities.lisp (file)

Methods
Method: flush-buffer (INPUT buffered-input)
Generic Function: input-buffer OBJECT
Package

scribble

Methods
Method: input-buffer (BUFFERED-INPUT buffered-input)

automatically generated reader method

Source

utilities.lisp (file)

Generic Function: input-stream OBJECT
Package

scribble

Methods
Method: input-stream (BUFFERED-INPUT buffered-input)

automatically generated reader method

Source

utilities.lisp (file)

Generic Function: peek-char* INPUT
Package

scribble

Source

utilities.lisp (file)

Methods
Method: peek-char* (INPUT buffered-input)
Method: peek-char* (INPUT stream)
Generic Function: read-char* INPUT
Package

scribble

Source

utilities.lisp (file)

Methods
Method: read-char* (INPUT buffered-input)
Method: read-char* (INPUT stream)
Generic Function: unread-char* INPUT CHAR
Package

scribble

Source

utilities.lisp (file)

Methods
Method: unread-char* (INPUT buffered-input) CHAR
Method: unread-char* (INPUT stream) CHAR

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

5.2.5 Conditions

Condition: simple-parse-error ()
Package

scribble

Source

utilities.lisp (file)

Direct superclasses
  • parse-error (condition)
  • simple-error (condition)

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

5.2.6 Classes

Class: buffered-input ()
Package

scribble

Source

utilities.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: stream
Type

stream

Initargs

:stream

Readers

input-stream (generic function)

Slot: buffer
Initform

(make-array (quote (16)) :element-type (quote character) :adjustable t :fill-pointer 0)

Readers

input-buffer (generic function)


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

5.2.7 Types

Type: spacing-character ()

spacing character

Package

scribble

Source

skribe.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   S  
Index Entry  Section

F
File, Lisp, scribble.asd: The scribble<dot>asd file
File, Lisp, scribble/package.lisp: The scribble/package<dot>lisp file
File, Lisp, scribble/racket.lisp: The scribble/racket<dot>lisp file
File, Lisp, scribble/readtables.lisp: The scribble/readtables<dot>lisp file
File, Lisp, scribble/skribe.lisp: The scribble/skribe<dot>lisp file
File, Lisp, scribble/stream-line-column.lisp: The scribble/stream-line-column<dot>lisp file
File, Lisp, scribble/utilities.lisp: The scribble/utilities<dot>lisp file

L
Lisp File, scribble.asd: The scribble<dot>asd file
Lisp File, scribble/package.lisp: The scribble/package<dot>lisp file
Lisp File, scribble/racket.lisp: The scribble/racket<dot>lisp file
Lisp File, scribble/readtables.lisp: The scribble/readtables<dot>lisp file
Lisp File, scribble/skribe.lisp: The scribble/skribe<dot>lisp file
Lisp File, scribble/stream-line-column.lisp: The scribble/stream-line-column<dot>lisp file
Lisp File, scribble/utilities.lisp: The scribble/utilities<dot>lisp file

S
scribble.asd: The scribble<dot>asd file
scribble/package.lisp: The scribble/package<dot>lisp file
scribble/racket.lisp: The scribble/racket<dot>lisp file
scribble/readtables.lisp: The scribble/readtables<dot>lisp file
scribble/skribe.lisp: The scribble/skribe<dot>lisp file
scribble/stream-line-column.lisp: The scribble/stream-line-column<dot>lisp file
scribble/utilities.lisp: The scribble/utilities<dot>lisp file

Jump to:   F   L   S  

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

A.2 Functions

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

A
adjust-stream-forward-to-char: Internal functions
ascii-punctuation-char-p: Internal functions

C
combine-column-modifiers: Exported functions
configure-scribble: Exported functions
configure-scribble-for-araneida: Exported functions
configure-scribble-for-htmlgen: Exported functions
configure-scribble-for-lml2: Exported functions
configure-scribble-for-tml: Exported functions
configure-scribble-for-who: Exported functions
configure-scribble-for-yaclml: Exported functions

D
default-scribble-cons: Exported functions
default-scribble-list: Exported functions
disable-scribble-at-syntax: Exported functions
disable-scribble-syntax: Exported functions
disable-sub-scribble-syntax: Exported functions
do-enable-scribble-at-syntax: Internal functions
do-enable-scribble-syntax: Internal functions
do-scribble-list: Internal functions

E
enable-scribble-at-syntax: Exported functions
enable-scribble-syntax: Exported functions
enable-sub-scribble-syntax: Exported functions
expect-char: Internal functions
expect-string: Internal functions
expected-char-p: Internal functions

F
flush-buffer: Internal generic functions
flush-buffer: Internal generic functions
forbidden-pipe-macro: Internal functions
Function, adjust-stream-forward-to-char: Internal functions
Function, ascii-punctuation-char-p: Internal functions
Function, combine-column-modifiers: Exported functions
Function, configure-scribble: Exported functions
Function, configure-scribble-for-araneida: Exported functions
Function, configure-scribble-for-htmlgen: Exported functions
Function, configure-scribble-for-lml2: Exported functions
Function, configure-scribble-for-tml: Exported functions
Function, configure-scribble-for-who: Exported functions
Function, configure-scribble-for-yaclml: Exported functions
Function, default-scribble-cons: Exported functions
Function, default-scribble-list: Exported functions
Function, disable-scribble-at-syntax: Exported functions
Function, disable-scribble-syntax: Exported functions
Function, disable-sub-scribble-syntax: Exported functions
Function, do-enable-scribble-at-syntax: Internal functions
Function, do-enable-scribble-syntax: Internal functions
Function, do-scribble-list: Internal functions
Function, enable-scribble-at-syntax: Exported functions
Function, enable-scribble-syntax: Exported functions
Function, enable-sub-scribble-syntax: Exported functions
Function, expect-char: Internal functions
Function, expect-string: Internal functions
Function, expected-char-p: Internal functions
Function, forbidden-pipe-macro: Internal functions
Function, mirror-char: Internal functions
Function, mirror-string: Internal functions
Function, n-spaces: Internal functions
Function, parse-at-string: Internal functions
Function, parse-at-syntax: Internal functions
Function, parse-bracket: Internal functions
Function, pop-readtable: Internal functions
Function, pp: Exported functions
Function, push-readtable: Internal functions
Function, read-at-syntax: Internal functions
Function, read-paren-list: Internal functions
Function, read-skribe-bracket: Internal functions
Function, read-stream-to-pos: Exported functions
Function, read-to-char: Internal functions
Function, reenable-scribble-at-syntax: Exported functions
Function, reenable-scribble-syntax: Exported functions
Function, reenable-sub-scribble-syntax: Exported functions
Function, scribble-cons: Internal functions
Function, scribble-cons-with-list-head: Internal functions
Function, scribble-list: Internal functions
Function, scribble-preprocess: Internal functions
Function, simple-parse-error: Internal functions
Function, skip-whitespace-return-column: Internal functions
Function, stream-line-column-harder: Exported functions
Function, string-column-modifier: Exported functions
Function, to-next-tab: Internal functions
Function, trim-ending-spaces: Internal functions
Function, unbalanced-paren: Internal functions
Function, unread-string: Internal functions

G
Generic Function, flush-buffer: Internal generic functions
Generic Function, input-buffer: Internal generic functions
Generic Function, input-stream: Internal generic functions
Generic Function, peek-char*: Internal generic functions
Generic Function, read-char*: Internal generic functions
Generic Function, unread-char*: Internal generic functions

I
input-buffer: Internal generic functions
input-buffer: Internal generic functions
input-stream: Internal generic functions
input-stream: Internal generic functions

M
Macro, with-preprocessor: Exported macros
Macro, within-package: Internal macros
Macro, within-scribble-package: Internal macros
Method, flush-buffer: Internal generic functions
Method, input-buffer: Internal generic functions
Method, input-stream: Internal generic functions
Method, peek-char*: Internal generic functions
Method, peek-char*: Internal generic functions
Method, read-char*: Internal generic functions
Method, read-char*: Internal generic functions
Method, unread-char*: Internal generic functions
Method, unread-char*: Internal generic functions
mirror-char: Internal functions
mirror-string: Internal functions

N
n-spaces: Internal functions

P
parse-at-string: Internal functions
parse-at-syntax: Internal functions
parse-bracket: Internal functions
peek-char*: Internal generic functions
peek-char*: Internal generic functions
peek-char*: Internal generic functions
pop-readtable: Internal functions
pp: Exported functions
push-readtable: Internal functions

R
read-at-syntax: Internal functions
read-char*: Internal generic functions
read-char*: Internal generic functions
read-char*: Internal generic functions
read-paren-list: Internal functions
read-skribe-bracket: Internal functions
read-stream-to-pos: Exported functions
read-to-char: Internal functions
reenable-scribble-at-syntax: Exported functions
reenable-scribble-syntax: Exported functions
reenable-sub-scribble-syntax: Exported functions

S
scribble-cons: Internal functions
scribble-cons-with-list-head: Internal functions
scribble-list: Internal functions
scribble-preprocess: Internal functions
simple-parse-error: Internal functions
skip-whitespace-return-column: Internal functions
stream-line-column-harder: Exported functions
string-column-modifier: Exported functions

T
to-next-tab: Internal functions
trim-ending-spaces: Internal functions

U
unbalanced-paren: Internal functions
unread-char*: Internal generic functions
unread-char*: Internal generic functions
unread-char*: Internal generic functions
unread-string: Internal functions

W
with-preprocessor: Exported macros
within-package: Internal macros
within-scribble-package: Internal macros

Jump to:   A   C   D   E   F   G   I   M   N   P   R   S   T   U   W  

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

A.3 Variables

Jump to:   $   *  
B   S  
Index Entry  Section

$
$columns-per-tab: Internal special variables

*
*lf*: Internal special variables
*saved-readtables*: Internal special variables
*scribble-at-readtable*: Internal special variables
*scribble-cons*: Exported special variables
*scribble-default-head*: Exported special variables
*scribble-list*: Exported special variables
*scribble-package*: Exported special variables
*scribble-preprocess*: Exported special variables
*scribble-preprocessor*: Exported special variables
*scribble-readtable*: Internal special variables
*sub-scribble-readtable*: Internal special variables

B
buffer: Internal classes

S
Slot, buffer: Internal classes
Slot, stream: Internal classes
Special Variable, $columns-per-tab: Internal special variables
Special Variable, *lf*: Internal special variables
Special Variable, *saved-readtables*: Internal special variables
Special Variable, *scribble-at-readtable*: Internal special variables
Special Variable, *scribble-cons*: Exported special variables
Special Variable, *scribble-default-head*: Exported special variables
Special Variable, *scribble-list*: Exported special variables
Special Variable, *scribble-package*: Exported special variables
Special Variable, *scribble-preprocess*: Exported special variables
Special Variable, *scribble-preprocessor*: Exported special variables
Special Variable, *scribble-readtable*: Internal special variables
Special Variable, *sub-scribble-readtable*: Internal special variables
stream: Internal classes

Jump to:   $   *  
B   S  

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

A.4 Data types

Jump to:   B   C   P   S   T  
Index Entry  Section

B
buffered-input: Internal classes

C
Class, buffered-input: Internal classes
Condition, simple-parse-error: Internal conditions

P
Package, scribble: The scribble package

S
scribble: The scribble system
scribble: The scribble package
simple-parse-error: Internal conditions
spacing-character: Internal types
System, scribble: The scribble system

T
Type, spacing-character: Internal types

Jump to:   B   C   P   S   T