The cxml Reference Manual

Table of Contents

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

The cxml Reference Manual

This is the cxml Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:47:04 2018 GMT+0.


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

1 Introduction


Closure XML Parser

   An XML parser written in Common Lisp.

   Closure XML was written by Gilbert Baumann (unk6 at
   rz.uni-karlsruhe.de) as part of the Closure web browser.

   Contributions to the parser by
     * Henrik Motakef (hmot at henrik-motakef.de)
     * David Lichteblau (david@lichteblau.com)

   CXML implements a namespace-aware, validating XML 1.0 parser
   as well as the DOM Level 2 Core interfaces. Two parser interfaces
   are offered, one SAX-like, the other similar to StAX.

   CXML is licensed under Lisp-LGPL.

   Send bug reports to cxml-devel@common-lisp.net
   (http://common-lisp.net/cgi-bin/mailman/listinfo/cxml-devel)


Documentation

   Please refer to http://common-lisp.net/project/cxml/ for details.

   The documentation is also available in the doc/ subdirectory of this
   source distribution, run `make' in that directory to build HTML
   for the XML sources (requires xsltproc).


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

2 Systems

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


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

2.1 cxml

Dependencies
Source

cxml.asd (file)


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

2.2 cxml-test

Dependencies
Source

cxml.asd (file)

Components

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

2.3 cxml-klacks

Dependency

cxml-xml (system)

Source

cxml.asd (file)

Components

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

2.4 cxml-dom

Dependency

cxml-xml (system)

Source

cxml.asd (file)

Components

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

2.5 cxml-xml

Dependencies
Source

cxml.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 cxml.asd

Location

cxml.asd

Systems
Packages

cxml-system

Internal Definitions

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

3.1.2 cxml-test/domtest.lisp

Parent

cxml-test (system)

Location

test/domtest.lisp

Packages
Exported Definitions

run-all-tests (function)

Internal Definitions

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

3.1.3 cxml-test/xmlconf.lisp

Parent

cxml-test (system)

Location

test/xmlconf.lisp

Packages

xmlconf

Exported Definitions

run-all-tests (function)

Internal Definitions

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

3.1.4 cxml-klacks/package.lisp

Parent

cxml-klacks (system)

Location

klacks/package.lisp

Packages

klacks


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

3.1.5 cxml-klacks/klacks.lisp

Dependency

package.lisp (file)

Parent

cxml-klacks (system)

Location

klacks/klacks.lisp

Exported Definitions
Internal Definitions

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

3.1.6 cxml-klacks/klacks-impl.lisp

Dependency

klacks.lisp (file)

Parent

cxml-klacks (system)

Location

klacks/klacks-impl.lisp

Exported Definitions
Internal Definitions

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

3.1.7 cxml-klacks/tap-source.lisp

Dependency

klacks-impl.lisp (file)

Parent

cxml-klacks (system)

Location

klacks/tap-source.lisp

Exported Definitions
Internal Definitions

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

3.1.8 cxml-dom/package.lisp

Parent

cxml-dom (system)

Location

dom/package.lisp

Packages

dom

Exported Definitions

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

3.1.9 cxml-dom/rune-impl.lisp

Dependency

package.lisp (file)

Parent

cxml-dom (system)

Location

dom/dom-impl.lisp

Packages

rune-dom

Exported Definitions
Internal Definitions

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

3.1.10 cxml-dom/rune-builder.lisp

Dependency

rune-impl.lisp (file)

Parent

cxml-dom (system)

Location

dom/dom-builder.lisp

Exported Definitions
Internal Definitions

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

3.1.11 cxml-dom/dom-sax.lisp

Dependency

package.lisp (file)

Parent

cxml-dom (system)

Location

dom/dom-sax.lisp

Exported Definitions

map-document (function)

Internal Definitions

compute-attributes (function)


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

3.1.12 cxml-xml/package.lisp

Parent

cxml-xml (system)

Location

xml/package.lisp

Packages

cxml


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

3.1.13 cxml-xml/util.lisp

Dependency

package.lisp (file)

Parent

cxml-xml (system)

Location

xml/util.lisp

Internal Definitions

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

3.1.14 cxml-xml/sax-handler.lisp

Parent

cxml-xml (system)

Location

xml/sax-handler.lisp

Packages

sax

Exported Definitions
Internal Definitions

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

3.1.15 cxml-xml/xml-name-rune-p.lisp

Dependencies
Parent

cxml-xml (system)

Location

xml/xml-name-rune-p.lisp

Internal Definitions

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

3.1.16 cxml-xml/split-sequence.lisp

Dependency

package.lisp (file)

Parent

cxml-xml (system)

Location

xml/split-sequence.lisp

Internal Definitions

split-sequence-if (function)


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

3.1.17 cxml-xml/xml-parse.lisp

Dependencies
Parent

cxml-xml (system)

Location

xml/xml-parse.lisp

Exported Definitions
Internal Definitions

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

3.1.18 cxml-xml/unparse.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/unparse.lisp

Exported Definitions
Internal Definitions

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

3.1.19 cxml-xml/xmls-compat.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/xmls-compat.lisp

Packages

cxml-xmls

Exported Definitions
Internal Definitions

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

3.1.20 cxml-xml/recoder.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/recoder.lisp

Exported Definitions
Internal Definitions

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

3.1.21 cxml-xml/xmlns-normalizer.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/xmlns-normalizer.lisp

Exported Definitions
Internal Definitions

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

3.1.22 cxml-xml/space-normalizer.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/space-normalizer.lisp

Exported Definitions
Internal Definitions

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

3.1.23 cxml-xml/catalog.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/catalog.lisp

Exported Definitions
Internal Definitions

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

3.1.24 cxml-xml/sax-proxy.lisp

Dependency

xml-parse.lisp (file)

Parent

cxml-xml (system)

Location

xml/sax-proxy.lisp

Exported Definitions
Internal Definitions

dtd (method)


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

3.1.25 cxml-xml/atdoc-configuration.lisp

Dependency

package.lisp (file)

Parent

cxml-xml (system)

Location

xml/atdoc-configuration.lisp

Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 domtest-tests

Source

domtest.lisp (file)


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

4.2 domtest

Source

domtest.lisp (file)

Use List
Exported Definitions

run-all-tests (function)

Internal Definitions

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

4.3 xmlconf

Source

xmlconf.lisp (file)

Use List
Exported Definitions

run-all-tests (function)

Internal Definitions

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

4.4 klacks

Source

package.lisp (file)

Exported Definitions

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

4.5 dom

Source

package.lisp (file)

Exported Definitions
Internal Definitions

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

4.6 rune-dom

Source

rune-impl.lisp (file)

Nickname

cxml-dom

Use List
Exported Definitions
Internal Definitions

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

4.7 cxml-system

Source

cxml.asd

Use List
Internal Definitions

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

4.8 cxml

Source

package.lisp (file)

Use List
Used By List

domtest

Exported Definitions
Internal Definitions

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

4.9 sax

Source

sax-handler.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

4.10 cxml-xmls

Source

xmls-compat.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: *cache-all-dtds*
Package

cxml

Source

xml-parse.lisp (file)

Special Variable: *catalog*
Package

cxml

Source

xml-parse.lisp (file)

Special Variable: *dtd-cache*
Package

cxml

Source

xml-parse.lisp (file)

Special Variable: *include-xmlns-attributes*

If non-nil, namespace declarations are reported as normal attributes.

This variable has no effect unless ‘*namespace-processing*’ is non-nil.

See also ‘*use-xmlns-namespace*’, and ‘start-element’ for a detailed description of the consequences of setting this variable.

Package

sax

Source

sax-handler.lisp (file)

Special Variable: *namespace-processing*

If non-nil (the default), namespace processing is enabled.

See also ‘start-element’ and ‘end-element’ for a detailed description of the consequences of modifying this variable, and ‘*include-xmlns-attributes*’ and ‘*use-xmlns-namespace*’ for further related options.

Package

sax

Source

sax-handler.lisp (file)

Special Variable: *prefer*
Package

cxml

Source

catalog.lisp (file)

Special Variable: *use-xmlns-namespace*

If this variable is nil (the default), attributes with a name like ’xmlns:x’ are not considered to be in a namespace, following the ’Namespaces in XML’ specification.

If it is non-nil, such attributes are considered to be in a namespace with the URI ’http://www.w3.org/2000/xmlns/’, following an incompatible change silently introduced in the errata to that spec, and adopted by some W3C standards.

For example, an attribute like xmlns:ex=’http://example.com’ would be reported like this:

*use-xmlns-namespace*: nil
namespace-uri: nil
local-name: nil
qname: #"xmlns:ex"

*use-xmlns-namespace*: t
namespace-uri: #"http://www.w3.org/2000/xmlns/" local-name: #"ex"
qname: #"xmlns:ex"

Setting this variable has no effect unless both ‘*namespace-processing*’ and ‘*include-xmlns-attributes*’ are non-nil.

Package

sax

Source

sax-handler.lisp (file)


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

5.1.2 Macros

Macro: do-node-list (VAR NODELIST &optional RESULTFORM) &body BODY
Package

dom

Source

rune-impl.lisp (file)

Macro: do-node-map (VAR NODE-MAP &optional RESULTFORM) &body BODY
Package

dom

Source

rune-impl.lisp (file)

Macro: expecting-element (SOURCE &optional LNAME URI) &body BODY
Package

klacks

Source

klacks.lisp (file)

Macro: with-element QNAME &body BODY

@arg[qname]{A string, evaluated.}
@arg[body]{forms, an implicit progn}
@return{The result of @code{body}.}

Writes an element to the current output sink.

This macro is a convenience wrapper around @fun{with-element*}.

@var{qname} is parsed to determine the element’s namespace prefix and local name. Then @fun{with-element*} is called on @var{body} using the resulting values.

Package

cxml

Source

unparse.lisp (file)

Macro: with-element* (PREFIX LNAME) &body BODY

@arg[prefix]{Namespace prefix, a string (evaluated).} @arg[lname]{Local name, a string (evaluated).}
@arg[body]{forms, an implicit progn}
@return{The result of @code{body}.}

Writes an element to the current output sink.

First, @var{prefix} is resolved to a namespace URI using the bindings established by @fun{with-namespace}.

Next, body is evaluated as an implicit progn. During this time, attributes for the element can be specified using @fun{attribute}.

Once information on the start tag is complete, @fun{start-element} on the current output sink, using the specified namespace prefix and local name specified by the arguments, the namespace URI computed as described above,and including all attributes collected so far.

Information on the start tag is considered complete once the first of the following situations occurs:
@begin{itemize}
@item{Before any child node of the element is written, e.g. using an inner call of @fun{with-element},}
@item{Before the body of @fun{with-ouptut-sink} is evaluated.} @item{After the end of @var{body} has been reached.} @end{itemize}

Finally, sax:end-element is used to write an end tag, using the same qualified name and namespace information as above.

Package

cxml

Source

unparse.lisp (file)

Macro: with-namespace (PREFIX URI) &body BODY

@arg[prefix]{Namespace prefix, a string (evaluated).} @arg[uri]{Namespace URI, a string (evaluated).}
@arg[body]{forms, an implicit progn}
@return{The result of @code{body}.}

Registers @code{prefix} as a name for the namespace URI @code{uri} for the extent of body.

Namespace bindings established by @code{with-namespace} are used by @fun{with-element} and @fun{with-element*} as well as @fun{attribute} and @fun{attribute*}.

Package

cxml

Source

unparse.lisp (file)

Macro: with-open-source (VAR SOURCE) &body BODY
Package

klacks

Source

klacks.lisp (file)

Macro: with-output-sink (VAR) &body BODY

@arg[var]{A symbol, not evaluated.}
@arg[body]{forms, an implicit progn}
@return{The result of @code{body}.}

Allows safe use of manual calls to SAX functions during the extent of @fun{with-xml-output},

Determines the current output sink established by @fun{with-xml-output}, as used by convenience serialization functions. Writes delayed serialization events to the sink. Binds local variable @code{var} to the sink and evaluates @code{body} as an implicit progn.

The consequences are undefined if this macro is used outside of the extent of a call to @fun{with-xml-output}.

See @fun{with-xml-output} for details on delayed events.

Package

cxml

Source

unparse.lisp (file)

Macro: with-xml-output SINK &body BODY

@arg[sink]{A @class{SAX handler}, evaluated}
@arg[body]{forms}
@return{The result of calling @code{sax:end-document} on @code{sink}.}
Evaluates sink and establishes it as the current output sink for the following "convenience serialization" macros and functions: @fun{with-element}, @fun{with-namespace}, @fun{doctype}, @fun{with-element*}, @fun{attribute}, @fun{attribute*}, @fun{text} @fun{comment}, @fun{processing-instruction}, @fun{unescaped}.

Before @code{body} is evaluated, @fun{sax:start-document} is signalled to the @code{sink}. Afterwards, @fun{sax:end-document} is signalled.

Note that convenience serialization delays some serialization events. For example, @fun{with-element} delays signalling an opening tag using @fun{sax:start-element} until it has information about all possible attributes of the element. Because of this delay, it is not usually safe to signal SAX events to the sink during the extent of @code{with-xml-output}. However, @fun{with-output-sink} can be used to force output of delayed events, allowing direct use of the sink.

Example:
@pre{(with-xml-output (make-octet-stream-sink stream) (with-element "foo"
(attribute "xyz" "abc")
(with-element "bar"
(attribute "blub" "bla"))
(text "Hi there.")))}

Package

cxml

Source

unparse.lisp (file)


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

5.1.3 Functions

Function: attribute QNAME VALUE

@arg[qname]{Qualified name, a string.}
@arg[value]{Any value understood by @fun{unparse-attribute}, in particular strings.}
@return{undocumented}

Collects an attribute for the start tag that is currently being written.

This function may only be called during the extent of a use of @fun{with-element} or @fun{with-element*}, and only before the first child node has been written.

An attribute for the current element is recorded using the namespace prefix and local name specified by @var{qname}. The attribute’s namespace prefix is resolved to a namespace URI using the bindings established by @fun{with-namespace},and that namespace URI is used for the attribute.

Package

cxml

Source

unparse.lisp (file)

Function: attribute* PREFIX LNAME VALUE &optional QNAME

@arg[prefix]{Namespace prefix, a string.}
@arg[lname]{Local name, a string.}
@arg[value]{Any value understood by @fun{unparse-attribute}, in particular strings.}
@return{undocumented}

Collects an attribute for the start tag that is currently being written.

This function may only be called during the extent of a use of @fun{with-element} or @fun{with-element*}, and only before the first child node has been written.

An attribute for the current element is recorded using the namespace prefix and local name specified by arguments. @var{prefix} is resolved to a namespace URI using the bindings established by @fun{with-namespace}, and that namespace URI is used for the attribute.

Package

cxml

Source

unparse.lisp (file)

Function: cdata DATA

@arg[data]{String.}
@return{undocumented}

Writes a CDATA section to the current output sink, using @code{data} as its contents.

Note: It is currently the caller’s responsibily to ensure that the CDATA section will not contain forbidden character sequences.

Package

cxml

Source

unparse.lisp (file)

Function: clear-dtd-cache DTD-CACHE
Package

cxml

Source

xml-parse.lisp (file)

Function: comment DATA

@arg[data]{String.}
@return{undocumented}

Writes a comment to the current output sink, using @code{data} as
its contents.

Note: It is currently the caller’s responsibily to ensure that @code{data} does not contain character sequences forbidden for comments.

Package

cxml

Source

unparse.lisp (file)

Function: consume-characters SOURCE
Package

klacks

Source

klacks.lisp (file)

Function: create-document &optional DOCUMENT-ELEMENT
Package

rune-dom

Source

rune-impl.lisp (file)

Function: current-characters SOURCE
Package

klacks

Source

klacks.lisp (file)

Function: current-lname SOURCE
Package

klacks

Source

klacks.lisp (file)

Function: current-qname SOURCE
Package

klacks

Source

klacks.lisp (file)

Function: current-uri SOURCE
Package

klacks

Source

klacks.lisp (file)

Function: doctype NAME PUBLIC-ID SYSTEM-ID &optional INTERNAL-SUBSET

@arg[name]{Element name, a string.}
@arg[public-id]{String}
@arg[system-id]{A system ID as a @class{puri:uri}.} @arg[internal-subset]{nil or a string}
@return{undocumented}

Writes a doctype declaration to the current output sink, using the specified name, public ID, system ID, and optionally an internal subset.

Package

cxml

Source

unparse.lisp (file)

Function: expect SOURCE KEY &optional U V W
Package

klacks

Source

klacks.lisp (file)

Function: find-attribute QNAME ATTRS
Package

sax

Source

sax-handler.lisp (file)

Function: find-attribute-ns URI LNAME ATTRS
Package

sax

Source

sax-handler.lisp (file)

Function: find-element SOURCE &optional LNAME URI
Package

klacks

Source

klacks.lisp (file)

Function: find-event SOURCE KEY
Package

klacks

Source

klacks.lisp (file)

Function: getdtd URI DTD-CACHE
Function: (setf getdtd) NEWVAL URI DTD-CACHE
Package

cxml

Source

xml-parse.lisp (file)

Function: make-attribute &key (NAMESPACE-URI NAMESPACE-URI) (LOCAL-NAME LOCAL-NAME) (QNAME QNAME) (VALUE VALUE) (SPECIFIED-P SPECIFIED-P)
Package

sax

Source

sax-handler.lisp (file)

Function: make-broadcast-handler &rest HANDLERS

@arg[handlers]{A list of @class{SAX handler}s.}
@return{A @class{broadcast-handler}.}

Creates a SAX handler which passes every event it receives on to each handler specified as an argument to this function.

See @class{broadcast-handler} for details.

Package

cxml

Source

sax-proxy.lisp (file)

Function: make-catalog &optional URIS
Package

cxml

Source

catalog.lisp (file)

Function: make-character-stream-sink STREAM &rest INITARGS &key ENCODING &allow-other-keys

@arg[stream]{A character stream.}
@return{A serialization sink, i.e. a @class{SAX handler}}

Returns a handler that writes processes SAX events by writing an equivalent XML document to @var{stream}.

The sink will return @var{stream} as a result from @fun{sax:end-document}.

All sink creation functions share the same keyword arguments. Refer to @fun{make-octet-vector-sink} for details on keyword arguments.

Package

cxml

Source

unparse.lisp (file)

Function: make-dom-builder ()
Package

rune-dom

Source

rune-builder.lisp (file)

Function: make-dtd-cache ()
Package

cxml

Source

xml-parse.lisp (file)

Function: make-extid PUBLIC SYSTEM

@arg[publicid]{string or nil} @arg[systemid]{@class{puri:uri} or nil}
@return{an instance of @class{extid}}

Create an object representing the External ID composed of the specified Public ID and System ID.

Package

cxml

Source

xml-parse.lisp (file)

Function: make-namespace-normalizer CHAINED-HANDLER

@arg[chained-handler]{A @class{SAX handler}.}
@return{A @class{SAX handler}.}

Return a SAX handler that performs @a[http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#normalizeDocumentAlgo]{DOM 3-style namespace normalization} on attribute lists in
@fun{sax:start-element} events before passing them on the next handler.

Package

cxml

Source

xmlns-normalizer.lisp (file)

Function: make-node &key NAME NS ATTRS CHILDREN
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: make-octet-stream-sink STREAM &rest INITARGS &key ENCODING &allow-other-keys

@arg[stream]{An (unsigned-byte 8) stream.}
@return{A serialization sink, i.e. a @class{SAX handler}}

Returns a handler that writes processes SAX events by writing an equivalent XML document to @var{stream}.

The sink will return @var{stream} as a result from @fun{sax:end-document}.

All sink creation functions share the same keyword arguments. Refer to @fun{make-octet-vector-sink} for details on keyword arguments.

Package

cxml

Source

unparse.lisp (file)

Function: make-octet-vector-sink &rest INITARGS &key ENCODING &allow-other-keys

@arg[canonical]{canonical form, one of NIL, T, 1, 2. If specified, serialization in canonical form is enabled. The two canonical forms are useful to allow comparisons of XML documents and their content model by character-by-character comparisons of
their serialized representation.}
@arg[indentation]{indentation level. An integer or nil. If specified, a pretty-printing indentation mode is enabled. Note that indentation as implemented currently changes the content model unconditionally, and is usually helpful only for debugging purposes.} @arg[encoding]{the character encoding to use. A string or
keyword. Values are interpreted by Babel. nil is also allowed
and means UTF-8.}
@arg[omit-xml-declaration]{Boolean. If true, no XML declaration
is written.}
@return{A serialization sink, i.e. a @class{SAX handler}}

Returns a handler that writes processes SAX events by writing an equivalent XML document to a newly allocated vector of @code{(unsigned-byte 8)}.

The following values for @code{canonical} are allowed:

@begin{itemize}
@item{t or 1: Canonical XML}
@item{2: Second Canonical Form}
@item{NIL: Use a more readable non-canonical representation.} @end{itemize}

The sink will return the vector as a result from @fun{sax:end-document}.

An internal subset will be included in the result regardless of the canonical setting. It is the responsibility of the caller to not report an internal subset for canonical <= 1, or only notations as required for canonical = 2. For example, the include-doctype argument to dom:map-document should be set to nil for the former behaviour and :canonical-notations for the latter.

Package

cxml

Source

unparse.lisp (file)

Function: make-recoder CHAINED-HANDLER RECODER-FN
Package

cxml

Source

recoder.lisp (file)

Function: make-rod-sink &rest INITARGS &key ENCODING &allow-other-keys

@return{A serialization sink, i.e. a @class{SAX handler}}

Returns a handler that writes processes SAX events by writing an equivalent XML document to a newly allocated string of unicode characters (or on implementations without unicode support: a rod).

The sink will return the string (or rod) as a result from @fun{sax:end-document}.

All sink creation functions share the same keyword arguments. Refer to @fun{make-octet-vector-sink} for details on keyword arguments.

Package

cxml

Source

unparse.lisp (file)

Function: make-source INPUT &rest ARGS &key VALIDATE DTD ROOT ENTITY-RESOLVER DISALLOW-INTERNAL-SUBSET BUFFERING PATHNAME
Package

cxml

Source

klacks-impl.lisp (file)

Function: make-string-sink &rest ARGS

@return{A serialization sink, i.e. a @class{SAX handler}}

Returns a handler that writes processes SAX events by writing an equivalent XML document to a newly allocated string of unicode characters.

The sink will return the string as a result from @fun{sax:end-document}.

All sink creation functions share the same keyword arguments. Refer to @fun{make-octet-vector-sink} for details on keyword arguments.

Package

cxml

Source

unparse.lisp (file)

Function: make-tapping-source UPSTREAM-SOURCE &optional SAX-HANDLER
Package

klacks

Source

tap-source.lisp (file)

Function: make-validator DTD ROOT

@arg[dtd]{An @class{dtd} instance.}
@arg[root]{Element name, a string.}
@return{A @class{SAX handler}.}

Create a SAX handler which validates against a DTD instance.
The document’s root element must be named @code{root}.
Used with @fun{dom:map-document}, this validates a document object as if by re-reading it with a validating parser, except that declarations recorded in the document instance are completely ignored.

Example:

@pre{(let ((d (parse-file "~/test.xml" (cxml-dom:make-dom-builder))) (x (parse-dtd-file "~/test.dtd")))
(dom:map-document (cxml:make-validator x #"foo") d))}

Package

cxml

Source

xml-parse.lisp (file)

Function: make-whitespace-normalizer CHAINED-HANDLER &optional DTD
Package

cxml

Source

space-normalizer.lisp (file)

Function: make-xmls-builder &key INCLUDE-DEFAULT-VALUES INCLUDE-NAMESPACE-URI

Make a XMLS style builder. When ’include-namespace-uri is true a modified XMLS tree is generated that includes the element namespace URI rather than the qualified name prefix and also includes the namespace URI for attributes.

Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: make-xpath-navigator ()
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: map-document HANDLER DOCUMENT &key INCLUDE-XMLNS-ATTRIBUTES INCLUDE-DOCTYPE INCLUDE-DEFAULT-VALUES RECODE
Package

dom

Source

dom-sax.lisp (file)

Function: map-node HANDLER NODE &key INCLUDE-XMLNS-ATTRIBUTES INCLUDE-NAMESPACE-URI
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: map-node-list FN NODELIST
Package

dom

Source

rune-impl.lisp (file)

Function: map-node-map FN NODE-MAP
Package

dom

Source

rune-impl.lisp (file)

Function: node-attrs NODE
Function: (setf node-attrs) NEWVAL NODE
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: node-children NODE
Function: (setf node-children) NEWVAL NODE
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: node-name NODE
Function: (setf node-name) NEWVAL NODE
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: node-ns NODE
Function: (setf node-ns) NEWVAL NODE
Package

cxml-xmls

Source

xmls-compat.lisp (file)

Function: parse INPUT HANDLER &rest ARGS &key VALIDATE DTD ROOT ENTITY-RESOLVER DISALLOW-INTERNAL-SUBSET RECODE PATHNAME

@arg[input]{A string, pathname, octet vector, or stream.}
@arg[handler]{A @class{SAX handler}}
@arg[validate]{Boolean. Defaults to @code{nil}. If true, parse in validating mode, i.e. assert that the document contains a DOCTYPE declaration and conforms to the DTD declared.}
@arg[dtd]{unless @code{nil}, an extid instance specifying the external subset to load. This options overrides the extid specified in the document type declaration, if any. See below for @fun{make-extid}. This option is useful for verification purposes together with the @var{root} and @var{disallow-internal-subset} arguments.} @arg[root]{The expected root element name, or @code{nil} (the default). If specified, this argument overrides the name stated in the input’s DOCTYPE (if any).}
@arg[entity-resolver]{@code{nil} or a function of two arguments which is invoked for every entity referenced by the document with the entity’s Public ID (a rod) and System ID (an URI object) as arguments. The function may either return nil, CXML will then try to resolve the entity as usual. Alternatively it may return a Common Lisp stream specialized on @code{(unsigned-byte 8)} which will be used instead. (It may also signal an error, of course, which can be useful to prohibit parsed XML documents from including arbitrary files readable by
the parser.)}
@arg[disallow-internal-subset]{Boolean. If true, signal
an error if the document contains an internal subset.} @arg[recode]{Boolean. (Ignored on Lisps with Unicode
support.) Recode rods to UTF-8 strings. Defaults to true.
Make sure to use @fun{utf8-dom:make-dom-builder} if this
option is enabled and @fun{rune-dom:make-dom-builder} otherwise.}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

Parse an XML document from @var{input}, which can be a string, pathname, octet vector, or stream.

Return values from this function depend on the SAX handler used.
This is an old-style convenience wrapper around the new-style interface @fun{parse}.

Parse an XML document from @var{filename}, and signal SAX events to @var{handler} while doing so.

All SAX parsing functions share the same keyword arguments. Refer to @fun{parse} for details on keyword arguments.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-dtd-file FILENAME &optional HANDLER

@arg[filename]{An pathname designator.}
@arg[handler]{A @class{SAX handler}}
@return{A @class{dtd} instance.}

Parse @a[http://www.w3.org/TR/2000/REC-xml-20001006#NT-extSubset]{declarations} from @var{filename} and return an object representing the DTD,
suitable as an argument to @code{validate} with @fun{parse}.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-dtd-stream STREAM &optional HANDLER

@arg[stream]{An (unsigned-byte 8) stream.}
@arg[handler]{A @class{SAX handler}}
@return{A @class{dtd} instance.}

Parse @a[http://www.w3.org/TR/2000/REC-xml-20001006#NT-extSubset]{declarations} from @var{stream} and return an object representing the DTD,
suitable as an argument to @code{validate} with @fun{parse}.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-empty-document URI QNAME HANDLER &key PUBLIC-ID SYSTEM-ID ENTITY-RESOLVER RECODE

@arg[uri]{a string or nil}
@arg[qname]{a string or nil}
@arg[handler]{a @class{SAX handler}}
@arg[public-id]{a string or nil}
@arg[system-id]{a @type{puri:uri} or nil} @arg[entity-resolver]{@code{nil} or a function of two arguments which is invoked for every entity referenced by the document with the entity’s Public ID (a rod) and System ID (an URI object) as arguments. The function may either return nil, CXML will then try to resolve the entity as usual. Alternatively it may return a Common Lisp stream specialized on @code{(unsigned-byte 8)} which will be used instead. (It may also signal an error, of course, which can be useful to prohibit parsed XML documents from including arbitrary files readable by
the parser.)}
@arg[recode]{Boolean. (Ignored on Lisps with Unicode
support.) Recode rods to UTF-8 strings. Defaults to true.
Make sure to use @fun{utf8-dom:make-dom-builder} if this
option is enabled and @fun{rune-dom:make-dom-builder} otherwise.}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

Simulate parsing of a document with a document element @var{qname} having no attributes except for an optional namespace
declaration to @var{uri}. If an external ID is specified (@var{system-id}, @var{public-id}), find, parse, and report
this DTD as if with @fun{parse-file}, using the specified
entity resolver.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-file FILENAME HANDLER &rest ARGS

@arg[filename]{An pathname designator.}
@arg[handler]{A @class{SAX handler}}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

This is an old-style convenience wrapper around the new-style interface @fun{parse}.

Parse an XML document from @var{filename}, and signal SAX events to @var{handler} while doing so.

All SAX parsing functions share the same keyword arguments. Refer to @fun{parse} for details on keyword arguments.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-octets OCTETS HANDLER &rest ARGS

@arg[octets]{An (unsigned-byte 8) vector.}
@arg[handler]{A @class{SAX handler}}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

This is an old-style convenience wrapper around the new-style interface @fun{parse}.

Parse an XML document from @var{octets}, and signal SAX events to @var{handler} while doing so.

All SAX parsing functions share the same keyword arguments. Refer to @fun{parse} for details on keyword arguments.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-rod STRING HANDLER &rest ARGS

@arg[string]{An string of unicode characters.}
@arg[handler]{A @class{SAX handler}}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

This is an old-style convenience wrapper around the new-style interface @fun{parse}.

Parse an XML document from @var{string}, and signal SAX events to @var{handler} while doing so.

Note: This function assumes that @var{string} has already been decoded into Unicode runes and ignores the encoding specified in the XML declaration, if any.

All SAX parsing functions share the same keyword arguments. Refer to @fun{parse} for details on keyword arguments.

Package

cxml

Source

xml-parse.lisp (file)

Function: parse-stream STREAM HANDLER &rest ARGS

@arg[stream]{An (unsigned-byte 8) stream}
@arg[handler]{A @class{SAX handler}}
@return{The value returned by @fun{sax:end-document} on @var{handler}.}

This is an old-style convenience wrapper around the new-style interface @fun{parse}.

Parse an XML document from @var{stream}, and signal SAX events to @var{handler} while doing so.

All SAX parsing functions share the same keyword arguments. Refer to @fun{parse} for details on keyword arguments.

Package

cxml

Source

xml-parse.lisp (file)

Function: processing-instruction TARGET DATA

@arg[target]{String.}
@arg[data]{String.}
@return{undocumented}

Writes a processing instruction to the current output sink, using @code{target} and @code{data} as its contents.

Note: It is currently the caller’s responsibily to ensure that @code{target} and @code{data} do not contain character sequences forbidden for processing instruction contents.

Package

cxml

Source

unparse.lisp (file)

Function: remdtd URI DTD-CACHE
Package

cxml

Source

xml-parse.lisp (file)

Function: resolve-extid PUBLIC SYSTEM CATALOG
Package

cxml

Source

catalog.lisp (file)

Function: resolve-uri URI CATALOG
Package

cxml

Source

catalog.lisp (file)

Function: run-all-tests *DIRECTORY* &optional VERBOSE
Package

domtest

Source

domtest.lisp (file)

Function: run-all-tests PARSER-FN DIRECTORY
Package

xmlconf

Source

xmlconf.lisp (file)

Function: serialize-element SOURCE HANDLER &key DOCUMENT-EVENTS
Package

klacks

Source

klacks.lisp (file)

Function: serialize-event SOURCE HANDLER &key CONSUME
Package

klacks

Source

klacks.lisp (file)

Function: serialize-source SOURCE HANDLER
Package

klacks

Source

klacks.lisp (file)

Function: skip SOURCE KEY &optional A B C
Package

klacks

Source

klacks.lisp (file)

Function: text DATA

@arg[data]{String.}
@return{undocumented}

Writes a text node to the current output sink, using @code{data} as its contents.

Note: It is currently the caller’s responsibily to ensure that @code{data} does not contain characters forbidden for character data.

Package

cxml

Source

unparse.lisp (file)

Function: unescaped STR

@arg[data]{String.}
@return{undocumented}

If supported by the current output sink, writes character data directly to the sink’s target.

Use of this function is often an indicator of bad design. Avoid it if you can. (Implementation note: This function is supported because XSLT’s XML output method requires it.)

Package

cxml

Source

unparse.lisp (file)

Function: validity-error FMT &rest ARGS
Package

cxml

Source

xml-parse.lisp (file)


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

5.1.4 Generic functions

Generic Function: append-child NODE NEW-CHILD
Package

dom

Methods
Method: append-child (NODE node) (NEW-CHILD document-fragment)
Source

rune-impl.lisp (file)

Method: append-child (NODE node) (NEW-CHILD node)
Source

rune-impl.lisp (file)

Generic Function: append-data NODE ARG
Package

dom

Methods
Method: append-data (NODE character-data) ARG
Source

rune-impl.lisp (file)

Generic Function: attribute-declaration HANDLER ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT

Called when an attribute declaration is seen in a DTD.
type one of :CDATA, :ID, :IDREF, :IDREFS,
:ENTITY, :ENTITIES, :NMTOKEN, :NMTOKENS,
(:NOTATION <name>*), or (:ENUMERATION <name>*)
default :REQUIRED, :IMPLIED, (:FIXED content), or (:DEFAULT content)

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: attribute-declaration (HANDLER klacks-dtd-handler) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Source

klacks-impl.lisp (file)

Method: attribute-declaration (HANDLER dom-builder) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Source

rune-builder.lisp (file)

Method: attribute-declaration (HANDLER broadcast-handler) ELT ATTR TYPE DEFAULT
Source

sax-proxy.lisp (file)

Method: attribute-declaration (HANDLER recoder) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Source

recoder.lisp (file)

Method: attribute-declaration (SINK sink) ENAME ANAME TYPE DEFAULT
Source

unparse.lisp (file)

Method: attribute-declaration (HANDLER null) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Method: attribute-declaration HANDLER ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Method: attribute-declaration (HANDLER abstract-handler) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Method: attribute-declaration (HANDLER content-handler) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Method: attribute-declaration (HANDLER abstract-handler) ELEMENT-NAME ATTRIBUTE-NAME TYPE DEFAULT
Generic Function: attribute-local-name ATTRIBUTE
Package

sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-local-name) (generic function)

Methods
Method: attribute-local-name (ATTRIBUTE standard-attribute)
Method: attribute-local-name (ATTRIBUTE standard-attribute)
Generic Function: (setf attribute-local-name) NEWVAL ATTRIBUTE
Package

sax

Reader

attribute-local-name (generic function)

Methods
Method: (setf attribute-local-name) NEWVAL (ATTRIBUTE standard-attribute)
Source

sax-handler.lisp (file)

Generic Function: attribute-namespace-uri ATTRIBUTE
Package

sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-namespace-uri) (generic function)

Methods
Method: attribute-namespace-uri (ATTRIBUTE standard-attribute)
Method: attribute-namespace-uri (ATTRIBUTE standard-attribute)
Generic Function: (setf attribute-namespace-uri) NEWVAL ATTRIBUTE
Package

sax

Reader

attribute-namespace-uri (generic function)

Methods
Method: (setf attribute-namespace-uri) NEWVAL (ATTRIBUTE standard-attribute)
Source

sax-handler.lisp (file)

Generic Function: attribute-p OBJECT
Package

dom

Methods
Method: attribute-p OBJECT
Source

rune-impl.lisp (file)

Method: attribute-p (OBJECT attribute)
Source

rune-impl.lisp (file)

Generic Function: attribute-qname ATTRIBUTE
Package

sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-qname) (generic function)

Methods
Method: attribute-qname (ATTRIBUTE standard-attribute)
Method: attribute-qname (ATTRIBUTE standard-attribute)
Generic Function: (setf attribute-qname) NEWVAL ATTRIBUTE
Package

sax

Reader

attribute-qname (generic function)

Methods
Method: (setf attribute-qname) NEWVAL (ATTRIBUTE standard-attribute)
Source

sax-handler.lisp (file)

Generic Function: attribute-specified-p ATTRIBUTE
Package

sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-specified-p) (generic function)

Methods
Method: attribute-specified-p (ATTRIBUTE standard-attribute)
Method: attribute-specified-p (ATTRIBUTE standard-attribute)
Generic Function: (setf attribute-specified-p) NEWVAL ATTRIBUTE
Package

sax

Reader

attribute-specified-p (generic function)

Methods
Method: (setf attribute-specified-p) NEWVAL (ATTRIBUTE standard-attribute)
Source

sax-handler.lisp (file)

Generic Function: attribute-value ATTRIBUTE
Package

sax

Source

sax-handler.lisp (file)

Writer

(setf attribute-value) (generic function)

Methods
Method: attribute-value (ATTRIBUTE standard-attribute)
Method: attribute-value (ATTRIBUTE standard-attribute)
Generic Function: (setf attribute-value) NEWVAL ATTRIBUTE
Package

sax

Reader

attribute-value (generic function)

Methods
Method: (setf attribute-value) NEWVAL (ATTRIBUTE standard-attribute)
Source

sax-handler.lisp (file)

Generic Function: attributes OBJECT
Package

dom

Methods
Method: attributes (SELF node)
Source

rune-impl.lisp (file)

Method: attributes (ELEMENT element)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: broadcast-handler-handlers OBJECT

@arg[instance]{A @class{broadcast-handler}}
@return{A list of @class{SAX handler}s.}

Returns the list of SAX handlers that arechained to this broadcast handler.

Package

cxml

Writer

(setf broadcast-handler-handlers) (generic function)

Methods
Method: broadcast-handler-handlers (BROADCAST-HANDLER broadcast-handler)

automatically generated reader method

Source

sax-proxy.lisp (file)

Generic Function: (setf broadcast-handler-handlers) NEW-VALUE OBJECT
Package

cxml

Reader

broadcast-handler-handlers (generic function)

Methods
Method: (setf broadcast-handler-handlers) NEW-VALUE (BROADCAST-HANDLER broadcast-handler)

automatically generated writer method

Source

sax-proxy.lisp (file)

Generic Function: cdata-section-p OBJECT
Package

dom

Methods
Method: cdata-section-p OBJECT
Source

rune-impl.lisp (file)

Method: cdata-section-p (OBJECT cdata-section)
Source

rune-impl.lisp (file)

Generic Function: character-data-p OBJECT
Package

dom

Methods
Method: character-data-p OBJECT
Source

rune-impl.lisp (file)

Method: character-data-p (OBJECT character-data)
Source

rune-impl.lisp (file)

Generic Function: characters HANDLER DATA

Called for textual element content.

The data is passed as a rod, with all entity references resolved. It is possible that the character content of an element is reported via multiple subsequent calls to this generic function.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: characters (HANDLER dom-builder) DATA
Source

rune-builder.lisp (file)

Method: characters (HANDLER broadcast-handler) DATA
Source

sax-proxy.lisp (file)

Method: characters (HANDLER whitespace-normalizer) DATA
Source

space-normalizer.lisp (file)

Method: characters (HANDLER recoder) DATA
Source

recoder.lisp (file)

Method: characters (HANDLER xmls-builder) DATA
Source

xmls-compat.lisp (file)

Method: characters (SINK sink) DATA
Source

unparse.lisp (file)

Method: characters (HANDLER validator) DATA
Source

xml-parse.lisp (file)

Method: characters (HANDLER null) DATA
Method: characters HANDLER DATA
Method: characters (HANDLER abstract-handler) DATA
Method: characters (HANDLER default-handler) DATA
Method: characters (HANDLER abstract-handler) DATA
Generic Function: child-nodes NODE
Package

dom

Methods
Method: child-nodes (NODE node)
Source

rune-impl.lisp (file)

Generic Function: clone-node NODE DEEP
Package

dom

Methods
Method: clone-node (NODE document) DEEP
Source

rune-impl.lisp (file)

Method: clone-node (NODE node) DEEP
Source

rune-impl.lisp (file)

Generic Function: close-source SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: close-source (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: close-source (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: code SELF
Package

dom

Methods
Method: code (SELF dom-exception)
Source

rune-impl.lisp (file)

Generic Function: column-number SAX-PARSER

Return an approximation of the current column number, or NIL.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: column-number (PARSER klacksax)
Source

klacks.lisp (file)

Method: column-number (PARSER cxml-parser)
Source

xml-parse.lisp (file)

Method: column-number (HANDLER sax-parser-mixin)
Generic Function: comment HANDLER DATA
Package

sax

Source

sax-handler.lisp (file)

Methods
Method: comment (HANDLER dom-builder) DATA
Source

rune-builder.lisp (file)

Method: comment (HANDLER broadcast-handler) DATA
Source

sax-proxy.lisp (file)

Method: comment (HANDLER recoder) DATA
Source

recoder.lisp (file)

Method: comment (SINK sink) DATA
Source

unparse.lisp (file)

Method: comment (HANDLER null) DATA
Method: comment HANDLER DATA
Method: comment (HANDLER abstract-handler) DATA
Method: comment (HANDLER content-handler) DATA
Method: comment (HANDLER abstract-handler) DATA
Generic Function: comment-p OBJECT
Package

dom

Methods
Method: comment-p OBJECT
Source

rune-impl.lisp (file)

Method: comment-p (OBJECT comment)
Source

rune-impl.lisp (file)

Generic Function: consume SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: consume (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: consume (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: create-attribute DOCUMENT NAME
Package

dom

Methods
Method: create-attribute (DOCUMENT document) NAME
Source

rune-impl.lisp (file)

Generic Function: create-attribute-ns DOCUMENT URI QNAME
Package

dom

Methods
Method: create-attribute-ns (DOCUMENT document) URI QNAME
Source

rune-impl.lisp (file)

Generic Function: create-cdata-section DOCUMENT DATA
Package

dom

Methods
Method: create-cdata-section (DOCUMENT document) DATA
Source

rune-impl.lisp (file)

Generic Function: create-comment DOCUMENT DATA
Package

dom

Methods
Method: create-comment (DOCUMENT document) DATA
Source

rune-impl.lisp (file)

Generic Function: create-document FACTORY URI QNAME DOCTYPE
Package

dom

Methods
Method: create-document (FACTORY (eql implementation)) URI QNAME DOCTYPE
Source

rune-impl.lisp (file)

Generic Function: create-document-fragment DOCUMENT
Package

dom

Methods
Method: create-document-fragment (DOCUMENT document)
Source

rune-impl.lisp (file)

Generic Function: create-document-type FACTORY NAME PUBLICID SYSTEMID
Package

dom

Methods
Method: create-document-type (FACTORY (eql implementation)) NAME PUBLICID SYSTEMID
Source

rune-impl.lisp (file)

Generic Function: create-element DOCUMENT TAG-NAME
Package

dom

Methods
Method: create-element (DOCUMENT document) TAG-NAME
Source

rune-impl.lisp (file)

Generic Function: create-element-ns DOCUMENT URI QNAME
Package

dom

Methods
Method: create-element-ns (DOCUMENT document) URI QNAME
Source

rune-impl.lisp (file)

Generic Function: create-entity-reference DOCUMENT NAME
Package

dom

Methods
Method: create-entity-reference (DOCUMENT document) NAME
Source

rune-impl.lisp (file)

Generic Function: create-processing-instruction DOCUMENT TARGET DATA
Package

dom

Methods
Method: create-processing-instruction (DOCUMENT document) TARGET DATA
Source

rune-impl.lisp (file)

Generic Function: create-text-node DOCUMENT DATA
Package

dom

Methods
Method: create-text-node (DOCUMENT document) DATA
Source

rune-impl.lisp (file)

Generic Function: current-cdata-section-p SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: current-cdata-section-p (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: current-cdata-section-p (CXML-SOURCE cxml-source)

automatically generated reader method

Source

klacks-impl.lisp (file)

Generic Function: current-column-number SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: current-column-number (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: current-column-number (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: current-line-number SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: current-line-number (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: current-line-number (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: current-system-id SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: current-system-id (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: current-system-id (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: current-xml-base SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: current-xml-base (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: current-xml-base (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: data OBJECT
Generic Function: (setf data) NEWVAL SELF
Package

dom

Methods
Method: data (PROCESSING-INSTRUCTION processing-instruction)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: data (CHARACTER-DATA character-data)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: (setf data) NEWVAL (SELF processing-instruction)
Source

rune-impl.lisp (file)

Method: (setf data) NEWVAL (SELF character-data)
Source

rune-impl.lisp (file)

Generic Function: decode-qname QNAME SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: decode-qname QNAME (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: decode-qname QNAME (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: delete-data NODE OFFSET COUNT
Package

dom

Methods
Method: delete-data (NODE character-data) OFFSET COUNT
Source

rune-impl.lisp (file)

Generic Function: doctype OBJECT
Package

dom

Methods
Method: doctype (DOCUMENT document)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: document-element DOCUMENT
Package

dom

Methods
Method: document-element (DOCUMENT document)
Source

rune-impl.lisp (file)

Generic Function: document-fragment-p OBJECT
Package

dom

Methods
Method: document-fragment-p OBJECT
Source

rune-impl.lisp (file)

Method: document-fragment-p (OBJECT document-fragment)
Source

rune-impl.lisp (file)

Generic Function: document-p OBJECT
Package

dom

Methods
Method: document-p OBJECT
Source

rune-impl.lisp (file)

Method: document-p (OBJECT document)
Source

rune-impl.lisp (file)

Generic Function: document-type-p OBJECT
Package

dom

Methods
Method: document-type-p OBJECT
Source

rune-impl.lisp (file)

Method: document-type-p (OBJECT document-type)
Source

rune-impl.lisp (file)

Generic Function: element-declaration HANDLER NAME MODEL

Called when a element declaration is seen in a DTD. Model is not a string, but a nested list, with *, ?, +, OR, and AND being the operators, rods as names, :EMPTY and :PCDATA as special tokens. (AND represents sequences.)

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: element-declaration (HANDLER klacks-dtd-handler) NAME MODEL
Source

klacks-impl.lisp (file)

Method: element-declaration (HANDLER dom-builder) NAME MODEL
Source

rune-builder.lisp (file)

Method: element-declaration (HANDLER broadcast-handler) NAME MODEL
Source

sax-proxy.lisp (file)

Method: element-declaration (HANDLER recoder) NAME MODEL
Source

recoder.lisp (file)

Method: element-declaration (SINK sink) NAME MODEL
Source

unparse.lisp (file)

Method: element-declaration (HANDLER null) NAME MODEL
Method: element-declaration HANDLER NAME MODEL
Method: element-declaration (HANDLER abstract-handler) NAME MODEL
Method: element-declaration (HANDLER content-handler) NAME MODEL
Method: element-declaration (HANDLER abstract-handler) NAME MODEL
Generic Function: element-p OBJECT
Package

dom

Methods
Method: element-p OBJECT
Source

rune-impl.lisp (file)

Method: element-p (OBJECT element)
Source

rune-impl.lisp (file)

Generic Function: end-cdata HANDLER

Called at the end of parsing a CDATA section.

Handlers only have to implement this if they are interested in the lexical structure of the parsed document. The content of the CDATA section is reported via the ‘characters’ generic function like all other textual content.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-cdata (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: end-cdata (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: end-cdata (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-cdata (SINK sink)
Source

unparse.lisp (file)

Method: end-cdata (HANDLER validator)
Source

xml-parse.lisp (file)

Method: end-cdata (HANDLER null)
Method: end-cdata HANDLER
Method: end-cdata (HANDLER abstract-handler)
Method: end-cdata (HANDLER content-handler)
Method: end-cdata (HANDLER abstract-handler)
Generic Function: end-document HANDLER

Called at the end of parsing a document.
This is always the last function called in the parsing process.

In contrast to all of the other methods, the return value of this gf
is significant, it will be returned by the parse-file/stream/string function.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-document (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: end-document (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: end-document (HANDLER catalog-parser)
Source

catalog.lisp (file)

Method: end-document (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-document (HANDLER xmls-builder)
Source

xmls-compat.lisp (file)

Method: end-document (SINK sink)
Source

unparse.lisp (file)

Method: end-document (HANDLER null)
Method: end-document HANDLER
Method: end-document (HANDLER abstract-handler)
Method: end-document (HANDLER default-handler)
Method: end-document (HANDLER abstract-handler)
Generic Function: end-dtd HANDLER

Called at the end of parsing a DTD.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-dtd (HANDLER klacks-dtd-handler)
Source

klacks-impl.lisp (file)

Method: end-dtd (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: end-dtd (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-dtd (SINK sink)
Source

unparse.lisp (file)

Method: end-dtd (HANDLER null)
Method: end-dtd HANDLER
Method: end-dtd (HANDLER abstract-handler)
Method: end-dtd (HANDLER content-handler)
Method: end-dtd (HANDLER abstract-handler)
Generic Function: end-element HANDLER NAMESPACE-URI LOCAL-NAME QNAME

Called to report the end of an element.

See the documentation for ‘start-element’ for a description of the parameters.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-element (HANDLER dom-builder) NAMESPACE-URI LOCAL-NAME QNAME
Source

rune-builder.lisp (file)

Method: end-element (HANDLER broadcast-handler) NAMESPACE-URI LOCAL-NAME QNAME
Source

sax-proxy.lisp (file)

Method: end-element (HANDLER catalog-parser) URI LNAME QNAME
Source

catalog.lisp (file)

Method: end-element (HANDLER whitespace-normalizer) URI LNAME QNAME
Source

space-normalizer.lisp (file)

Method: end-element (HANDLER namespace-normalizer) URI LNAME QNAME
Source

xmlns-normalizer.lisp (file)

Method: end-element (HANDLER recoder) NAMESPACE-URI LOCAL-NAME QNAME
Source

recoder.lisp (file)

Method: end-element (HANDLER xmls-builder) NAMESPACE-URI LOCAL-NAME QNAME
Source

xmls-compat.lisp (file)

Method: end-element (SINK sink) NAMESPACE-URI LOCAL-NAME QNAME
Source

unparse.lisp (file)

Method: end-element (HANDLER validator) URI LNAME QNAME
Source

xml-parse.lisp (file)

Method: end-element (HANDLER null) NAMESPACE-URI LOCAL-NAME QNAME
Method: end-element HANDLER NAMESPACE-URI LOCAL-NAME QNAME
Method: end-element (HANDLER abstract-handler) NAMESPACE-URI LOCAL-NAME QNAME
Method: end-element (HANDLER default-handler) NAMESPACE-URI LOCAL-NAME QNAME
Method: end-element (HANDLER abstract-handler) NAMESPACE-URI LOCAL-NAME QNAME
Generic Function: end-internal-subset HANDLER

Called after processing of the internal subset has finished, if present.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-internal-subset (HANDLER klacks-dtd-handler)
Source

klacks-impl.lisp (file)

Method: end-internal-subset (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: end-internal-subset (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: end-internal-subset (HANDLER recoder)
Source

recoder.lisp (file)

Method: end-internal-subset (SINK sink)
Source

unparse.lisp (file)

Method: end-internal-subset (HANDLER null)
Method: end-internal-subset HANDLER
Method: end-internal-subset (HANDLER abstract-handler)
Method: end-internal-subset (HANDLER content-handler)
Method: end-internal-subset (HANDLER abstract-handler)
Generic Function: end-prefix-mapping HANDLER PREFIX

Called when a prefix -> namespace-uri mapping goes out of scope.

This will always be called immediatly after the ‘end-element’ event for the element on which the namespace is declared. The order of the end-prefix-mapping events is otherwise not guaranteed.

Clients don’t usually have to implement this except under special circumstances, for example when they have to deal with qualified names in textual content. The parser will handle namespaces of elements and attributes on its own.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: end-prefix-mapping (HANDLER broadcast-handler) PREFIX
Source

sax-proxy.lisp (file)

Method: end-prefix-mapping (HANDLER recoder) PREFIX
Source

recoder.lisp (file)

Method: end-prefix-mapping (HANDLER null) PREFIX
Method: end-prefix-mapping HANDLER PREFIX
Method: end-prefix-mapping (HANDLER abstract-handler) PREFIX
Method: end-prefix-mapping (HANDLER content-handler) PREFIX
Method: end-prefix-mapping (HANDLER abstract-handler) PREFIX
Generic Function: entities OBJECT
Package

dom

Methods
Method: entities (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: entity-p OBJECT
Package

dom

Methods
Method: entity-p OBJECT
Source

rune-impl.lisp (file)

Method: entity-p (OBJECT entity)
Source

rune-impl.lisp (file)

Generic Function: entity-reference-p OBJECT
Package

dom

Methods
Method: entity-reference-p OBJECT
Source

rune-impl.lisp (file)

Method: entity-reference-p (OBJECT entity-reference)
Source

rune-impl.lisp (file)

Generic Function: entity-resolver HANDLER RESOLVER

Called between sax:end-dtd and sax:end-document to register an entity resolver, a function of two arguments: An entity name and SAX handler. When called, the resolver function will parse the named entity’s data.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: entity-resolver (HANDLER klacks-dtd-handler) FN
Source

klacks-impl.lisp (file)

Method: entity-resolver (HANDLER dom-builder) RESOLVER
Source

rune-builder.lisp (file)

Method: entity-resolver (HANDLER broadcast-handler) RESOLVER
Source

sax-proxy.lisp (file)

Method: entity-resolver (HANDLER recoder) RESOLVER
Source

recoder.lisp (file)

Method: entity-resolver (HANDLER null) RESOLVER
Method: entity-resolver HANDLER RESOLVER
Method: entity-resolver (HANDLER abstract-handler) RESOLVER
Method: entity-resolver (HANDLER content-handler) RESOLVER
Method: entity-resolver (HANDLER abstract-handler) RESOLVER
Generic Function: external-entity-declaration HANDLER KIND NAME PUBLIC-ID SYSTEM-ID

Called when a parsed external entity declaration is seen in a DTD.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: external-entity-declaration (HANDLER klacks-dtd-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Source

klacks-impl.lisp (file)

Method: external-entity-declaration (HANDLER dom-builder) KIND NAME PUBLIC-ID SYSTEM-ID
Source

rune-builder.lisp (file)

Method: external-entity-declaration (HANDLER broadcast-handler) KIND NAME PUB SYS
Source

sax-proxy.lisp (file)

Method: external-entity-declaration (HANDLER recoder) KIND NAME PUBLIC-ID SYSTEM-ID
Source

recoder.lisp (file)

Method: external-entity-declaration (SINK sink) KIND NAME PUBLIC-ID SYSTEM-ID
Source

unparse.lisp (file)

Method: external-entity-declaration (HANDLER null) KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration HANDLER KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration (HANDLER abstract-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration (HANDLER content-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Method: external-entity-declaration (HANDLER abstract-handler) KIND NAME PUBLIC-ID SYSTEM-ID
Generic Function: find-namespace-binding PREFIX SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: find-namespace-binding PREFIX (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: find-namespace-binding PREFIX (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: first-child NODE
Package

dom

Methods
Method: first-child (NODE node)
Source

rune-impl.lisp (file)

Generic Function: get-attribute SOURCE LNAME &optional URI
Package

klacks

Source

klacks.lisp (file)

Methods
Method: get-attribute (SOURCE cxml-source) LNAME &optional URI
Source

klacks-impl.lisp (file)

Generic Function: get-attribute ELEMENT NAME
Package

dom

Methods
Method: get-attribute (ELEMENT element) NAME
Source

rune-impl.lisp (file)

Generic Function: get-attribute-node ELEMENT NAME
Package

dom

Methods
Method: get-attribute-node (ELEMENT element) NAME
Source

rune-impl.lisp (file)

Generic Function: get-attribute-node-ns ELEMENT URI LNAME
Package

dom

Methods
Method: get-attribute-node-ns (ELEMENT element) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: get-attribute-ns ELEMENT URI LNAME
Package

dom

Methods
Method: get-attribute-ns (ELEMENT element) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: get-element-by-id DOCUMENT ID
Package

dom

Methods
Method: get-element-by-id (DOCUMENT document) ID
Source

rune-impl.lisp (file)

Generic Function: get-elements-by-tag-name DOCUMENT TAG-NAME
Package

dom

Methods
Method: get-elements-by-tag-name (ELEMENT element) NAME
Source

rune-impl.lisp (file)

Method: get-elements-by-tag-name (DOCUMENT document) TAG-NAME
Source

rune-impl.lisp (file)

Generic Function: get-elements-by-tag-name-ns DOCUMENT URI LNAME
Package

dom

Methods
Method: get-elements-by-tag-name-ns (ELEMENT element) URI LNAME
Source

rune-impl.lisp (file)

Method: get-elements-by-tag-name-ns (DOCUMENT document) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: get-named-item SELF NAME
Package

dom

Methods
Method: get-named-item (SELF named-node-map) NAME
Source

rune-impl.lisp (file)

Generic Function: get-named-item-ns SELF URI LNAME
Package

dom

Methods
Method: get-named-item-ns (SELF named-node-map) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: has-attribute ELEMENT NAME
Package

dom

Methods
Method: has-attribute (ELEMENT element) NAME
Source

rune-impl.lisp (file)

Generic Function: has-attribute-ns ELEMENT URI LNAME
Package

dom

Methods
Method: has-attribute-ns (ELEMENT element) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: has-attributes ELEMENT
Package

dom

Methods
Method: has-attributes (ELEMENT element)
Source

rune-impl.lisp (file)

Method: has-attributes (ELEMENT node)
Source

rune-impl.lisp (file)

Generic Function: has-child-nodes NODE
Package

dom

Methods
Method: has-child-nodes (NODE node)
Source

rune-impl.lisp (file)

Generic Function: has-feature FACTORY FEATURE VERSION
Package

dom

Methods
Method: has-feature (FACTORY (eql implementation)) FEATURE VERSION
Source

rune-impl.lisp (file)

Generic Function: implementation DOCUMENT
Package

dom

Methods
Method: implementation (DOCUMENT document)
Source

rune-impl.lisp (file)

Generic Function: import-node DOCUMENT NODE DEEP
Package

dom

Methods
Method: import-node (DOCUMENT document) (NODE character-data) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE processing-instruction) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE notation) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE entity-reference) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE entity) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE element) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE document-fragment) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) (NODE attribute) DEEP
Source

rune-impl.lisp (file)

Method: import-node (DOCUMENT document) NODE DEEP
Source

rune-impl.lisp (file)

Generic Function: insert-before NODE NEW-CHILD REF-CHILD
Package

dom

Methods
Method: insert-before (NODE node) (FRAGMENT document-fragment) REF-CHILD
Source

rune-impl.lisp (file)

Method: insert-before (NODE node) (NEW-CHILD node) REF-CHILD
Source

rune-impl.lisp (file)

Generic Function: insert-data NODE OFFSET ARG
Package

dom

Methods
Method: insert-data (NODE character-data) OFFSET ARG
Source

rune-impl.lisp (file)

Generic Function: internal-entity-declaration HANDLER KIND NAME VALUE

Called when an internal entity declaration is seen in a DTD.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: internal-entity-declaration (HANDLER klacks-dtd-handler) KIND NAME VALUE
Source

klacks-impl.lisp (file)

Method: internal-entity-declaration (HANDLER dom-builder) KIND NAME VALUE
Source

rune-builder.lisp (file)

Method: internal-entity-declaration (HANDLER broadcast-handler) KIND NAME VALUE
Source

sax-proxy.lisp (file)

Method: internal-entity-declaration (HANDLER recoder) KIND NAME VALUE
Source

recoder.lisp (file)

Method: internal-entity-declaration (SINK sink) KIND NAME VALUE
Source

unparse.lisp (file)

Method: internal-entity-declaration (HANDLER null) KIND NAME VALUE
Method: internal-entity-declaration HANDLER KIND NAME VALUE
Method: internal-entity-declaration (HANDLER abstract-handler) KIND NAME VALUE
Method: internal-entity-declaration (HANDLER content-handler) KIND NAME VALUE
Method: internal-entity-declaration (HANDLER abstract-handler) KIND NAME VALUE
Generic Function: internal-subset NODE
Package

dom

Methods
Method: internal-subset (NODE document-type)
Source

rune-impl.lisp (file)

Generic Function: is-supported NODE FEATURE VERSION
Package

dom

Methods
Method: is-supported (NODE node) FEATURE VERSION
Source

rune-impl.lisp (file)

Generic Function: item SELF INDEX
Package

dom

Methods
Method: item (SELF named-node-map) INDEX
Source

rune-impl.lisp (file)

Method: item (SELF vector) INDEX
Source

rune-impl.lisp (file)

Generic Function: items OBJECT
Package

dom

Methods
Method: items (NAMED-NODE-MAP named-node-map)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: last-child NODE
Package

dom

Methods
Method: last-child (NODE node)
Source

rune-impl.lisp (file)

Generic Function: length SELF
Package

dom

Methods
Method: length (NODE character-data)
Source

rune-impl.lisp (file)

Method: length (SELF named-node-map)
Source

rune-impl.lisp (file)

Method: length (SELF vector)
Source

rune-impl.lisp (file)

Generic Function: line-number SAX-PARSER

Return an approximation of the current line number, or NIL.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: line-number (PARSER klacksax)
Source

klacks.lisp (file)

Method: line-number (PARSER cxml-parser)
Source

xml-parse.lisp (file)

Method: line-number (HANDLER sax-parser-mixin)
Generic Function: list-attributes SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: list-attributes (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: list-attributes (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: local-name NODE
Package

dom

Methods
Method: local-name (NAMESPACE-MIXIN namespace-mixin)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: local-name (NODE node)
Source

rune-impl.lisp (file)

Generic Function: map-attributes FN SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: map-attributes FN (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: map-attributes FN (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: map-current-namespace-declarations FN SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: map-current-namespace-declarations FN (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: map-current-namespace-declarations FN (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: name OBJECT
Package

dom

Methods
Method: name (ENTITY-REFERENCE entity-reference)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: name (ENTITY entity)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: name (NOTATION notation)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: name (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: name (ATTRIBUTE attribute)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: named-node-map-p OBJECT
Package

dom

Methods
Method: named-node-map-p OBJECT
Source

rune-impl.lisp (file)

Method: named-node-map-p (OBJECT named-node-map)
Source

rune-impl.lisp (file)

Generic Function: namespace-uri NODE
Package

dom

Methods
Method: namespace-uri (NAMESPACE-MIXIN namespace-mixin)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: namespace-uri (NODE node)
Source

rune-impl.lisp (file)

Generic Function: next-sibling NODE
Package

dom

Methods
Method: next-sibling (NODE node)
Source

rune-impl.lisp (file)

Generic Function: node-name SELF
Package

dom

Methods
Method: node-name (SELF processing-instruction)
Source

rune-impl.lisp (file)

Method: node-name (SELF entity-reference)
Source

rune-impl.lisp (file)

Method: node-name (SELF entity)
Source

rune-impl.lisp (file)

Method: node-name (SELF notation)
Source

rune-impl.lisp (file)

Method: node-name (SELF document-type)
Source

rune-impl.lisp (file)

Method: node-name (SELF element)
Source

rune-impl.lisp (file)

Method: node-name (SELF attribute)
Source

rune-impl.lisp (file)

Method: node-name (SELF comment)
Source

rune-impl.lisp (file)

Method: node-name (SELF cdata-section)
Source

rune-impl.lisp (file)

Method: node-name (SELF text)
Source

rune-impl.lisp (file)

Method: node-name (SELF document-fragment)
Source

rune-impl.lisp (file)

Method: node-name (SELF document)
Source

rune-impl.lisp (file)

Generic Function: node-p OBJECT
Package

dom

Methods
Method: node-p OBJECT
Source

rune-impl.lisp (file)

Method: node-p (OBJECT node)
Source

rune-impl.lisp (file)

Generic Function: node-type SELF
Package

dom

Methods
Method: node-type (SELF processing-instruction)
Source

rune-impl.lisp (file)

Method: node-type (SELF entity-reference)
Source

rune-impl.lisp (file)

Method: node-type (SELF entity)
Source

rune-impl.lisp (file)

Method: node-type (SELF notation)
Source

rune-impl.lisp (file)

Method: node-type (SELF document-type)
Source

rune-impl.lisp (file)

Method: node-type (SELF element)
Source

rune-impl.lisp (file)

Method: node-type (SELF attribute)
Source

rune-impl.lisp (file)

Method: node-type (SELF cdata-section)
Source

rune-impl.lisp (file)

Method: node-type (SELF comment)
Source

rune-impl.lisp (file)

Method: node-type (SELF text)
Source

rune-impl.lisp (file)

Method: node-type (SELF document-fragment)
Source

rune-impl.lisp (file)

Method: node-type (SELF document)
Source

rune-impl.lisp (file)

Generic Function: node-value SELF
Generic Function: (setf node-value) NEWVAL SELF
Package

dom

Methods
Method: node-value (SELF processing-instruction)
Method: (setf node-value) NEWVAL (SELF processing-instruction)
Source

rune-impl.lisp (file)

Method: node-value (SELF entity-reference)
Method: (setf node-value) NEWVAL (SELF entity-reference)
Source

rune-impl.lisp (file)

Method: node-value (SELF entity)
Method: (setf node-value) NEWVAL (SELF entity)
Source

rune-impl.lisp (file)

Method: node-value (SELF notation)
Method: (setf node-value) NEWVAL (SELF notation)
Source

rune-impl.lisp (file)

Method: node-value (SELF document-type)
Method: (setf node-value) NEWVAL (SELF document-type)
Source

rune-impl.lisp (file)

Method: node-value (SELF element)
Method: (setf node-value) NEWVAL (SELF element)
Source

rune-impl.lisp (file)

Method: node-value (SELF attribute)
Method: (setf node-value) NEWVAL (SELF attribute)
Source

rune-impl.lisp (file)

Method: node-value (SELF character-data)
Method: (setf node-value) NEWVAL (SELF character-data)
Source

rune-impl.lisp (file)

Method: node-value (SELF document-fragment)
Method: (setf node-value) NEWVAL (SELF document-fragment)
Source

rune-impl.lisp (file)

Method: node-value (SELF document)
Method: (setf node-value) NEWVAL (SELF document)
Source

rune-impl.lisp (file)

Generic Function: normalize NODE
Package

dom

Methods
Method: normalize (NODE node)
Source

rune-impl.lisp (file)

Generic Function: notation-declaration HANDLER NAME PUBLIC-ID SYSTEM-ID

Called when a notation declaration is seen while parsing a DTD.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: notation-declaration (HANDLER klacks-dtd-handler) NAME PUBLIC-ID SYSTEM-ID
Source

klacks-impl.lisp (file)

Method: notation-declaration (HANDLER dom-builder) NAME PUBLIC-ID SYSTEM-ID
Source

rune-builder.lisp (file)

Method: notation-declaration (HANDLER broadcast-handler) NAME PUBLIC-ID SYSTEM-ID
Source

sax-proxy.lisp (file)

Method: notation-declaration (HANDLER recoder) NAME PUBLIC-ID SYSTEM-ID
Source

recoder.lisp (file)

Method: notation-declaration (SINK sink) NAME PUBLIC-ID SYSTEM-ID
Source

unparse.lisp (file)

Method: notation-declaration (HANDLER null) NAME PUBLIC-ID SYSTEM-ID
Method: notation-declaration HANDLER NAME PUBLIC-ID SYSTEM-ID
Method: notation-declaration (HANDLER abstract-handler) NAME PUBLIC-ID SYSTEM-ID
Method: notation-declaration (HANDLER content-handler) NAME PUBLIC-ID SYSTEM-ID
Method: notation-declaration (HANDLER abstract-handler) NAME PUBLIC-ID SYSTEM-ID
Generic Function: notation-name OBJECT
Package

dom

Methods
Method: notation-name (ENTITY entity)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: notation-p OBJECT
Package

dom

Methods
Method: notation-p OBJECT
Source

rune-impl.lisp (file)

Method: notation-p (OBJECT notation)
Source

rune-impl.lisp (file)

Generic Function: notations OBJECT
Package

dom

Methods
Method: notations (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: owner-document OBJECT
Package

dom

Methods
Method: owner-document (NODE node)
Source

rune-impl.lisp (file)

Method: owner-document (NAMED-NODE-MAP named-node-map)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: owner-element OBJECT
Package

dom

Methods
Method: owner-element (ATTRIBUTE attribute)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: parent-node NODE
Package

dom

Methods
Method: parent-node (NODE node)
Source

rune-impl.lisp (file)

Generic Function: peek SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: peek (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: peek (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: peek-next SOURCE
Package

klacks

Methods
Method: peek-next (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: peek-next (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: peek-value SOURCE
Package

klacks

Source

klacks.lisp (file)

Methods
Method: peek-value (SOURCE tapping-source)
Source

tap-source.lisp (file)

Method: peek-value (SOURCE cxml-source)
Source

klacks-impl.lisp (file)

Generic Function: prefix NODE
Generic Function: (setf prefix) NEWVAL NODE
Package

dom

Methods
Method: prefix (NAMESPACE-MIXIN namespace-mixin)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: (setf prefix) NEWVAL (NODE namespace-mixin)
Source

rune-impl.lisp (file)

Method: prefix (NODE node)
Source

rune-impl.lisp (file)

Method: (setf prefix) NEWVAL (NODE element) after
Source

rune-impl.lisp (file)

Method: (setf prefix) NEWVAL (NODE attribute) after
Source

rune-impl.lisp (file)

Method: (setf prefix) NEWVAL (NODE attribute) before
Source

rune-impl.lisp (file)

Generic Function: previous-sibling NODE
Package

dom

Methods
Method: previous-sibling (NODE node)
Source

rune-impl.lisp (file)

Generic Function: processing-instruction HANDLER TARGET DATA

Called when a processing instruction is read.

Both target and data are rods.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: processing-instruction (HANDLER dom-builder) TARGET DATA
Source

rune-builder.lisp (file)

Method: processing-instruction (HANDLER broadcast-handler) TARGET DATA
Source

sax-proxy.lisp (file)

Method: processing-instruction (HANDLER recoder) TARGET DATA
Source

recoder.lisp (file)

Method: processing-instruction (SINK sink) TARGET DATA
Source

unparse.lisp (file)

Method: processing-instruction (HANDLER null) TARGET DATA
Method: processing-instruction HANDLER TARGET DATA
Method: processing-instruction (HANDLER abstract-handler) TARGET DATA
Method: processing-instruction (HANDLER default-handler) TARGET DATA
Method: processing-instruction (HANDLER abstract-handler) TARGET DATA
Generic Function: processing-instruction-p OBJECT
Package

dom

Methods
Method: processing-instruction-p OBJECT
Source

rune-impl.lisp (file)

Method: processing-instruction-p (OBJECT processing-instruction)
Source

rune-impl.lisp (file)

Generic Function: proxy-chained-handler INSTANCE
Generic Function: (setf proxy-chained-handler) NEWVAL INSTANCE
Package

cxml

Methods
Method: proxy-chained-handler (INSTANCE sax-proxy)

@arg[instance]{A @class{sax-proxy}.}
@return{A @class{SAX handler}s.}

Returns the SAX handler that is chained to this SAX proxy.

Source

sax-proxy.lisp (file)

Method: (setf proxy-chained-handler) NEWVAL (INSTANCE sax-proxy)
Source

sax-proxy.lisp (file)

Generic Function: public-id OBJECT
Package

dom

Methods
Method: public-id (ENTITY entity)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: public-id (NOTATION notation)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: public-id (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: register-sax-parser HANDLER SAX-PARSER

Set the SAX-PARSER instance of this handler.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: register-sax-parser (HANDLER broadcast-handler) PARSER after
Source

sax-proxy.lisp (file)

Method: register-sax-parser (HANDLER null) SAX-PARSER
Method: register-sax-parser (HANDLER sax-parser-mixin) SAX-PARSER
Method: register-sax-parser HANDLER SAX-PARSER
Method: register-sax-parser (HANDLER abstract-handler) SAX-PARSER
Generic Function: remove-attribute ELEMENT NAME
Package

dom

Methods
Method: remove-attribute (ELEMENT element) NAME
Source

rune-impl.lisp (file)

Generic Function: remove-attribute-node ELEMENT OLD-ATTR
Package

dom

Methods
Method: remove-attribute-node (ELEMENT element) (OLD-ATTR attribute)
Source

rune-impl.lisp (file)

Generic Function: remove-attribute-ns ELT URI LNAME
Package

dom

Methods
Method: remove-attribute-ns (ELT element) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: remove-child NODE OLD-CHILD
Package

dom

Methods
Method: remove-child (NODE node) (OLD-CHILD node)
Source

rune-impl.lisp (file)

Generic Function: remove-named-item SELF NAME
Package

dom

Methods
Method: remove-named-item (SELF attribute-node-map) NAME
Source

rune-impl.lisp (file)

Method: remove-named-item (SELF named-node-map) NAME
Source

rune-impl.lisp (file)

Generic Function: remove-named-item-ns SELF URI LNAME
Package

dom

Methods
Method: remove-named-item-ns (SELF attribute-node-map) URI LNAME
Source

rune-impl.lisp (file)

Method: remove-named-item-ns (SELF named-node-map) URI LNAME
Source

rune-impl.lisp (file)

Generic Function: replace-child NODE NEW-CHILD OLD-CHILD
Package

dom

Methods
Method: replace-child (NODE node) (NEW-CHILD document-fragment) (OLD-CHILD node)
Source

rune-impl.lisp (file)

Method: replace-child (NODE node) (NEW-CHILD node) (OLD-CHILD node)
Source

rune-impl.lisp (file)

Generic Function: replace-data NODE OFFSET COUNT ARG
Package

dom

Methods
Method: replace-data (NODE character-data) OFFSET COUNT ARG
Source

rune-impl.lisp (file)

Generic Function: sax-parser OBJECT
Package

sax

Methods
Method: sax-parser (SAX-PARSER-MIXIN sax-parser-mixin)

automatically generated reader method

Source

sax-handler.lisp (file)

Generic Function: set-attribute ELEMENT NAME VALUE
Package

dom

Methods
Method: set-attribute (ELEMENT element) NAME VALUE
Source

rune-impl.lisp (file)

Generic Function: set-attribute-node ELEMENT NEW-ATTR
Package

dom

Methods
Method: set-attribute-node (ELEMENT element) (NEW-ATTR attribute)
Source

rune-impl.lisp (file)

Generic Function: set-attribute-node-ns ELEMENT NEW-ATTR
Package

dom

Methods
Method: set-attribute-node-ns (ELEMENT element) (NEW-ATTR attribute)
Source

rune-impl.lisp (file)

Generic Function: set-attribute-ns ELEMENT URI LNAME VALUE
Package

dom

Methods
Method: set-attribute-ns (ELEMENT element) URI LNAME VALUE
Source

rune-impl.lisp (file)

Generic Function: set-named-item SELF ARG
Package

dom

Methods
Method: set-named-item (SELF attribute-node-map) ARG after
Source

rune-impl.lisp (file)

Method: set-named-item (SELF named-node-map) ARG
Source

rune-impl.lisp (file)

Generic Function: set-named-item-ns SELF ARG
Package

dom

Methods
Method: set-named-item-ns (SELF attribute-node-map) ARG after
Source

rune-impl.lisp (file)

Method: set-named-item-ns (SELF named-node-map) ARG
Source

rune-impl.lisp (file)

Generic Function: sink-encoding OBJECT
Package

cxml

Methods
Method: sink-encoding (SINK sink)

automatically generated reader method

Source

unparse.lisp (file)

Generic Function: sink-omit-xml-declaration-p OBJECT
Generic Function: (setf sink-omit-xml-declaration-p) NEW-VALUE OBJECT
Package

cxml

Methods
Method: sink-omit-xml-declaration-p (SINK sink)

automatically generated reader method

Source

unparse.lisp (file)

Method: (setf sink-omit-xml-declaration-p) NEW-VALUE (SINK sink)

automatically generated writer method

Source

unparse.lisp (file)

Generic Function: specified OBJECT
Package

dom

Methods
Method: specified (ATTRIBUTE attribute)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: split-text TEXT OFFSET
Package

dom

Methods
Method: split-text (TEXT text) OFFSET
Source

rune-impl.lisp (file)

Generic Function: start-cdata HANDLER

Called at the beginning of parsing a CDATA section.

Handlers only have to implement this if they are interested in the lexical structure of the parsed document. The content of the CDATA section is reported via the ‘characters’ generic function like all other textual content.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-cdata (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: start-cdata (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: start-cdata (HANDLER recoder)
Source

recoder.lisp (file)

Method: start-cdata (SINK sink)
Source

unparse.lisp (file)

Method: start-cdata (HANDLER validator)
Source

xml-parse.lisp (file)

Method: start-cdata (HANDLER null)
Method: start-cdata HANDLER
Method: start-cdata (HANDLER abstract-handler)
Method: start-cdata (HANDLER content-handler)
Method: start-cdata (HANDLER abstract-handler)
Generic Function: start-document HANDLER

Called at the beginning of the parsing process,
before any element, processing instruction or comment is reported.

Handlers that need to maintain internal state may use this to perform any neccessary initializations.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-document (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: start-document (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: start-document (HANDLER recoder)
Source

recoder.lisp (file)

Method: start-document (SINK sink)
Source

unparse.lisp (file)

Method: start-document (HANDLER null)
Method: start-document HANDLER
Method: start-document (HANDLER abstract-handler)
Method: start-document (HANDLER default-handler)
Method: start-document (HANDLER abstract-handler)
Generic Function: start-dtd HANDLER NAME PUBLIC-ID SYSTEM-ID

Called at the beginning of parsing a DTD.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-dtd (HANDLER dom-builder) NAME PUBLICID SYSTEMID
Source

rune-builder.lisp (file)

Method: start-dtd (HANDLER broadcast-handler) NAME PUBLIC-ID SYSTEM-ID
Source

sax-proxy.lisp (file)

Method: start-dtd (HANDLER recoder) NAME PUBLIC-ID SYSTEM-ID
Source

recoder.lisp (file)

Method: start-dtd (SINK sink) NAME PUBLIC-ID SYSTEM-ID
Source

unparse.lisp (file)

Method: start-dtd (HANDLER null) NAME PUBLIC-ID SYSTEM-ID
Method: start-dtd HANDLER NAME PUBLIC-ID SYSTEM-ID
Method: start-dtd (HANDLER abstract-handler) NAME PUBLIC-ID SYSTEM-ID
Method: start-dtd (HANDLER content-handler) NAME PUBLIC-ID SYSTEM-ID
Method: start-dtd (HANDLER abstract-handler) NAME PUBLIC-ID SYSTEM-ID
Generic Function: start-element HANDLER NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES

Called to report the beginning of an element.

There will always be a corresponding call to end-element, even in the case of an empty element (i.e. <foo/>).

If the value of *namespaces* is non-nil, namespace-uri, local-name and qname are rods. If it is nil, namespace-uri and local-name are always nil, and it is not an error if the qname is not a well-formed qualified element name (for example, if it contains more than one colon).

The attributes parameter is a list (in arbitrary order) of instances of the ‘attribute’ structure class. The for their namespace-uri and local-name properties, the same rules as for the element name apply. Additionally, namespace-declaring attributes (those whose name is "xmlns" or starts with "xmlns:") are only included if *include-xmlns-attributes* is non-nil.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-element (HANDLER dom-builder) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Source

rune-builder.lisp (file)

Method: start-element (HANDLER broadcast-handler) URI LNAME QNAME ATTRIBUTES
Source

sax-proxy.lisp (file)

Method: start-element (HANDLER catalog-parser) URI LNAME QNAME ATTRS
Source

catalog.lisp (file)

Method: start-element (HANDLER whitespace-normalizer) URI LNAME QNAME ATTRS
Source

space-normalizer.lisp (file)

Method: start-element (HANDLER namespace-normalizer) URI LNAME QNAME ATTRS
Source

xmlns-normalizer.lisp (file)

Method: start-element (HANDLER recoder) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Source

recoder.lisp (file)

Method: start-element (HANDLER xmls-builder) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Source

xmls-compat.lisp (file)

Method: start-element (SINK sink) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Source

unparse.lisp (file)

Method: start-element (HANDLER validator) URI LNAME QNAME ATTRIBUTES
Source

xml-parse.lisp (file)

Method: start-element (HANDLER null) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Method: start-element HANDLER NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Method: start-element (HANDLER abstract-handler) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Method: start-element (HANDLER default-handler) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Method: start-element (HANDLER abstract-handler) NAMESPACE-URI LOCAL-NAME QNAME ATTRIBUTES
Generic Function: start-internal-subset HANDLER

Reports that an internal subset is present. Called before any definition from the internal subset is reported.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-internal-subset (HANDLER klacks-dtd-handler)
Source

klacks-impl.lisp (file)

Method: start-internal-subset (HANDLER dom-builder)
Source

rune-builder.lisp (file)

Method: start-internal-subset (HANDLER broadcast-handler)
Source

sax-proxy.lisp (file)

Method: start-internal-subset (HANDLER recoder)
Source

recoder.lisp (file)

Method: start-internal-subset (SINK sink)
Source

unparse.lisp (file)

Method: start-internal-subset (HANDLER null)
Method: start-internal-subset HANDLER
Method: start-internal-subset (HANDLER abstract-handler)
Method: start-internal-subset (HANDLER content-handler)
Method: start-internal-subset (HANDLER abstract-handler)
Generic Function: start-prefix-mapping HANDLER PREFIX URI

Called when the scope of a new prefix -> namespace-uri mapping begins.

This will always be called immediatly before the ‘start-element’ event for the element on which the namespaces are declared.

Clients don’t usually have to implement this except under special circumstances, for example when they have to deal with qualified names in textual content. The parser will handle namespaces of elements and attributes on its own.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: start-prefix-mapping (HANDLER broadcast-handler) PREFIX URI
Source

sax-proxy.lisp (file)

Method: start-prefix-mapping (HANDLER recoder) PREFIX URI
Source

recoder.lisp (file)

Method: start-prefix-mapping (HANDLER null) PREFIX URI
Method: start-prefix-mapping HANDLER PREFIX URI
Method: start-prefix-mapping (HANDLER abstract-handler) PREFIX URI
Method: start-prefix-mapping (HANDLER content-handler) PREFIX URI
Method: start-prefix-mapping (HANDLER abstract-handler) PREFIX URI
Generic Function: substring-data NODE OFFSET COUNT
Package

dom

Methods
Method: substring-data (NODE character-data) OFFSET COUNT
Source

rune-impl.lisp (file)

Generic Function: system-id OBJECT
Package

dom

Methods
Method: system-id (ENTITY entity)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: system-id (NOTATION notation)

automatically generated reader method

Source

rune-impl.lisp (file)

Method: system-id (DOCUMENT-TYPE document-type)

automatically generated reader method

Source

rune-impl.lisp (file)

Generic Function: system-id SAX-PARSER

Return the URI of the document being parsed. This is either the main document, or the entity’s system ID while contents of a parsed general external entity are being processed.

Package

sax

Source

sax-handler.lisp (file)

Methods
Method: system-id (PARSER klacksax)
Source

klacks.lisp (file)

Method: system-id (PARSER cxml-parser)
Source