Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the closure-common Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:15:34 2022 GMT+0.
Next: Systems, Previous: The closure-common Reference Manual, Up: The closure-common Reference Manual [Contents][Index]
This is a fork of Gilbert Baumann's closure-common library, originally found here: http://www.cliki.net/closure-common
The source hadn't been updated in a while and it doesn't seem that Gilbert Baumann or David Lichteblau is actively maintaing the project. Hence, this fork.
Next: Files, Previous: Introduction, Up: The closure-common Reference Manual [Contents][Index]
The main system appears first, followed by any subsystem dependency.
Next: Packages, Previous: Systems, Up: The closure-common Reference Manual [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
Next: closure-common/package.lisp, Previous: Lisp, Up: Lisp [Contents][Index]
closure-common (system).
closure-source-file (class).
Next: closure-common/definline.lisp, Previous: closure-common/closure-common.asd, Up: Lisp [Contents][Index]
closure-common (system).
Next: closure-common/runes.lisp, Previous: closure-common/package.lisp, Up: Lisp [Contents][Index]
package.lisp (file).
closure-common (system).
definline (macro).
Next: closure-common/syntax.lisp, Previous: closure-common/definline.lisp, Up: Lisp [Contents][Index]
definline.lisp (file).
closure-common (system).
Next: closure-common/encodings.lisp, Previous: closure-common/runes.lisp, Up: Lisp [Contents][Index]
runes.lisp (file).
closure-common (system).
Next: closure-common/encodings-data.lisp, Previous: closure-common/syntax.lisp, Up: Lisp [Contents][Index]
syntax.lisp (file).
closure-common (system).
Next: closure-common/xstream.lisp, Previous: closure-common/encodings.lisp, Up: Lisp [Contents][Index]
encodings.lisp (file).
closure-common (system).
Next: closure-common/ystream.lisp, Previous: closure-common/encodings-data.lisp, Up: Lisp [Contents][Index]
encodings-data.lisp (file).
closure-common (system).
Next: closure-common/hax.lisp, Previous: closure-common/xstream.lisp, Up: Lisp [Contents][Index]
xstream.lisp (file).
closure-common (system).
Previous: closure-common/ystream.lisp, Up: Lisp [Contents][Index]
ystream.lisp (file).
closure-common (system).
hax.
%rod= (function).
Next: Definitions, Previous: Files, Up: The closure-common Reference Manual [Contents][Index]
Packages are listed by definition order.
common-lisp.
Next: closure-common-system, Previous: utf8-runes, Up: Packages [Contents][Index]
*utf8-runes-readtable* (special variable).
closure-source-file (class).
Next: runes-encoding, Previous: closure-common-system, Up: Packages [Contents][Index]
An event protocol for HTML serialization, this package is similar
to the SAX protocol defined by cxml for XML serialization.
(Technically, this package should have been spelled SAH, but HAX
sounds better.)
Note that Closure HTML is not a streaming parser yet. Documents
are always parsed in full before the first HAX event is emitted.
In spite of this restriction, the HAX API is useful for HTML
serialization and transformation purposes, and for integration
with SAX.
@begin[HAX handlers]{section}
@aboutclass{abstract-handler}
@aboutclass{default-handler}
@end{section}
@begin[The attribute protocol]{section}
@aboutclass{standard-attribute}
@aboutfun{make-attribute}
@aboutfun{attribute-name}
@aboutfun{attribute-value}
@aboutfun{attribute-specified-p}
@end{section}
@begin[HAX events]{section}
@aboutfun{start-document}
@aboutfun{start-element}
@aboutfun{end-element}
@aboutfun{characters}
@aboutfun{unescaped}
@aboutfun{comment}
@aboutfun{end-document}
@end{section}
common-lisp.
%rod= (function).
Next: Indexes, Previous: Packages, Up: The closure-common Reference Manual [Contents][Index]
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Macros, Previous: Public Interface, Up: Public Interface [Contents][Index]
Next: Ordinary functions, Previous: Special variables, Up: Public Interface [Contents][Index]
Like READ-RUNE, but does not actually return the read rune.
Peek a single rune off the xstream ‘input’. In case of end of file :EOF is returned.
Read a single rune off the xstream ‘input’. In case of end of file :EOF is returned.
Next: Generic functions, Previous: Macros, Up: Public Interface [Contents][Index]
@arg[name]{a string/rod}
@arg[attrs]{a list of attributes}
@return{an attribute, or nil}
@short{Searches for an attribute by name.}
Returns the first attribute in @var{attrs} with the specified name,
or @code{nil} if no such attribute was found.
@see{attribute-name}
@arg[name]{a string/rod}
@arg[value]{a string/rod}
@arg[specified-p]{a boolean, default is @code{t}}
@return{an instance of @class{standard-attribute}.}
@short{Creates a HAX attribute.}
Creates an instance that can be used with the generic functions
for HAX attributes. The result can be passed to
@fun{hax:start-element} in the list of attributes.
@see{attribute-name}
@see{attribute-value}
@see{attribute-specified-p}
Unread the last recently read rune; if there wasn’t such a rune, you deserve to lose.
name.
Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
@arg[instance]{any class implementing this function}
@return{a string/rod}
@short{Return an attribute’s name.}
Instances of this classes implementing this function can be passed to
@fun{hax:start-element} in the list of attributes.
@see{attribute-value}
@see{attribute-specified-p}
hax.
automatically generated reader method
name.
hax.
automatically generated writer method
@arg[instance]{any class implementing this function}
@return{a string/rod}
@short{Return whether the attribute was contained the parsed document.}
Attributes return @code{nil} here if they resulted from a default
value declaration in a DTD.
Instances of this classes implementing this function can be passed to
@fun{hax:start-element} in the list of attributes.
@see{attribute-name}
@see{attribute-value}
hax.
automatically generated reader method
hax.
automatically generated writer method
@arg[instance]{any class implementing this function}
@return{a string/rod}
@short{Return an attribute’s value.}
Instances of this classes implementing this function can be passed to
@fun{hax:start-element} in the list of attributes.
@see{attribute-name}
@see{attribute-specified-p}
hax.
automatically generated reader method
hax.
automatically generated writer method
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[data]{rod/string}
@return{unspecified}
@short{Signals character data.}
This event represents character data in a document.
@see{start-document}
@see{start-element}
@see{end-element}
@see{comment}
@see{end-document}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[data]{rod/string}
@return{unspecified}
@short{Signals a comment.}
This event represents a comment.
@see{start-document}
@see{start-element}
@see{end-element}
@see{characters}
@see{unescaped}
@see{end-document}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@return{The return value of this function depends on the handler class.}
@short{Signals the end of an HTML document.}
This is the last event sent to any handler, and signals the end of
serialization.
The return value of this function is usually returned to user code
by higher-level serialization functions and can be considered the
result of serialization and "return value" of the handler.
@see{start-document}
@see{start-element}
@see{end-element}
@see{characters}
@see{unescaped}
@see{comment}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[name]{root element name, a rod/string}
@return{unspecified}
@short{Signals the end of an HTML element.}
This event corresponds to the closing tag of an element.
@see{start-document}
@see{start-element}
@see{characters}
@see{unescaped}
@see{comment}
@see{end-document}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[name]{root element name, a rod/string}
@arg[public-id]{nil or the Public ID, a rod/string}
@arg[system-id]{nil or the System ID/URI, a rod/string}
@return{unspecified}
@short{Signals the beginning of an HTML document.}
This is the first event sent to any handler.
If @var{system-id} is non-nil, the document includes a doctype
declaration.
@see{start-element}
@see{end-element}
@see{characters}
@see{unescaped}
@see{comment}
@see{end-document}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[name]{root element name, a rod/string}
@arg[attributes]{a list of attributes}
@return{unspecified}
@short{Signals the beginning of an HTML element.}
This event corresponds to the opening tag of an element.
Elements of the attribute list can have any class, but must implement
the generic functions for attributes. See @class{standard-attribute}
for the built-in attribute implementation.
@see{find-attribute}
@see{start-document}
@see{end-element}
@see{characters}
@see{unescaped}
@see{comment}
@see{end-document}
hax.
@arg[handler]{a HAX/SAX handler
(see @class{abstract-handler} for details)}
@arg[data]{rod/string}
@return{unspecified}
@short{Escaping bypass.}
This event writes raw characters into a document.
Beware dragons.
@see{start-document}
@see{start-element}
@see{end-element}
@see{comment}
@see{end-document}
hax.
Next: Conditions, Previous: Generic functions, Up: Public Interface [Contents][Index]
asdf/action.
sb-gray.
trivial-gray-streams.
Next: Structures, Previous: Standalone methods, Up: Public Interface [Contents][Index]
simple-error.
Next: Classes, Previous: Conditions, Up: Public Interface [Contents][Index]
structure-object.
(simple-array runes::buffer-byte (*))
runes::+null-buffer+
runes::buffer-index
0
runes::buffer-index
0
(simple-array runes::octet (*))
runes::+null-octet-buffer+
runes::buffer-index
0
runes::buffer-index
0
common-lisp.
runes::buffer-index
0
runes::buffer-index
0
:utf-8
integer
1
integer
0
integer
0
structure-object.
integer
0
fixnum
0
runes:simple-rod
(runes:make-rod runes::+ystream-bufsize+)
Next: Types, Previous: Structures, Up: Public Interface [Contents][Index]
@short{The superclass of all HAX handlers.}
Direct subclasses have to implement all event methods, since
no default methods are defined on this class.
Note that it is permissible to use handlers that are not
instances of this class in some circumstances.
In particular,
@code{nil} is a valid HAX handler and ignores all events.
In addition,
@a[http://common-lisp.net/project/cxml/sax.html#sax]{SAX handlers}
are valid HAX handlers (and vice versa), even though
hax:abstract-handler and sax:abstract-handler do not
share a specific superclass. HAX events sent to SAX handlers are
automatically re-signalled as XHTML SAX events, and SAX events sent
to HAX handlers are re-signalled as namespace-less HAX events.
However, user code should define subclasses of the documented
superclasses to enable the HAX/SAX bridging described above.
@see{chtml:parse}
@see{chtml:serialize-lhtml}
@see{chtml:serialize-pt}
@see{start-document}
@see{end-document}
@see{start-element}
@see{end-element}
@see{characters}
@see{unescaped}
@see{comment}
hax.
@short{A no-op HAX handler.}
This class defines methods for all HAX events that do nothing.
It is useful as a superclass when implementing a HAX handler that
is interested in only some events and not others.
@see{chtml:parse}
@see{chtml:serialize-lhtml}
@see{chtml:serialize-pt}
@see{start-document}
@see{end-document}
@see{start-element}
@see{end-element}
@see{characters}
@see{unescaped}
@see{comment}
hax.
@short{An implementation of the HAX attribute protocol.}
A standard class implementing the generic functions for HAX
attributes. Instances of this class can be passed to
@fun{hax:start-element} in the list of attributes.
@see-slot{attribute-name} @see-slot{attribute-value} @see-slot{attribute-specified-p} @see-constructor{make-instance}
Previous: Public Interface, Up: Definitions [Contents][Index]
Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]
Special marker inserted into stream buffers to indicate end of buffered data.
Hashtable, which maps all known rune names to rune codes; Names are stored in uppercase.
Next: Ordinary functions, Previous: Special variables, Up: Internals [Contents][Index]
Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]
Next: Structures, Previous: Ordinary functions, Up: Internals [Contents][Index]
automatically generated reader method
Next: Classes, Previous: Generic functions, Up: Internals [Contents][Index]
(simple-array (unsigned-byte 8) (*))
(runes::make-ub8-array (* 6 runes::+ystream-bufsize+))
(runes::make-buffer)
(make-string-output-stream)
Next: Types, Previous: Structures, Up: Internals [Contents][Index]
cl-source-file.
:table
Previous: Definitions, Up: The closure-common Reference Manual [Contents][Index]
| Jump to: | %
(
A C D E F G I L M O P R S T U W X Y |
|---|
| Jump to: | %
(
A C D E F G I L M O P R S T U W X Y |
|---|
Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]
| Jump to: | *
+
B C E F I L N O P R S T V |
|---|
| Jump to: | *
+
B C E F I L N O P R S T V |
|---|
| Jump to: | %
8
A B C D E F H O P R S T U X Y |
|---|
| Jump to: | %
8
A B C D E F H O P R S T U X Y |
|---|